laag-nasm 2.13.03.2

data/vendor/repo.or.cz/nasm/rdoff/doc/v1-v2.txt

@@ -0,0 +1,62 @@
+Differences between RDOFF versions 1 & 2
+========================================
+
+This document is designed primarily for people maintaining code which
+uses RDOFF version 1, and would like to upgrade that code to work
+with version 2.
+
+The main changes are summarised here:
+
+Overall format
+==============
+
+The overall format has changed somewhat since version 1, in order
+to make RDOFF more flexible. After the file type identifier (which
+has been changed to 'RDOFF2', obviously), there is now a 4 byte
+integer describing the length of the object module. This allows
+multiple objects to be concatenated, while the loader can easily
+build an index of the locations of each object. This isn't as
+pointless as it sounds; I'm using RDOFF in a microkernel operating
+system, and this is the ideal way of loading multiple driver modules
+at boot time.
+
+There are also no longer a fixed number of segments; instead there
+is a list of segments, immediately following the header.
+Each segment is preceded by a 10 byte header giving information about
+that segment. This header has the following format:
+
+Length	Description
+2	Type
+2	Number
+2	Reserved
+4	Length
+
+'Type' is a number describing what sort of segment it is (eg text, data,
+comment, debug info). See 'rdoff2.txt' for a list of the segment types.
+'Number' is the number used to refer to the segment in the header records.
+Not all segments will be loaded; it is only intended that one code
+and one data segment will be loaded into memory. It is possible, however,
+for a loaded segment to contain a reference to an unloaded segment.
+This is an error, and should be flagged at load time. Or maybe you should
+load the segment... its up to you, really.
+
+The segment's data immediately follows the end of the segment header.
+
+HEADER RECORDS
+==============
+
+All of the header records have changed in this version, but not
+substantially. Each record type has had a content-length code added,
+a single byte immediately following the type byte. This contains the
+length of the rest of the record (excluding the type and length bytes,
+but including the terminating nulls on any strings in the record).
+
+There are two new record types, Segment Relocation (6), and FAR import (7).
+The record formats are identical to Relocation (1) and import (2). They are
+only of real use on systems using segmented architectures. Systems using
+a flat model should treat FAR import (7) exactly the same as an import (2),
+and should either flag segment relocation as an error, or attempt to figure
+out whether it is a reference to a code or data symbol, and set the value
+referenced to the according selector value. I am opting for the former
+approach, and would recommend that others working on 32 bit flat systems
+do the same.

data/vendor/repo.or.cz/nasm/rdoff/hash.c

@@ -0,0 +1,122 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * hash.h     Routines to calculate a CRC32 hash value
+ *
+ *   These routines donated to the NASM effort by Graeme Defty.
+ */
+
+#include "compiler.h"
+
+#include "hash.h"
+
+const uint32_t consttab[] = {
+    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
+    0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
+    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
+    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
+    0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
+    0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
+    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
+    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
+    0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
+    0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
+    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
+    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
+    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
+    0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
+    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
+    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
+    0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
+    0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
+    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
+    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
+    0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
+    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
+    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
+    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
+    0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
+    0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
+    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
+    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
+    0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
+    0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
+    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
+    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
+    0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
+    0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
+    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
+    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
+    0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
+    0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
+    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
+    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
+    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
+    0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
+    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+};
+
+uint32_t hash(const char *name)
+{
+    register const char *n;
+    register uint32_t hashval = 0xffffffff;
+
+    for (n = name; *n; n++)
+        hashval = (hashval >> 8) ^ consttab[(hashval ^ *n) & 0xff];
+
+    hashval ^= 0xffffffff;
+
+    return hashval;
+}

data/vendor/repo.or.cz/nasm/rdoff/hash.h

@@ -0,0 +1,17 @@
+/* hash.h     Routines to calculate a CRC32 hash value
+ *
+ *   These routines donated to the NASM effort by Graeme Defty.
+ *
+ * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the license given in the file "LICENSE"
+ * distributed in the NASM archive.
+ */
+
+#ifndef RDOFF_HASH_H
+#define RDOFF_HASH_H 1
+
+
+uint32_t hash(const char *name);
+
+#endif

data/vendor/repo.or.cz/nasm/rdoff/ldrdf.1

@@ -0,0 +1,41 @@
+.TH LDRDF 1 "September 6, 1999" "Debian Project" "Debian Manual"
+.SH NAME
+ldrdf \- link RDOFF objects and libraries produced by rdflib(1)
+.SH SYNOPSIS
+.B ldrdf
+.RI "[-o " output-file ]
+.I object-file\c
+.RI "... [-l" library "...]"
+.SH DESCRIPTION
+.B ldrdf
+is a version of unix
+.BR ld (1)
+(or DOS LINK) for use with RDOFF files.  It is capable of linking RDOFF
+objects, and libraries produced with the
+.BR rdflib (1)
+utility.
+.PP
+Libraries must be specified with their path as no search is performed.
+Modules in libraries are not linked to the program unless they are
+referred to.
+.SH OPTIONS
+.TP
+.RI "-o " output-file
+Specify an output file.  The default output filename is
+.RI ' aout.rdx '.
+.TP
+-v
+Increase verbosity level.  Currently 4 verbosity levels are available:
+default (which only prints error information), normal (which prints
+information about the produced object, -v), medium (which prints information
+about what the program is doing, -v -v) and high (which prints all available
+information, -v -v -v).
+.TP
+-p
+Change alignment value to which multiple segments combigned into a single
+segment should be aligned (must be either 1, 2, 4, 8, 16, 32 or 256; default
+is 16).
+.SH AUTHORS
+Julian Hall <jules@earthcorp.com>.
+.PP
+This manual page was written by Matej Vela <vela@debian.org>.

data/vendor/repo.or.cz/nasm/rdoff/ldrdf.c

