-/* ldrdf.c RDOFF Object File linker/loader main program
- *
- * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
- * Julian Hall. All rights reserved. The software is
- * redistributable under the licence given in the file "Licence"
- * distributed in the NASM archive.
- */
-
-/*
- * TODO: actually get this new version working!
- * - finish off write_output() - appears to be done
- * - implement library searching - appears to be done
- * - maybe we only want to do one pass, for performance reasons?
- * this makes things a little harder, but unix 'ld' copes...
- * - implement command line options - appears to be done
- * - improve symbol table implementation - done, thanks to Graeme Defty
- * - 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
- * wont work if compiled by a 16 bit compiler. Try DJGPP if you're running
- * under DOS. '#define STINGY_MEMORY' may help a little.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "multboot.h"
-#include "rdoff.h"
-#include "symtab.h"
-#include "collectn.h"
-#include "rdlib.h"
-#include "segtab.h"
-
-#define LDRDF_VERSION "1.02"
-
-#define RDF_MAXSEGS 64
-/* #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 */
- long 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;
- long bss_reloc;
-};
-
-#include "ldsegs.h"
-
-#define newstr(str) strcpy(malloc(strlen(str) + 1),str)
-#define newstrcat(s1,s2) strcat(strcpy(malloc(strlen(s1)+strlen(s2)+1),s1),s2)
-
-/* ==========================================================================
- * Function prototypes of private utility functions
- */
-
-void processmodule(const char * filename, struct modulenode * mod);
-int allocnewseg(int16 type,int16 reserved);
-int findsegment(int16 type,int16 reserved);
-void symtab_add(const char * symbol, int segment, long offset);
-int symtab_get(const char * symbol, int * segment, long * 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;
-
-/* error file */
-static FILE * error_file;
-
-#ifdef _MULTBOOT_H
-
-/* loading address for multiboot header */
-unsigned MBHloadAddr;
-
-/*
- * Tiny code that moves RDF loader to its working memory region:
- * mov esi,SOURCE_ADDR ; BE xx xx xx xx
- * mov edi,DEST_ADDR ; BF xx xx xx xx
- * mov esp,edi ; 89 FC
- * push edi ; 57
- * mov ecx,RDFLDR_LENGTH/4 ; B9 xx xx xx xx
- * cld ; FC
- * rep movsd ; F3 A5
- * ret ; C3
- */
-
-#define RDFLDR_LENGTH 4096 /* Loader will be moved to unused */
-#define RDFLDR_DESTLOC 0xBF000 /* video page */
-
-unsigned char RDFloaderMover[]={
- 0xBE, 0, 0, 0, 0, 0xBF, 0, 0xF0, 0xB, 0,
- 0x89, 0xFC, 0x57,
- 0xB9, 0, 4, 0, 0,
- 0xFC, 0xF3, 0xA5, 0xC3
-};
-
-#endif
-
-/* 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;
-long bss_length;
-
-/* global options which affect how the program behaves */
-struct ldrdfoptions {
- int verbose;
- int align;
- int warnUnresolved;
- int errorUnresolved;
- int strip;
- int respfile;
- int stderr_redir;
- int objpath;
- int libpath;
- int addMBheader;
-} 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
- */
-
-void initsegments()
-{
- 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).
- */
-
-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 = malloc (sizeof(*modules));
- lastmodule = modules;
- }
- else
- {
- lastmodule->next = 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 = 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, cos 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;
- long bssamount = 0;
-
- 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:%08lx (+%04lx)\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:%08lx (+%04lx)\n", outseg,
- mod->seginfo[seg].reloc,
- mod->f.seg[seg].length);
- }
-
- }
-
- /*
- * extract symbols from the header, and dump them into the
- * symbol table
- */
- header = 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 2: /* imported symbol - define with seg = -1 */
- case 7:
- symtab_add(hr->i.label, -1, 0);
- break;
-
- case 3: /* exported symbol */
- {
- int destseg;
- long destreloc;
-
- if (hr->e.segment == 2)
- {
- 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 5: /* 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;
- }
- }
-
- if (bssamount != 0)
- {
- /*
- * 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:%08lx (+%04lx)\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;
- free(header);
-
-#endif
-
-}
-
-
-/*
- * Look in list for module by its name.
- */
-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(int16 type,int16 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(int16 type,int16 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, long 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 = malloc(sizeof(symtabEnt));
- if (!ste) {
- fprintf(stderr, "ldrdf: out of memory\n");
- exit(1);
- }
- ste->name = 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, long * 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.
- */
-
-void add_library(const char * name)
-{
- if (rdl_verify(name)) {
- rdl_perror("ldrdf", name);
- errorcount++;
- return;
- }
- if (! libraries)
- {
- lastlib = libraries = malloc(sizeof(*libraries));
- if (! libraries) {
- fprintf(stderr, "ldrdf: out of memory\n");
- exit(1);
- }
- }
- else
- {
- lastlib->next = 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).
- */
-
-int search_libraries()
-{
- struct librarynode * cur;
- rdffile f;
- int i;
- void * header;
- int segment;
- long 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 = 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 != 3) continue;
-
- /*
- * Find the symbol 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 = 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 = strdup(f.name);
- lastmodule->next = NULL;
- processmodule(f.name, lastmodule);
- break;
- }
- if (!keepfile)
- {
- 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.
- */
-void write_output(const char * filename)
-{
- FILE * f;
- rdf_headerbuf * rdfheader;
- struct modulenode * cur;
- int i, availableseg, seg, localseg, isrelative;
- void * header;
- rdfheaderrec * hr, newrec;
- symtabEnt * se;
- segtab segs;
- long offset;
- byte * 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);
- }
-
- /*
- * Add multiboot header if appropriate option is specified.
- * Multiboot record *MUST* be the first record in output file.
- */
- if (options.addMBheader) {
- if (options.verbose)
- puts("\nadding multiboot header record");
-
- hr = (rdfheaderrec *) malloc(sizeof(struct MultiBootHdrRec));
- hr->mbh.type = 9;
- hr->mbh.reclen = sizeof(struct tMultiBootHeader)+RDFLDRMOVER_SIZE;
-
- hr->mbh.mb.Magic = MB_MAGIC;
- hr->mbh.mb.Flags = MB_FL_KLUDGE;
- hr->mbh.mb.Checksum = ~(MB_MAGIC+MB_FL_KLUDGE-1);
- hr->mbh.mb.HeaderAddr = MBHloadAddr+16;
- hr->mbh.mb.LoadAddr = MBHloadAddr;
- hr->mbh.mb.Entry = MBHloadAddr+16+sizeof(struct tMultiBootHeader);
-
- memcpy(hr->mbh.mover,RDFloaderMover,RDFLDRMOVER_SIZE);
-
- rdfaddheader(rdfheader,hr);
- 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 = 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 = 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 1: /* 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 & 64) == 64;
- hr->r.segment &= 63;
-
- 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:%08lx)\n", cur->name,
- (int)hr->r.segment, hr->r.offset);
- *data = (char) offset;
- break;
- case 2:
- offset += * (short *)data;
- if (offset < -32767 || offset > 32768)
- fprintf(error_file, "warning: relocation out of range "
- "at %s(%02x:%08lx)\n", cur->name,
- (int)hr->r.segment, hr->r.offset);
- * (short *)data = (short) offset;
- break;
- case 4:
- * (long *)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;
- rdfaddheader(rdfheader, hr);
- }
- break;
-
- case 2: /* import symbol */
- case 7:
- /*
- * 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.warnUnresolved) {
- fprintf(error_file, "warning: unresolved reference to `%s'"
- " in module `%s'\n", hr->i.label, cur->name);
- if (options.errorUnresolved==1) errorcount++;
- }
- /*
- * we need to allocate a segment number for this
- * symbol, and store it in the symbol table for
- * future reference
- */
- if (!se) {
- se=malloc(sizeof(*se));
- if (!se) {
- fprintf(stderr, "ldrdf: out of memory\n");
- exit(1);
- }
- se->name = 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 3: /* export symbol */
- /*
- * need to insert an export for this symbol into the new
- * header, unless we're stripping symbols [unless this
- * symbol is in an explicit keep list]. *** FIXME ***
- */
- if (options.strip)
- 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 8: /* module name */
- /*
- * insert module name record if export symbols
- * are not stripped.
- */
- if (options.strip) break;
-
- rdfaddheader(rdfheader, hr);
- break;
-
- case 6: /* 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;
- }
- }
-
- free(header);
- done_seglocations(&segs);
-
- }
-
- /*
- * combined BSS reservation for the entire results
- */
- newrec.type = 5;
- 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);
- }
-
- if (options.addMBheader) {
- struct MultiBootHdrRec *mbhrec = (struct MultiBootHdrRec *)(rdfheader->buf->buffer);
- unsigned l = membuflength(rdfheader->buf) + 14 +
- 10*rdfheader->nsegments + rdfheader->seglength;
- unsigned *ldraddr = (unsigned *)(mbhrec->mover+1);
-
- mbhrec->mb.LoadEndAddr = MBHloadAddr+l+10+RDFLDR_LENGTH;
- mbhrec->mb.BSSendAddr = mbhrec->mb.LoadEndAddr;
- *ldraddr = MBHloadAddr+l+10;
- }
-
- 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++)
- {
- int16 s;
- long l;
-
- if (i == 2) continue;
-
- s = translateshort(outputseg[i].type);
- fwrite(&s, 2, 1, f);
- s = translateshort(outputseg[i].number);
- fwrite(&s, 2, 1, f);
- s = translateshort(outputseg[i].reserved);
- fwrite(&s, 2, 1, f);
- l = translatelong(outputseg[i].length);
- fwrite(&l, 4, 1, f);
-
- fwrite(outputseg[i].data, outputseg[i].length, 1, f);
- }
-
- fwrite("\0\0\0\0\0\0\0\0\0\0", 10, 1, f);
-}
-
-/* =========================================================================
- * Main program
- */
-
-void usage()
-{
- printf("usage:\n");
- printf(" ldrdf [options] object modules ... [-llibrary ...]\n");
- printf(" ldrdf -r\n");
- printf("options:\n");
- printf(" -v[=n] increases verbosity by 1, or sets it to n\n");
- printf(" -a nn sets segment alignment value (default 16)\n");
- printf(" -s strips exported symbols\n");
- printf(" -x warn about unresolved symbols\n");
- printf(" -o name write output in file 'name'\n");
- printf(" -j path specify objects search path\n");
- printf(" -L path specify libraries search path\n");
- printf(" -mbh [address] add multiboot header to output file. Default\n");
- printf(" loading address is 0x110000\n");
- exit(0);
-}
-
-int main(int argc, char ** argv)
-{
- char * outname = "aout.rdf";
- int moduleloaded = 0;
- char *respstrings[128] = {0, };
-
- options.verbose = 0;
- options.align = 16;
- options.warnUnresolved = 0;
- options.strip = 0;
-
- error_file = stderr;
-
- argc --, argv ++;
- if (argc == 0) usage();
- while (argc && **argv == '-' && argv[0][1] != 'l')
- {
- switch(argv[0][1]) {
- case 'r':
- printf("ldrdf (linker for RDF files) version " LDRDF_VERSION "\n");
- printf( _RDOFF_H "\n");
- 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 'x':
- options.warnUnresolved = 1;
- if (argv[0][2]=='e')
- options.errorUnresolved = 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);
- }
- argc-=2;
- while(fgets(buf,sizeof(buf)-1,f)!=NULL)
- {
- char *p;
- if (buf[0]=='\n') continue;
- if ((p = strchr(buf,'\n')) != 0)
- *p=0;
- if (i >= 128)
- {
- fprintf(stderr,"ldrdf: too many input files\n");
- exit(1);
- }
- *(respstrings+i) = newstr(buf);
- argc++, i++;
- }
- goto done;
- }
- case '2':
- options.stderr_redir = 1;
- error_file = stdout;
- break;
- case 'm':
- if (argv[0][2] == 'b' && argv[0][3] == 'h') {
- if (argv[1][0] != '-') {
- MBHloadAddr = atoi(argv[1]);
- } else {
- MBHloadAddr = MB_DEFAULTLOADADDR;
- }
- options.addMBheader = 1;
- break;
- }
- default:
- usage();
- }
- argv++, argc--;
- }
-done:
- 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.warnUnresolved)
- printf(" warn about unresolved symbols\n");
- if (options.errorUnresolved)
- printf(" error if unresolved symbols\n");
- if (options.objpath)
- printf(" objects search path: %s\n",objpath);
- if (options.libpath)
- printf(" libraries search path: %s\n",libpath);
- if (options.addMBheader)
- printf(" loading address for multiboot header: 0x%X\n",MBHloadAddr);
- printf("\n");
- }
-
- symtab = symtabNew();
- initsegments();
-
- if (!symtab) {
- fprintf(stderr, "ldrdf: out of memory\n");
- exit(1);
- }
-
- if (*respstrings) argv = respstrings;
- while (argc)
- {
- if (!strncmp(*argv, "-l", 2)) /* library */
- {
- if(libpath) add_library(newstrcat(libpath,*argv + 2));
- else add_library(*argv + 2);
- }
- else {
- if(objpath) loadmodule(newstrcat(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) exit(1);
- return 0;
-}
+***************
+*** 29,42 ****
+ #include <stdlib.h>
+ #include <string.h>
+
+ #include "rdoff.h"
+ #include "symtab.h"
+ #include "collectn.h"
+ #include "rdlib.h"
+ #include "segtab.h"
+- #include "multboot.h"
+
+- #define LDRDF_VERSION "1.01 alpha 2"
+
+ #define RDF_MAXSEGS 64
+ /* #define STINGY_MEMORY */
+--- 29,42 ----
+ #include <stdlib.h>
+ #include <string.h>
+
++ #include "multboot.h"
+ #include "rdoff.h"
+ #include "symtab.h"
+ #include "collectn.h"
+ #include "rdlib.h"
+ #include "segtab.h"
+
++ #define LDRDF_VERSION "1.02"
+
+ #define RDF_MAXSEGS 64
+ /* #define STINGY_MEMORY */
projects / platform / upstream / nasm.git / commitdiff