diff options
Diffstat (limited to 'outrdf.c')
| -rw-r--r-- | outrdf.c | 467 |
1 files changed, 467 insertions, 0 deletions
diff --git a/outrdf.c b/outrdf.c new file mode 100644 index 00000000..24fd4808 --- /dev/null +++ b/outrdf.c @@ -0,0 +1,467 @@ +/* outrdf.c output routines for the Netwide Assembler to produce + * RDOFF format object files (which are intended mainly + * for use in proprietary projects, as the code to load and + * execute them is very simple). They will also be used + * for device drivers and possibly some executable files + * in the MOSCOW operating system. See Rdoff.txt for + * details. + * + * 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. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> +#include <assert.h> + +#include "nasm.h" +#include "nasmlib.h" +#include "outform.h" + +#ifdef OF_RDF + +typedef short int16; /* not sure if this will be required to be altered + at all... best to typedef it just in case */ + +const char *RDOFFId = "RDOFF1"; /* written to the start of RDOFF files */ + +/* the records that can be found in the RDOFF header */ + +/* Note that whenever a segment is referred to in the RDOFF file, its number + * is always half of the segment number that NASM uses to refer to it; this + * is because NASM only allocates even numbered segments, so as to not + * waste any of the 16 bits of segment number written to the file - this + * allows up to 65533 external labels to be defined; otherwise it would be + * 32764. */ + +struct RelocRec { + char type; /* must be 1 */ + char segment; /* only 0 for code, or 1 for data supported, + * but add 64 for relative refs (ie do not require + * reloc @ loadtime, only linkage) */ + long offset; /* from start of segment in which reference is loc'd */ + char length; /* 1 2 or 4 bytes */ + int16 refseg; /* segment to which reference refers to */ +}; + +struct ImportRec { + char type; /* must be 2 */ + int16 segment; /* segment number allocated to the label for reloc + * records - label is assumed to be at offset zero + * in this segment, so linker must fix up with offset + * of segment and of offset within segment */ + char label[33]; /* zero terminated... should be written to file until + * the zero, but not after it - max len = 32 chars */ +}; + +struct ExportRec { + char type; /* must be 3 */ + char segment; /* segment referred to (0/1) */ + long offset; /* offset within segment */ + char label[33]; /* zero terminated as above. max len = 32 chars */ +}; + +struct DLLRec { + char type; /* must be 4 */ + char libname[128]; /* name of library to link with at load time */ +}; + +struct BSSRec { + char type; /* must be 5 */ + long amount; /* number of bytes BSS to reserve */ +}; + +/* code for managing buffers needed to seperate code and data into individual + * sections until they are ready to be written to the file. + * We'd better hope that it all fits in memory else we're buggered... */ + +#define BUF_BLOCK_LEN 4088 /* selected to match page size (4096) + * on 80x86 machines for efficiency */ + +typedef struct memorybuffer { + int length; + char buffer[BUF_BLOCK_LEN]; + struct memorybuffer *next; +} memorybuffer; + +memorybuffer * newmembuf(){ + memorybuffer * t; + + t = nasm_malloc(sizeof(memorybuffer)); + + t->length = 0; + t->next = NULL; + return t; +} + +void membufwrite(memorybuffer *b, void *data, int bytes) { + int16 w; + long l; + + if (b->next) { /* memory buffer full - use next buffer */ + membufwrite(b->next,data,bytes); + return; + } + if ((bytes < 0 && b->length - bytes > BUF_BLOCK_LEN) + || (bytes > 0 && b->length + bytes > BUF_BLOCK_LEN)) { + + /* buffer full and no next allocated... allocate and initialise next + * buffer */ + + b->next = newmembuf(); + membufwrite(b->next,data,bytes); + } + + switch(bytes) { + case -4: /* convert to little-endian */ + l = * (long *) data ; + b->buffer[b->length++] = l & 0xFF; + l >>= 8 ; + b->buffer[b->length++] = l & 0xFF; + l >>= 8 ; + b->buffer[b->length++] = l & 0xFF; + l >>= 8 ; + b->buffer[b->length++] = l & 0xFF; + break; + + case -2: + w = * (int16 *) data ; + b->buffer[b->length++] = w & 0xFF; + w >>= 8 ; + b->buffer[b->length++] = w & 0xFF; + break; + + default: + while(bytes--) { + b->buffer[b->length++] = *(* (unsigned char **) &data); + + (* (unsigned char **) &data)++ ; + } + break; + } +} + +void membufdump(memorybuffer *b,FILE *fp) +{ + if (!b) return; + + fwrite (b->buffer, 1, b->length, fp); + + membufdump(b->next,fp); +} + +int membuflength(memorybuffer *b) +{ + if (!b) return 0; + return b->length + membuflength(b->next); +} + +void freemembuf(memorybuffer *b) +{ + if (!b) return; + freemembuf(b->next); + nasm_free(b); +} + +/*********************************************************************** + * Actual code to deal with RDOFF ouput format begins here... + */ + +/* global variables set during the initialisation phase */ + +memorybuffer *seg[2]; /* seg 0 = code, seg 1 = data */ +memorybuffer *header; /* relocation/import/export records */ + +FILE *ofile; + +int seg_warned; +static efunc error; + +int segtext,segdata,segbss; +long bsslength; + +static void rdf_init(FILE *fp, efunc errfunc, ldfunc ldef) +{ + ofile = fp; + error = errfunc; + seg[0] = newmembuf(); + seg[1] = newmembuf(); + header = newmembuf(); + segtext = seg_alloc(); + segdata = seg_alloc(); + segbss = seg_alloc(); + if (segtext != 0 || segdata != 2 || segbss != 4) + error(ERR_PANIC,"rdf segment numbers not allocated as expected (%d,%d,%d)", + segtext,segdata,segbss); + bsslength=0; +} + +static long rdf_section_names(char *name, int pass, int *bits) +{ + /* + * Default is 32 bits. + */ + if (!name) + *bits = 32; + + if (!name) return 0; + if (!strcmp(name, ".text")) return 0; + else if (!strcmp(name, ".data")) return 2; + else if (!strcmp(name, ".bss")) return 4; + else + return NO_SEG; +} + +static void write_reloc_rec(struct RelocRec *r) +{ + r->refseg >>= 1; /* adjust segment nos to RDF rather than NASM */ + + membufwrite(header,&r->type,1); + membufwrite(header,&r->segment,1); + membufwrite(header,&r->offset,-4); + membufwrite(header,&r->length,1); + membufwrite(header,&r->refseg,-2); /* 9 bytes written */ +} + +static void write_export_rec(struct ExportRec *r) +{ + r->segment >>= 1; + + membufwrite(header,&r->type,1); + membufwrite(header,&r->segment,1); + membufwrite(header,&r->offset,-4); + membufwrite(header,r->label,strlen(r->label) + 1); +} + +static void write_import_rec(struct ImportRec *r) +{ + r->segment >>= 1; + + membufwrite(header,&r->type,1); + membufwrite(header,&r->segment,-2); + membufwrite(header,r->label,strlen(r->label) + 1); +} + +static void write_bss_rec(struct BSSRec *r) +{ + membufwrite(header,&r->type,1); + membufwrite(header,&r->amount,-4); +} + +static void rdf_deflabel(char *name, long segment, long offset, int is_global) +{ + struct ExportRec r; + struct ImportRec ri; + + if (is_global && segment > 4) { + error(ERR_WARNING,"common declarations not supported... using extern"); + is_global = 0; + } + + if (is_global) { + r.type = 3; + r.segment = segment; + r.offset = offset; + strncpy(r.label,name,32); + r.label[32] = 0; + write_export_rec(&r); + } + + if (segment > 4) { /* EXTERN declaration */ + ri.type = 2; + ri.segment = segment; + strncpy(ri.label,name,32); + ri.label[32] = 0; + write_import_rec(&ri); + } +} + +static void rdf_out (long segto, void *data, unsigned long type, + long segment, long wrt) +{ + long bytes = type & OUT_SIZMASK; + struct RelocRec rr; + unsigned char databuf[4],*pd; + + segto >>= 1; /* convert NASM segment no to RDF number */ + + if (segto != 0 && segto != 1 && segto != 2) { + error(ERR_NONFATAL,"specified segment not supported by rdf output format"); + return; + } + + if (wrt != NO_SEG) { + wrt = NO_SEG; /* continue to do _something_ */ + error (ERR_NONFATAL, "WRT not supported by rdf output format"); + } + + type &= OUT_TYPMASK; + + if (segto == 2 && type != OUT_RESERVE) + { + error(ERR_NONFATAL, "BSS segments may not be initialised"); + + /* just reserve the space for now... */ + + if (type == OUT_REL2ADR) + bytes = 2; + else + bytes = 4; + type = OUT_RESERVE; + } + + if (type == OUT_RESERVE) { + if (segto == 2) /* BSS segment space reserverd */ + bsslength += bytes; + else + while (bytes --) + membufwrite(seg[segto],databuf,1); + } + else if (type == OUT_RAWDATA) { + if (segment != NO_SEG) + error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG"); + membufwrite(seg[segto],data,bytes); + } + else if (type == OUT_ADDRESS) { + + /* if segment == NO_SEG then we are writing an address of an + object within the same segment - do not produce reloc rec. */ + + if (segment != NO_SEG) + { + + /* it's an address, so we must write a relocation record */ + + rr.type = 1; /* type signature */ + rr.segment = segto; /* segment we're currently in */ + rr.offset = membuflength(seg[segto]); /* current offset */ + rr.length = bytes; /* length of reference */ + rr.refseg = segment; /* segment referred to */ + write_reloc_rec(&rr); + } + + pd = databuf; /* convert address to little-endian */ + if (bytes == 2) + WRITESHORT (pd, *(long *)data); + else + WRITELONG (pd, *(long *)data); + + membufwrite(seg[segto],databuf,bytes); + + } + else if (type == OUT_REL2ADR) + { + if (segment == segto) + error(ERR_PANIC, "intra-segment OUT_REL2ADR"); + if (segment != NO_SEG && segment % 2) { + error(ERR_NONFATAL, "rdf format does not support segment base refs"); + } + + rr.type = 1; /* type signature */ + rr.segment = segto+64; /* segment we're currently in + rel flag */ + rr.offset = membuflength(seg[segto]); /* current offset */ + rr.length = 2; /* length of reference */ + rr.refseg = segment; /* segment referred to */ + write_reloc_rec(&rr); + + /* work out what to put in the code: offset of the end of this operand, + * subtracted from any data specified, so that loader can just add + * address of imported symbol onto it to get address relative to end of + * instruction: import_address + data(offset) - end_of_instrn */ + + rr.offset = *(long *)data -(rr.offset + bytes); + + membufwrite(seg[segto],&rr.offset,-2); + } + else if (type == OUT_REL4ADR) + { + if (segment == segto) + error(ERR_PANIC, "intra-segment OUT_REL4ADR"); + if (segment != NO_SEG && segment % 2) { + error(ERR_NONFATAL, "rdf format does not support segment base refs"); + } + + rr.type = 1; /* type signature */ + rr.segment = segto+64; /* segment we're currently in + rel tag */ + rr.offset = membuflength(seg[segto]); /* current offset */ + rr.length = 4; /* length of reference */ + rr.refseg = segment; /* segment referred to */ + write_reloc_rec(&rr); + + rr.offset = *(long *)data -(rr.offset + bytes); + membufwrite(seg[segto],&rr.offset,-4); + } +} + +static void rdf_cleanup (void) { + long l; + unsigned char b[4],*d; + struct BSSRec bs; + + + /* should write imported & exported symbol declarations to header here */ + + /* generate the output file... */ + fwrite("RDOFF1",6,1,ofile); /* file type magic number */ + + if (bsslength != 0) /* reserve BSS */ + { + bs.type = 5; + bs.amount = bsslength; + write_bss_rec(&bs); + } + + l = membuflength(header);d=b; + WRITELONG(d,l); + + fwrite(b,4,1,ofile); /* write length of header */ + membufdump(header,ofile); /* dump header */ + + l = membuflength(seg[0]);d=b; /* code segment */ + WRITELONG(d,l); + + fwrite(b,4,1,ofile); + membufdump(seg[0],ofile); + + l = membuflength(seg[1]);d=b; /* data segment */ + WRITELONG(d,l); + + fwrite(b,4,1,ofile); + membufdump(seg[1],ofile); + + freemembuf(header); + freemembuf(seg[0]); + freemembuf(seg[1]); + fclose(ofile); +} + +static long rdf_segbase (long segment) { + return 0; +} + +static int rdf_directive (char *directive, char *value, int pass) { + return 0; +} + +static void rdf_filename (char *inname, char *outname, efunc error) { + standard_extension(inname,outname,".rdf",error); +} + +struct ofmt of_rdf = { + "Relocatable Dynamic Object File Format v1.1", + "rdf", + rdf_init, + rdf_out, + rdf_deflabel, + rdf_section_names, + rdf_segbase, + rdf_directive, + rdf_filename, + rdf_cleanup +}; + +#endif /* OF_RDF */ |