@@ -0,0 +1,1395 @@
+/* ----------------------------------------------------------------------- *
+ *
+ *   Copyright 1996-2014 The NASM Authors - All Rights Reserved
+ *   See the file AUTHORS included with the NASM distribution for
+ *   the specific copyright holders.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following
+ *   conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *
+ *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
+ *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ----------------------------------------------------------------------- */
+
+/*
+ * ldrdf.c - RDOFF Object File linker/loader main program.
+ */
+
+/*
+ * TODO:
+ * - enhance search of required export symbols in libraries (now depends
+ *   on modules order in library)
+ * - keep a cache of symbol names in each library module so
+ *   we don't have to constantly recheck the file
+ * - general performance improvements
+ *
+ * BUGS & LIMITATIONS: this program doesn't support multiple code, data
+ * or bss segments, therefore for 16 bit programs whose code, data or BSS
+ * segment exceeds 64K in size, it will not work. This program probably
+ * won't work if compiled by a 16 bit compiler. Try DJGPP if you're running
+ * under DOS. '#define STINGY_MEMORY' may help a little.
+ */
+
+#include "compiler.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "rdfutils.h"
+#include "symtab.h"
+#include "collectn.h"
+#include "rdlib.h"
+#include "segtab.h"
+#include "nasmlib.h"
+
+#define LDRDF_VERSION "1.08"
+
+/* #define STINGY_MEMORY */
+
+/* =======================================================================
+ * Types & macros that are private to this program
+ */
+
+struct segment_infonode {
+    int dest_seg;               /* output segment to be placed into, -1 to
+                                   skip linking this segment */
+    int32_t reloc;                 /* segment's relocation factor */
+};
+
+struct modulenode {
+    rdffile f;                  /* the RDOFF file structure */
+    struct segment_infonode seginfo[RDF_MAXSEGS];       /* what are we doing
+                                                           with each segment? */
+    void *header;
+    char *name;
+    struct modulenode *next;
+    int32_t bss_reloc;
+};
+
+#include "ldsegs.h"
+
+/* ==========================================================================
+ * Function prototypes of private utility functions
+ */
+
+void processmodule(const char *filename, struct modulenode *mod);
+int allocnewseg(uint16_t type, uint16_t reserved);
+int findsegment(uint16_t type, uint16_t reserved);
+void symtab_add(const char *symbol, int segment, int32_t offset);
+int symtab_get(const char *symbol, int *segment, int32_t *offset);
+
+/* =========================================================================
+ * Global data structures.
+ */
+
+/* a linked list of modules that will be included in the output */
+struct modulenode *modules = NULL;
+struct modulenode *lastmodule = NULL;
+
+/* a linked list of libraries to be searched for unresolved imported symbols */
+struct librarynode *libraries = NULL;
+struct librarynode *lastlib = NULL;
+
+/* the symbol table */
+void *symtab = NULL;
+
+/* objects search path */
+char *objpath = NULL;
+
+/* libraries search path */
+char *libpath = NULL;
+
+/* file to embed as a generic record */
+char *generic_rec_file = NULL;
+
+/* module name to be added at the beginning of output file */
+char *modname_specified = NULL;
+
+/* error file */
+static FILE *error_file;
+
+/* the header of the output file, built up stage by stage */
+rdf_headerbuf *newheader = NULL;
+
+/* The current state of segment allocation, including information about
+ * which output segment numbers have been allocated, and their types and
+ * amount of data which has already been allocated inside them.
+ */
+struct SegmentHeaderRec outputseg[RDF_MAXSEGS];
+int nsegs = 0;
+int32_t bss_length;
+
+/* global options which affect how the program behaves */
+struct ldrdfoptions {
+    int verbose;
+    int align;
+    int dynalink;
+    int strip;
+    int respfile;
+    int stderr_redir;
+    int objpath;
+    int libpath;
+} options;
+
+int errorcount = 0;             /* determines main program exit status */
+
+/* =========================================================================
+ * Utility functions
+ */
+
+/*
+ * initsegments()
+ *
+ * sets up segments 0, 1, and 2, the initial code data and bss segments
+ */
+static void initsegments(void)
+{
+    nsegs = 3;
+    outputseg[0].type = 1;
+    outputseg[0].number = 0;
+    outputseg[0].reserved = 0;
+    outputseg[0].length = 0;
+    outputseg[1].type = 2;
+    outputseg[1].number = 1;
+    outputseg[1].reserved = 0;
+    outputseg[1].length = 0;
+    outputseg[2].type = 0xFFFF; /* reserved segment type */
+    outputseg[2].number = 2;
+    outputseg[2].reserved = 0;
+    outputseg[2].length = 0;
+    bss_length = 0;
+}
+
+/*
+ * loadmodule()
+ *
+ * Determine the characteristics of a module, and decide what to do with
+ * each segment it contains (including determining destination segments and
+ * relocation factors for segments that	are kept).
+ */
+static void loadmodule(const char *filename)
+{
+    if (options.verbose)
+        printf("loading `%s'\n", filename);
+
+    /* allocate a new module entry on the end of the modules list */
+    if (!modules) {
+        modules = nasm_malloc(sizeof(*modules));
+        lastmodule = modules;
+    } else {
+        lastmodule->next = nasm_malloc(sizeof(*modules));
+        lastmodule = lastmodule->next;
+    }
+
+    if (!lastmodule) {
+        fprintf(stderr, "ldrdf: out of memory\n");
+        exit(1);
+    }
+
+    /* open the file using 'rdfopen', which returns nonzero on error */
+    if (rdfopen(&lastmodule->f, filename) != 0) {
+        rdfperror("ldrdf", filename);
+        exit(1);
+    }
+
+    /*
+     * store information about the module, and determine what segments
+     * it contains, and what we should do with them (determine relocation
+     * factor if we decide to keep them)
+     */
+    lastmodule->header = NULL;
+    lastmodule->name = nasm_strdup(filename);
+    lastmodule->next = NULL;
+
+    processmodule(filename, lastmodule);
+}
+
+/*
+ * processmodule()
+ *
+ * step through each segment, determine what exactly we're doing with
+ * it, and if we intend to keep it, determine (a) which segment to
+ * put it in and (b) whereabouts in that segment it will end up.
+ * (b) is fairly easy, because we're now keeping track of how big each
+ * segment in our output file is...
+ */
+void processmodule(const char *filename, struct modulenode *mod)
+{
+    struct segconfig sconf;
+    int seg, outseg;
+    void *header;
+    rdfheaderrec *hr;
+    int32_t bssamount = 0;
+    int bss_was_referenced = 0;
+
+    memset(&sconf, 0, sizeof sconf);
+
+    for (seg = 0; seg < mod->f.nsegs; seg++) {
+        /*
+         * get the segment configuration for this type from the segment
+         * table. getsegconfig() is a macro, defined in ldsegs.h.
+         */
+        getsegconfig(sconf, mod->f.seg[seg].type);
+
+        if (options.verbose > 1) {
+            printf("%s %04x [%04x:%10s] ", filename,
+                   mod->f.seg[seg].number, mod->f.seg[seg].type,
+                   sconf.typedesc);
+        }
+        /*
+         * sconf->dowhat tells us what to do with a segment of this type.
+         */
+        switch (sconf.dowhat) {
+        case SEG_IGNORE:
+            /*
+             * Set destination segment to -1, to indicate that this segment
+             * should be ignored for the purpose of output, ie it is left
+             * out of the linked executable.
+             */
+            mod->seginfo[seg].dest_seg = -1;
+            if (options.verbose > 1)
+                printf("IGNORED\n");
+            break;
+
+        case SEG_NEWSEG:
+            /*
+             * The configuration tells us to create a new segment for
+             * each occurrence of this segment type.
+             */
+            outseg = allocnewseg(sconf.mergetype,
+                                 mod->f.seg[seg].reserved);
+            mod->seginfo[seg].dest_seg = outseg;
+            mod->seginfo[seg].reloc = 0;
+            outputseg[outseg].length = mod->f.seg[seg].length;
+            if (options.verbose > 1)
+                printf("=> %04x:%08"PRIx32" (+%04"PRIx32")\n", outseg,
+                       mod->seginfo[seg].reloc, mod->f.seg[seg].length);
+            break;
+
+        case SEG_MERGE:
+            /*
+             * The configuration tells us to merge the segment with
+             * a previously existing segment of type 'sconf.mergetype',
+             * if one exists. Otherwise a new segment is created.
+             * This is handled transparently by 'findsegment()'.
+             */
+            outseg = findsegment(sconf.mergetype,
+                                 mod->f.seg[seg].reserved);
+            mod->seginfo[seg].dest_seg = outseg;
+
+            /*
+             * We need to add alignment to these segments.
+             */
+            if (outputseg[outseg].length % options.align != 0)
+                outputseg[outseg].length +=
+                    options.align -
+                    (outputseg[outseg].length % options.align);
+
+            mod->seginfo[seg].reloc = outputseg[outseg].length;
+            outputseg[outseg].length += mod->f.seg[seg].length;
+
+            if (options.verbose > 1)
+                printf("=> %04x:%08"PRIx32" (+%04"PRIx32")\n", outseg,
+                       mod->seginfo[seg].reloc, mod->f.seg[seg].length);
+        }
+
+    }
+
+    /*
+     * extract symbols from the header, and dump them into the
+     * symbol table
+     */
+    header = nasm_malloc(mod->f.header_len);
+    if (!header) {
+        fprintf(stderr, "ldrdf: not enough memory\n");
+        exit(1);
+    }
+    if (rdfloadseg(&mod->f, RDOFF_HEADER, header)) {
+        rdfperror("ldrdf", filename);
+        exit(1);
+    }
+
+    while ((hr = rdfgetheaderrec(&mod->f))) {
+        switch (hr->type) {
+        case RDFREC_IMPORT:    /* imported symbol */
+        case RDFREC_FARIMPORT:
+            /* Define with seg = -1 */
+            symtab_add(hr->i.label, -1, 0);
+            break;
+
+        case RDFREC_GLOBAL:{   /* exported symbol */
+                int destseg;
+                int32_t destreloc;
+
+                if (hr->e.segment == 2) {
+                    bss_was_referenced = 1;
+                    destreloc = bss_length;
+                    if (destreloc % options.align != 0)
+                        destreloc +=
+                            options.align - (destreloc % options.align);
+                    destseg = 2;
+                } else {
+                    if ((destseg =
+                         mod->seginfo[(int)hr->e.segment].dest_seg) == -1)
+                        continue;
+                    destreloc = mod->seginfo[(int)hr->e.segment].reloc;
+                }
+                symtab_add(hr->e.label, destseg, destreloc + hr->e.offset);
+                break;
+            }
+
+        case RDFREC_BSS:       /* BSS reservation */
+            /*
+             * first, amalgamate all BSS reservations in this module
+             * into one, because we allow this in the output format.
+             */
+            bssamount += hr->b.amount;
+            break;
+
+        case RDFREC_COMMON:{   /* Common variable */
+                symtabEnt *ste = symtabFind(symtab, hr->c.label);
+
+                /* Is the symbol already in the table? */
+                if (ste)
+                    break;
+
+                /* Align the variable */
+                if (bss_length % hr->c.align != 0)
+                    bss_length += hr->c.align - (bss_length % hr->c.align);
+                if (options.verbose > 1) {
+                    printf("%s %04x common '%s' => 0002:%08"PRIx32" (+%04"PRIx32")\n",
+                           filename, hr->c.segment, hr->c.label,
+                           bss_length, hr->c.size);
+                }
+
+                symtab_add(hr->c.label, 2, bss_length);
+                mod->bss_reloc = bss_length;
+                bss_length += hr->c.size;
+                break;
+            }
+        }
+    }
+
+    if (bssamount != 0 || bss_was_referenced) {
+        /*
+         * handle the BSS segment - first pad the existing bss length
+         * to the correct alignment, then store the length in bss_reloc
+         * for this module. Then add this module's BSS length onto
+         * bss_length.
+         */
+        if (bss_length % options.align != 0)
+            bss_length += options.align - (bss_length % options.align);
+
+        mod->bss_reloc = bss_length;
+        if (options.verbose > 1) {
+            printf("%s 0002 [            BSS] => 0002:%08"PRIx32" (+%04"PRIx32")\n",
+                   filename, bss_length, bssamount);
+        }
+        bss_length += bssamount;
+    }
+#ifdef STINGY_MEMORY
+    /*
+     * we free the header buffer here, to save memory later.
+     * this isn't efficient, but probably halves the memory usage
+     * of this program...
+     */
+    mod->f.header_loc = NULL;
+    nasm_free(header);
+
+#endif
+
+}
+
+/*
+ * Return 1 if a given module is in the list, 0 otherwise.
+ */
+static int lookformodule(const char *name)
+{
+    struct modulenode *curr = modules;
+
+    while (curr) {
+        if (!strcmp(name, curr->name))
+            return 1;
+        curr = curr->next;
+    }
+    return 0;
+}
+
+/*
+ * allocnewseg()
+ * findsegment()
+ *
+ * These functions manipulate the array of output segments, and are used
+ * by processmodule(). allocnewseg() allocates a segment in the array,
+ * initialising it to be empty. findsegment() first scans the array for
+ * a segment of the type requested, and if one isn't found allocates a
+ * new one.
+ */
+int allocnewseg(uint16_t type, uint16_t reserved)
+{
+    outputseg[nsegs].type = type;
+    outputseg[nsegs].number = nsegs;
+    outputseg[nsegs].reserved = reserved;
+    outputseg[nsegs].length = 0;
+    outputseg[nsegs].offset = 0;
+    outputseg[nsegs].data = NULL;
+
+    return nsegs++;
+}
+
+int findsegment(uint16_t type, uint16_t reserved)
+{
+    int i;
+
+    for (i = 0; i < nsegs; i++)
+        if (outputseg[i].type == type)
+            return i;
+
+    return allocnewseg(type, reserved);
+}
+
+/*
+ * symtab_add()
+ *
+ * inserts a symbol into the global symbol table, which associates symbol
+ * names either with addresses, or a marker that the symbol hasn't been
+ * resolved yet, or possibly that the symbol has been defined as
+ * contained in a dynamic [load time/run time] linked library.
+ *
+ * segment = -1 => not yet defined
+ * segment = -2 => defined as dll symbol
+ *
+ * If the symbol is already defined, and the new segment >= 0, then
+ * if the original segment was < 0 the symbol is redefined, otherwise
+ * a duplicate symbol warning is issued. If new segment == -1, this
+ * routine won't change a previously existing symbol. It will change
+ * to segment = -2 only if the segment was previously < 0.
+ */
+void symtab_add(const char *symbol, int segment, int32_t offset)
+{
+    symtabEnt *ste;
+
+    ste = symtabFind(symtab, symbol);
+    if (ste) {
+        if (ste->segment >= 0) {
+            /*
+             * symbol previously defined
+             */
+            if (segment < 0)
+                return;
+            fprintf(error_file, "warning: `%s' redefined\n", symbol);
+            return;
+        }
+
+        /*
+         * somebody wanted the symbol, and put an undefined symbol
+         * marker into the table
+         */
+        if (segment == -1)
+            return;
+        /*
+         * we have more information now - update the symbol's entry
+         */
+        ste->segment = segment;
+        ste->offset = offset;
+        ste->flags = 0;
+        return;
+    }
+    /*
+     * this is the first declaration of this symbol
+     */
+    ste = nasm_malloc(sizeof(symtabEnt));
+    if (!ste) {
+        fprintf(stderr, "ldrdf: out of memory\n");
+        exit(1);
+    }
+    ste->name = nasm_strdup(symbol);
+    ste->segment = segment;
+    ste->offset = offset;
+    ste->flags = 0;
+    symtabInsert(symtab, ste);
+}
+
+/*
+ * symtab_get()
+ *
+ * Retrieves the values associated with a symbol. Undefined symbols
+ * are assumed to have -1:0 associated. Returns 1 if the symbol was
+ * successfully located.
+ */
+int symtab_get(const char *symbol, int *segment, int32_t *offset)
+{
+    symtabEnt *ste = symtabFind(symtab, symbol);
+    if (!ste) {
+        *segment = -1;
+        *offset = 0;
+        return 0;
+    } else {
+        *segment = ste->segment;
+        *offset = ste->offset;
+        return 1;
+    }
+}
+
+/*
+ * add_library()
+ *
+ * checks that a library can be opened and is in the correct format,
+ * then adds it to the linked list of libraries.
+ */
+static void add_library(const char *name)
+{
+    if (rdl_verify(name)) {
+        rdl_perror("ldrdf", name);
+        errorcount++;
+        return;
+    }
+    if (!libraries) {
+        lastlib = libraries = nasm_malloc(sizeof(*libraries));
+        if (!libraries) {
+            fprintf(stderr, "ldrdf: out of memory\n");
+            exit(1);
+        }
+    } else {
+        lastlib->next = nasm_malloc(sizeof(*libraries));
+        if (!lastlib->next) {
+            fprintf(stderr, "ldrdf: out of memory\n");
+            exit(1);
+        }
+        lastlib = lastlib->next;
+    }
+    lastlib->next = NULL;
+    if (rdl_open(lastlib, name)) {
+        rdl_perror("ldrdf", name);
+        errorcount++;
+        return;
+    }
+}
+
+/*
+ * search_libraries()
+ *
+ * scans through the list of libraries, attempting to match symbols
+ * defined in library modules against symbols that are referenced but
+ * not defined (segment = -1 in the symbol table)
+ *
+ * returns 1 if any extra library modules are included, indicating that
+ * another pass through the library list should be made (possibly).
+ */
+static int search_libraries(void)
+{
+    struct librarynode *cur;
+    rdffile f;
+    int i;
+    void *header;
+    int segment;
+    int32_t offset;
+    int doneanything = 0, pass = 1, keepfile;
+    rdfheaderrec *hr;
+
+    cur = libraries;
+
+    while (cur) {
+        if (options.verbose > 2)
+            printf("scanning library `%s', pass %d...\n", cur->name, pass);
+
+        for (i = 0; rdl_openmodule(cur, i, &f) == 0; i++) {
+            if (pass == 2 && lookformodule(f.name))
+                continue;
+
+            if (options.verbose > 3)
+                printf("  looking in module `%s'\n", f.name);
+
+            header = nasm_malloc(f.header_len);
+            if (!header) {
+                fprintf(stderr, "ldrdf: not enough memory\n");
+                exit(1);
+            }
+            if (rdfloadseg(&f, RDOFF_HEADER, header)) {
+                rdfperror("ldrdf", f.name);
+                errorcount++;
+                return 0;
+            }
+
+            keepfile = 0;
+
+            while ((hr = rdfgetheaderrec(&f))) {
+                /* We're only interested in exports, so skip others */
+                if (hr->type != RDFREC_GLOBAL)
+                    continue;
+
+                /*
+                 * If the symbol is marked as SYM_GLOBAL, somebody will be
+                 * definitely interested in it..
+                 */
+                if ((hr->e.flags & SYM_GLOBAL) == 0) {
+                    /*
+                     * otherwise the symbol is just public. Find it in
+                     * the symbol table. If the symbol isn't defined, we
+                     * aren't interested, so go on to the next.
+                     * If it is defined as anything but -1, we're also not
+                     * interested. But if it is defined as -1, insert this
+                     * module into the list of modules to use, and go
+                     * immediately on to the next module...
+                     */
+                    if (!symtab_get(hr->e.label, &segment, &offset)
+                        || segment != -1)
+                        continue;
+                }
+
+                doneanything = 1;
+                keepfile = 1;
+
+                /*
+                 * as there are undefined symbols, we can assume that
+                 * there are modules on the module list by the time
+                 * we get here.
+                 */
+                lastmodule->next = nasm_malloc(sizeof(*lastmodule->next));
+                if (!lastmodule->next) {
+                    fprintf(stderr, "ldrdf: not enough memory\n");
+                    exit(1);
+                }
+                lastmodule = lastmodule->next;
+                memcpy(&lastmodule->f, &f, sizeof(f));
+                lastmodule->name = nasm_strdup(f.name);
+                lastmodule->next = NULL;
+                processmodule(f.name, lastmodule);
+                break;
+            }
+            if (!keepfile) {
+                nasm_free(f.name);
+                f.name = NULL;
+                f.fp = NULL;
+            }
+        }
+        if (rdl_error != 0 && rdl_error != RDL_ENOTFOUND)
+            rdl_perror("ldrdf", cur->name);
+
+        cur = cur->next;
+        if (cur == NULL && pass == 1) {
+            cur = libraries;
+            pass++;
+        }
+    }
+
+    return doneanything;
+}
+
+/*
+ * write_output()
+ *
+ * this takes the linked list of modules, and walks through it, merging
+ * all the modules into a single output module, and then writes this to a
+ * file.
+ */
+static void write_output(const char *filename)
+{
+    FILE *f;
+    rdf_headerbuf *rdfheader;
+    struct modulenode *cur;
+    int i, n, availableseg, seg, localseg, isrelative;
+    void *header;
+    rdfheaderrec *hr, newrec;
+    symtabEnt *se;
+    segtab segs;
+    int32_t offset;
+    uint8_t *data;
+
+    if ((f = fopen(filename, "wb")) == NULL) {
+        fprintf(stderr, "ldrdf: couldn't open %s for output\n", filename);
+        exit(1);
+    }
+    if ((rdfheader = rdfnewheader()) == NULL) {
+        fprintf(stderr, "ldrdf: out of memory\n");
+        exit(1);
+    }
+
+    /*
+     * If '-g' option was given, first record in output file will be a
+     * `generic' record, filled with a given file content.
+     * This can be useful, for example, when constructing multiboot
+     * compliant kernels.
+     */
+    if (generic_rec_file) {
+        FILE *ff;
+
+        if (options.verbose)
+            printf("\nadding generic record from binary file %s\n",
+                   generic_rec_file);
+
+        hr = (rdfheaderrec *) nasm_malloc(sizeof(struct GenericRec));
+        if ((ff = fopen(generic_rec_file, "r")) == NULL) {
+            fprintf(stderr, "ldrdf: couldn't open %s for input\n",
+                    generic_rec_file);
+            exit(1);
+        }
+        n = fread(hr->g.data, 1, sizeof(hr->g.data), ff);
+        fseek(ff, 0, SEEK_END);
+        if (ftell(ff) > (long)sizeof(hr->g.data)) {
+            fprintf(error_file,
+                    "warning: maximum generic record size is %u, "
+		    "rest of file ignored\n",
+                    (unsigned int)sizeof(hr->g.data));
+        }
+        fclose(ff);
+
+        hr->g.type = RDFREC_GENERIC;
+        hr->g.reclen = n;
+        rdfaddheader(rdfheader, hr);
+        nasm_free(hr);
+    }
+
+    /*
+     * Add module name record if `-mn' option was given
+     */
+    if (modname_specified) {
+	n = strlen(modname_specified);
+
+	if ((n < 1) || (n >= MODLIB_NAME_MAX)) {
+            fprintf(stderr, "ldrdf: invalid length of module name `%s'\n",
+		modname_specified);
+            exit(1);
+        }
+
+        if (options.verbose)
+            printf("\nadding module name record %s\n", modname_specified);
+
+        hr = (rdfheaderrec *) nasm_malloc(sizeof(struct ModRec));
+	hr->m.type = RDFREC_MODNAME;
+        hr->m.reclen = n + 1;
+        strcpy(hr->m.modname, modname_specified);
+        rdfaddheader(rdfheader, hr);
+        nasm_free(hr);
+    }
+
+
+    if (options.verbose)
+        printf("\nbuilding output module (%d segments)\n", nsegs);
+
+    /*
+     * Allocate the memory for the segments. We may be better off
+     * building the output module one segment at a time when running
+     * under 16 bit DOS, but that would be a slower way of doing this.
+     * And you could always use DJGPP...
+     */
+    for (i = 0; i < nsegs; i++) {
+        outputseg[i].data = NULL;
+        if (!outputseg[i].length)
+            continue;
+        outputseg[i].data = nasm_malloc(outputseg[i].length);
+        if (!outputseg[i].data) {
+            fprintf(stderr, "ldrdf: out of memory\n");
+            exit(1);
+        }
+    }
+
+    /*
+     * initialise availableseg, used to allocate segment numbers for
+     * imported and exported labels...
+     */
+    availableseg = nsegs;
+
+    /*
+     * Step through the modules, performing required actions on each one
+     */
+    for (cur = modules; cur; cur = cur->next) {
+        /*
+         * Read the actual segment contents into the correct places in
+         * the newly allocated segments
+         */
+
+        for (i = 0; i < cur->f.nsegs; i++) {
+            int dest = cur->seginfo[i].dest_seg;
+
+            if (dest == -1)
+                continue;
+            if (rdfloadseg(&cur->f, i,
+                           outputseg[dest].data + cur->seginfo[i].reloc)) {
+                rdfperror("ldrdf", cur->name);
+                exit(1);
+            }
+        }
+
+        /*
+         * Perform fixups, and add new header records where required
+         */
+
+        header = nasm_malloc(cur->f.header_len);
+        if (!header) {
+            fprintf(stderr, "ldrdf: out of memory\n");
+            exit(1);
+        }
+
+        if (cur->f.header_loc)
+            rdfheaderrewind(&cur->f);
+        else if (rdfloadseg(&cur->f, RDOFF_HEADER, header)) {
+            rdfperror("ldrdf", cur->name);
+            exit(1);
+        }
+
+        /*
+         * we need to create a local segment number -> location
+         * table for the segments in this module.
+         */
+        init_seglocations(&segs);
+        for (i = 0; i < cur->f.nsegs; i++) {
+            add_seglocation(&segs, cur->f.seg[i].number,
+                            cur->seginfo[i].dest_seg,
+                            cur->seginfo[i].reloc);
+        }
+        /*
+         * and the BSS segment (doh!)
+         */
+        add_seglocation(&segs, 2, 2, cur->bss_reloc);
+
+        while ((hr = rdfgetheaderrec(&cur->f))) {
+            switch (hr->type) {
+            case RDFREC_RELOC: /* relocation record - need to do a fixup */
+                /*
+                 * First correct the offset stored in the segment from
+                 * the start of the segment (which may well have changed).
+                 *
+                 * To do this we add to the number stored the relocation
+                 * factor associated with the segment that contains the
+                 * target segment.
+                 *
+                 * The relocation could be a relative relocation, in which
+                 * case we have to first subtract the amount we've relocated
+                 * the containing segment by.
+                 */
+                if (!get_seglocation(&segs, hr->r.refseg, &seg, &offset)) {
+                    fprintf(stderr,
+                            "%s: reloc to undefined segment %04x\n",
+                            cur->name, (int)hr->r.refseg);
+                    errorcount++;
+                    break;
+                }
+
+                isrelative =
+                    (hr->r.segment & RDOFF_RELATIVEMASK) ==
+                    RDOFF_RELATIVEMASK;
+                hr->r.segment &= (RDOFF_RELATIVEMASK - 1);
+
+                if (hr->r.segment == 2 ||
+                    (localseg =
+                     rdffindsegment(&cur->f, hr->r.segment)) == -1) {
+                    fprintf(stderr, "%s: reloc from %s segment (%d)\n",
+                            cur->name,
+                            hr->r.segment == 2 ? "BSS" : "unknown",
+                            hr->r.segment);
+                    errorcount++;
+                    break;
+                }
+
+                if (hr->r.length != 1 && hr->r.length != 2 &&
+                    hr->r.length != 4) {
+                    fprintf(stderr, "%s: nonstandard length reloc "
+                            "(%d bytes)\n", cur->name, hr->r.length);
+                    errorcount++;
+                    break;
+                }
+
+                /*
+                 * okay, now the relocation is in the segment pointed to by
+                 * cur->seginfo[localseg], and we know everything else is
+                 * okay to go ahead and do the relocation
+                 */
+                data = outputseg[cur->seginfo[localseg].dest_seg].data;
+                data += cur->seginfo[localseg].reloc + hr->r.offset;
+
+                /*
+                 * data now points to the reference that needs
+                 * relocation. Calculate the relocation factor.
+                 * Factor is:
+                 *      offset of referred object in segment [in offset]
+                 *      (- relocation of localseg, if ref is relative)
+                 * For simplicity, the result is stored in 'offset'.
+                 * Then add 'offset' onto the value at data.
+                 */
+
+                if (isrelative)
+                    offset -= cur->seginfo[localseg].reloc;
+                switch (hr->r.length) {
+                case 1:
+                    offset += *data;
+                    if (offset < -127 || offset > 128)
+                        fprintf(error_file,
+                                "warning: relocation out of range "
+                                "at %s(%02x:%08"PRIx32")\n", cur->name,
+                                (int)hr->r.segment, hr->r.offset);
+                    *data = (char)offset;
+                    break;
+                case 2:
+                    offset += *(int16_t *)data;
+                    if (offset < -32767 || offset > 32768)
+                        fprintf(error_file,
+                                "warning: relocation out of range "
+                                "at %s(%02x:%08"PRIx32")\n", cur->name,
+                                (int)hr->r.segment, hr->r.offset);
+                    *(int16_t *)data = (int16_t)offset;
+                    break;
+                case 4:
+                    *(int32_t *)data += offset;
+                    /* we can't easily detect overflow on this one */
+                    break;
+                }
+
+                /*
+                 * If the relocation was relative between two symbols in
+                 * the same segment, then we're done.
+                 *
+                 * Otherwise, we need to output a new relocation record
+                 * with the references updated segment and offset...
+                 */
+                if (!isrelative || cur->seginfo[localseg].dest_seg != seg) {
+                    hr->r.segment = cur->seginfo[localseg].dest_seg;
+                    hr->r.offset += cur->seginfo[localseg].reloc;
+                    hr->r.refseg = seg;
+                    if (isrelative)
+                        hr->r.segment += RDOFF_RELATIVEMASK;
+                    rdfaddheader(rdfheader, hr);
+                }
+                break;
+
+            case RDFREC_IMPORT:        /* import symbol */
+            case RDFREC_FARIMPORT:
+                /*
+                 * scan the global symbol table for the symbol
+                 * and associate its location with the segment number
+                 * for this module
+                 */
+                se = symtabFind(symtab, hr->i.label);
+                if (!se || se->segment == -1) {
+                    if (!options.dynalink && !(hr->i.flags & SYM_IMPORT)) {
+                        fprintf(error_file,
+                                "error: unresolved reference to `%s'"
+                                " in module `%s'\n", hr->i.label,
+                                cur->name);
+                        errorcount++;
+                    }
+                    /*
+                     * we need to allocate a segment number for this
+                     * symbol, and store it in the symbol table for
+                     * future reference
+                     */
+                    if (!se) {
+                        se = nasm_malloc(sizeof(*se));
+                        if (!se) {
+                            fprintf(stderr, "ldrdf: out of memory\n");
+                            exit(1);
+                        }
+                        se->name = nasm_strdup(hr->i.label);
+                        se->flags = 0;
+                        se->segment = availableseg++;
+                        se->offset = 0;
+                        symtabInsert(symtab, se);
+                    } else {
+                        se->segment = availableseg++;
+                        se->offset = 0;
+                    }
+                    /*
+                     * output a header record that imports it to the
+                     * recently allocated segment number...
+                     */
+                    newrec = *hr;
+                    newrec.i.segment = se->segment;
+                    rdfaddheader(rdfheader, &newrec);
+                }
+
+                add_seglocation(&segs, hr->i.segment, se->segment,
+                                se->offset);
+                break;
+
+            case RDFREC_GLOBAL:        /* export symbol */
+                /*
+                 * need to insert an export for this symbol into the new
+                 * header, unless we're stripping symbols. Even if we're
+                 * stripping, put the symbol if it's marked as SYM_GLOBAL.
+                 */
+                if (options.strip && !(hr->e.flags & SYM_GLOBAL))
+                    break;
+
+                if (hr->e.segment == 2) {
+                    seg = 2;
+                    offset = cur->bss_reloc;
+                } else {
+                    localseg = rdffindsegment(&cur->f, hr->e.segment);
+                    if (localseg == -1) {
+                        fprintf(stderr, "%s: exported symbol `%s' from "
+                                "unrecognised segment\n", cur->name,
+                                hr->e.label);
+                        errorcount++;
+                        break;
+                    }
+                    offset = cur->seginfo[localseg].reloc;
+                    seg = cur->seginfo[localseg].dest_seg;
+                }
+
+                hr->e.segment = seg;
+                hr->e.offset += offset;
+                rdfaddheader(rdfheader, hr);
+                break;
+
+            case RDFREC_MODNAME:       /* module name */
+                /*
+                 * Insert module name record if export symbols
+                 * are not stripped.
+                 * If module name begins with '$' - insert it anyway.
+                 */
+                if (options.strip && hr->m.modname[0] != '$')
+                    break;
+                rdfaddheader(rdfheader, hr);
+                break;
+
+            case RDFREC_DLL:   /* DLL name */
+                /*
+                 * Insert DLL name if it begins with '$'
+                 */
+                if (hr->d.libname[0] != '$')
+                    break;
+                rdfaddheader(rdfheader, hr);
+                break;
+
+            case RDFREC_SEGRELOC:      /* segment fixup */
+                /*
+                 * modify the segment numbers if necessary, and
+                 * pass straight through to the output module header
+                 *
+                 * *** FIXME ***
+                 */
+                if (hr->r.segment == 2) {
+                    fprintf(stderr, "%s: segment fixup in BSS section\n",
+                            cur->name);
+                    errorcount++;
+                    break;
+                }
+                localseg = rdffindsegment(&cur->f, hr->r.segment);
+                if (localseg == -1) {
+                    fprintf(stderr, "%s: segment fixup in unrecognised"
+                            " segment (%d)\n", cur->name, hr->r.segment);
+                    errorcount++;
+                    break;
+                }
+                hr->r.segment = cur->seginfo[localseg].dest_seg;
+                hr->r.offset += cur->seginfo[localseg].reloc;
+
+                if (!get_seglocation(&segs, hr->r.refseg, &seg, &offset)) {
+                    fprintf(stderr, "%s: segment fixup to undefined "
+                            "segment %04x\n", cur->name,
+                            (int)hr->r.refseg);
+                    errorcount++;
+                    break;
+                }
+                hr->r.refseg = seg;
+                rdfaddheader(rdfheader, hr);
+                break;
+
+            case RDFREC_COMMON:        /* Common variable */
+                /* Is this symbol already in the table? */
+                se = symtabFind(symtab, hr->c.label);
+                if (!se) {
+                    printf("%s is not in symtab yet\n", hr->c.label);
+                    break;
+                }
+                /* Add segment location */
+                add_seglocation(&segs, hr->c.segment, se->segment,
+                                se->offset);
+                break;
+            }
+        }
+
+        nasm_free(header);
+        done_seglocations(&segs);
+
+    }
+
+    /*
+     * combined BSS reservation for the entire results
+     */
+    newrec.type = RDFREC_BSS;
+    newrec.b.reclen = 4;
+    newrec.b.amount = bss_length;
+    rdfaddheader(rdfheader, &newrec);
+
+    /*
+     * Write the header
+     */
+    for (i = 0; i < nsegs; i++) {
+        if (i == 2)
+            continue;
+        rdfaddsegment(rdfheader, outputseg[i].length);
+    }
+
+    rdfwriteheader(f, rdfheader);
+    rdfdoneheader(rdfheader);
+
+    /*
+     * Step through the segments, one at a time, writing out into
+     * the output file
+     */
+    for (i = 0; i < nsegs; i++) {
+        if (i == 2)
+            continue;
+
+        fwriteint16_t(outputseg[i].type, f);
+        fwriteint16_t(outputseg[i].number, f);
+        fwriteint16_t(outputseg[i].reserved, f);
+        fwriteint32_t(outputseg[i].length, f);
+        nasm_write(outputseg[i].data, outputseg[i].length, f);
+    }
+
+    fwritezero(10, f);
+}
+
+/* =========================================================================
+ * Main program
+ */
+
+static void usage(void)
+{
+    printf("usage:\n"
+           "   ldrdf [options] object modules ... [-llibrary ...]\n"
+           "   ldrdf -r\n"
+           "options:\n"
+           "   -v[=n]          increase verbosity by 1, or set it to n\n"
+           "   -a nn           set segment alignment value (default 16)\n"
+           "   -s              strip public symbols\n"
+           "   -dy             Unix-style dynamic linking\n"
+           "   -o name         write output in file 'name'\n"
+           "   -j path         specify objects search path\n"
+           "   -L path         specify libraries search path\n"
+           "   -g file         embed 'file' as a first header record with type 'generic'\n"
+           "   -mn name        add module name record at the beginning of output file\n");
+    exit(0);
+}
+
+int main(int argc, char **argv)
+{
+    char *outname = "aout.rdf";
+    int moduleloaded = 0;
+    char *respstrings[128] = { 0, };
+
+    rdoff_init();
+
+    options.verbose = 0;
+    options.align = 16;
+    options.dynalink = 0;
+    options.strip = 0;
+
+    error_file = stderr;
+
+    argc--, argv++;
+    if (argc == 0)
+        usage();
+    while (argc && *argv && **argv == '-' && argv[0][1] != 'l') {
+        switch (argv[0][1]) {
+        case 'r':
+            printf("ldrdf (linker for RDF files) version " LDRDF_VERSION
+                   "\n");
+            printf("RDOFF2 revision %s\n", RDOFF2_REVISION);
+            exit(0);
+        case 'v':
+            if (argv[0][2] == '=') {
+                options.verbose = argv[0][3] - '0';
+                if (options.verbose < 0 || options.verbose > 9) {
+                    fprintf(stderr,
+                            "ldrdf: verbosity level must be a number"
+                            " between 0 and 9\n");
+                    exit(1);
+                }
+            } else
+                options.verbose++;
+            break;
+        case 'a':
+            options.align = atoi(argv[1]);
+            if (options.align <= 0) {
+                fprintf(stderr,
+                        "ldrdf: -a expects a positive number argument\n");
+                exit(1);
+            }
+            argv++, argc--;
+            break;
+        case 's':
+            options.strip = 1;
+            break;
+        case 'd':
+            if (argv[0][2] == 'y')
+                options.dynalink = 1;
+            break;
+        case 'm':
+            if (argv[0][2] == 'n') {
+                modname_specified = argv[1];
+		argv++, argc--;
+		if (!argc) {
+		    fprintf(stderr, "ldrdf: -mn expects a module name\n");
+		    exit(1);
+		}
+	    }
+            break;
+        case 'o':
+            outname = argv[1];
+            argv++, argc--;
+            break;
+        case 'j':
+            if (!objpath) {
+                options.objpath = 1;
+                objpath = argv[1];
+                argv++, argc--;
+                break;
+            } else {
+                fprintf(stderr,
+                        "ldrdf: more than one objects search path specified\n");
+                exit(1);
+            }
+        case 'L':
+            if (!libpath) {
+                options.libpath = 1;
+                libpath = argv[1];
+                argv++, argc--;
+                break;
+            } else {
+                fprintf(stderr,
+                        "ldrdf: more than one libraries search path specified\n");
+                exit(1);
+            }
+        case '@':{
+                int i = 0;
+                char buf[256];
+                FILE *f;
+
+                options.respfile = 1;
+                if (argv[1] != NULL)
+                    f = fopen(argv[1], "r");
+                else {
+                    fprintf(stderr,
+                            "ldrdf: no response file name specified\n");
+                    exit(1);
+                }
+
+                if (f == NULL) {
+                    fprintf(stderr,
+                            "ldrdf: unable to open response file\n");
+                    exit(1);
+                }
+
+                argv++, argc--;
+                while (fgets(buf, sizeof(buf), f) != NULL) {
+                    char *p;
+                    if (buf[0] == '\n')
+                        continue;
+                    if ((p = strchr(buf, '\n')) != NULL)
+                        *p = '\0';
+                    if (i >= 128) {
+                        fclose(f);
+                        fprintf(stderr, "ldrdf: too many input files\n");
+                        exit(1);
+                    }
+                    *(respstrings + i) = nasm_strdup(buf);
+                    argc++, i++;
+                }
+                fclose(f);
+                break;
+            }
+        case '2':
+            options.stderr_redir = 1;
+            error_file = stdout;
+            break;
+        case 'g':
+            generic_rec_file = argv[1];
+            argv++, argc--;
+            if (!argc) {
+		fprintf(stderr, "ldrdf: -g expects a file name\n");
+		exit(1);
+	    }
+            break;
+        default:
+            usage();
+        }
+        argv++, argc--;
+    }
+
+    if (options.verbose > 4) {
+        printf("ldrdf invoked with options:\n");
+        printf("    section alignment: %d bytes\n", options.align);
+        printf("    output name: `%s'\n", outname);
+        if (options.strip)
+            printf("    strip symbols\n");
+        if (options.dynalink)
+            printf("    Unix-style dynamic linking\n");
+        if (options.objpath)
+            printf("    objects search path: %s\n", objpath);
+        if (options.libpath)
+            printf("    libraries search path: %s\n", libpath);
+        printf("\n");
+    }
+
+    symtab = symtabNew();
+    initsegments();
+
+    if (!symtab) {
+        fprintf(stderr, "ldrdf: out of memory\n");
+        exit(1);
+    }
+
+    while (argc) {
+        if (!*argv)
+            argv = respstrings;
+        if (!*argv)
+            break;
+        if (!strncmp(*argv, "-l", 2)) {
+            if (libpath && (argv[0][2] != '/'))
+                add_library(nasm_strcat(libpath, *argv + 2));
+            else
+                add_library(*argv + 2);
+        } else {
+            if (objpath && (argv[0][0] != '/'))
+                loadmodule(nasm_strcat(objpath, *argv));
+            else
+                loadmodule(*argv);
+            moduleloaded = 1;
+        }
+        argv++, argc--;
+    }
+
+    if (!moduleloaded) {
+        printf("ldrdf: nothing to do. ldrdf -h for usage\n");
+        return 0;
+    }
+
+    search_libraries();
+
+    if (options.verbose > 2) {
+        printf("symbol table:\n");
+        symtabDump(symtab, stdout);
+    }
+
+    write_output(outname);
+
+    if (errorcount > 0) {
+        remove(outname);
+        exit(1);
+    }
+    return 0;
+}