output/outrdf.c

   1 /* outrdf.c     output routines for the Netwide Assembler to produce
   2  *              RDOFF format object files (which are intended mainly
   3  *              for use in proprietary projects, as the code to load and
   4  *              execute them is very simple). They will also be used
   5  *              for device drivers and possibly some executable files
   6  *              in the MOSCOW operating system. See Rdoff.txt for
   7  *              details.
   8  *
   9  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
  10  * Julian Hall. All rights reserved. The software is
  11  * redistributable under the license given in the file "LICENSE"
  12  * distributed in the NASM archive.
  13  */
  14
  15 #include "compiler.h"
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <ctype.h>
  21 #include <assert.h>
  22
  23 #include "nasm.h"
  24 #include "nasmlib.h"
  25 #include "outform.h"
  26
  27 /* VERBOSE_WARNINGS: define this to add some extra warnings... */
  28 #define VERBOSE_WARNINGS
  29
  30 #ifdef OF_RDF
  31
  32 typedef int16_t int16;            /* not sure if this will be required to be altered
  33                                    at all... best to typedef it just in case */
  34
  35 static const char *RDOFFId = "RDOFF1";  /* written to start of RDOFF files */
  36
  37 /* the records that can be found in the RDOFF header */
  38
  39 /* Note that whenever a segment is referred to in the RDOFF file, its number
  40  * is always half of the segment number that NASM uses to refer to it; this
  41  * is because NASM only allocates even numbered segments, so as to not
  42  * waste any of the 16 bits of segment number written to the file - this
  43  * allows up to 65533 external labels to be defined; otherwise it would be
  44  * 32764. */
  45
  46 struct RelocRec {
  47     char type;                  /* must be 1 */
  48     char segment;               /* only 0 for code, or 1 for data supported,
  49                                  * but add 64 for relative refs (ie do not require
  50                                  * reloc @ loadtime, only linkage) */
  51     int32_t offset;                /* from start of segment in which reference is loc'd */
  52     char length;                /* 1 2 or 4 bytes */
  53     int16 refseg;               /* segment to which reference refers to */
  54 };
  55
  56 struct ImportRec {
  57     char type;                  /* must be 2 */
  58     int16 segment;              /* segment number allocated to the label for reloc
  59                                  * records - label is assumed to be at offset zero
  60                                  * in this segment, so linker must fix up with offset
  61                                  * of segment and of offset within segment */
  62     char label[33];             /* zero terminated... should be written to file until
  63                                  * the zero, but not after it - max len = 32 chars */
  64 };
  65
  66 struct ExportRec {
  67     char type;                  /* must be 3 */
  68     char segment;               /* segment referred to (0/1) */
  69     int32_t offset;                /* offset within segment */
  70     char label[33];             /* zero terminated as above. max len = 32 chars */
  71 };
  72
  73 struct DLLRec {
  74     char type;                  /* must be 4 */
  75     char libname[128];          /* name of library to link with at load time */
  76 };
  77
  78 struct BSSRec {
  79     char type;                  /* must be 5 */
  80     int32_t amount;                /* number of bytes BSS to reserve */
  81 };
  82
  83 /* code for managing buffers needed to seperate code and data into individual
  84  * sections until they are ready to be written to the file.
  85  * We'd better hope that it all fits in memory else we're buggered... */
  86
  87 #define BUF_BLOCK_LEN 4088      /* selected to match page size (4096)
  88                                  * on 80x86 machines for efficiency */
  89
  90 typedef struct memorybuffer {
  91     int length;
  92     char buffer[BUF_BLOCK_LEN];
  93     struct memorybuffer *next;
  94 } memorybuffer;
  95
  96 static memorybuffer *newmembuf(void)
  97 {
  98     memorybuffer *t;
  99
 100     t = nasm_malloc(sizeof(memorybuffer));
 101
 102     t->length = 0;
 103     t->next = NULL;
 104     return t;
 105 }
 106
 107 static void membufwrite(memorybuffer * b, void *data, int bytes)
 108 {
 109     int16 w;
 110     int32_t l;
 111
 112     if (b->next) {              /* memory buffer full - use next buffer */
 113         membufwrite(b->next, data, bytes);
 114         return;
 115     }
 116     if ((bytes < 0 && b->length - bytes > BUF_BLOCK_LEN)
 117         || (bytes > 0 && b->length + bytes > BUF_BLOCK_LEN)) {
 118
 119         /* buffer full and no next allocated... allocate and initialize next
 120          * buffer */
 121
 122         b->next = newmembuf();
 123         membufwrite(b->next, data, bytes);
 124         return;
 125     }
 126
 127     switch (bytes) {
 128     case -4:                   /* convert to little-endian */
 129         l = *(int32_t *)data;
 130         b->buffer[b->length++] = l & 0xFF;
 131         l >>= 8;
 132         b->buffer[b->length++] = l & 0xFF;
 133         l >>= 8;
 134         b->buffer[b->length++] = l & 0xFF;
 135         l >>= 8;
 136         b->buffer[b->length++] = l & 0xFF;
 137         break;
 138
 139     case -2:
 140         w = *(int16 *) data;
 141         b->buffer[b->length++] = w & 0xFF;
 142         w >>= 8;
 143         b->buffer[b->length++] = w & 0xFF;
 144         break;
 145
 146     default:
 147         while (bytes--) {
 148             b->buffer[b->length++] = *(*(uint8_t **)&data);
 149
 150             (*(uint8_t **)&data)++;
 151         }
 152         break;
 153     }
 154 }
 155
 156 static void membufdump(memorybuffer * b, FILE * fp)
 157 {
 158     if (!b)
 159         return;
 160
 161     fwrite(b->buffer, 1, b->length, fp);
 162
 163     membufdump(b->next, fp);
 164 }
 165
 166 static int membuflength(memorybuffer * b)
 167 {
 168     if (!b)
 169         return 0;
 170     return b->length + membuflength(b->next);
 171 }
 172
 173 static void freemembuf(memorybuffer * b)
 174 {
 175     if (!b)
 176         return;
 177     freemembuf(b->next);
 178     nasm_free(b);
 179 }
 180
 181 /***********************************************************************
 182  * Actual code to deal with RDOFF ouput format begins here...
 183  */
 184
 185 /* global variables set during the initialisation phase */
 186
 187 static memorybuffer *seg[2];    /* seg 0 = code, seg 1 = data */
 188 static memorybuffer *header;    /* relocation/import/export records */
 189
 190 static FILE *ofile;
 191
 192 static efunc error;
 193
 194 static int segtext, segdata, segbss;
 195 static int32_t bsslength;
 196
 197 static void rdf_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
 198 {
 199     maxbits = 64;
 200     ofile = fp;
 201     error = errfunc;
 202     seg[0] = newmembuf();
 203     seg[1] = newmembuf();
 204     header = newmembuf();
 205     segtext = seg_alloc();
 206     segdata = seg_alloc();
 207     segbss = seg_alloc();
 208     if (segtext != 0 || segdata != 2 || segbss != 4)
 209         error(ERR_PANIC,
 210               "rdf segment numbers not allocated as expected (%d,%d,%d)",
 211               segtext, segdata, segbss);
 212     bsslength = 0;
 213 }
 214
 215 static int32_t rdf_section_names(char *name, int pass, int *bits)
 216 {
 217     /*
 218      * Default is 32 bits.
 219      */
 220     if (!name)
 221         *bits = 32;
 222
 223     if (!name)
 224         return 0;
 225     if (!strcmp(name, ".text"))
 226         return 0;
 227     else if (!strcmp(name, ".data"))
 228         return 2;
 229     else if (!strcmp(name, ".bss"))
 230         return 4;
 231     else
 232         return NO_SEG;
 233 }
 234
 235 static void write_reloc_rec(struct RelocRec *r)
 236 {
 237     if (r->refseg != NO_SEG && (r->refseg & 1))
 238         error(ERR_NONFATAL, "RDF format does not support segment base"
 239               " references");
 240
 241     r->refseg >>= 1;            /* adjust segment nos to RDF rather than NASM */
 242
 243     membufwrite(header, &r->type, 1);
 244     membufwrite(header, &r->segment, 1);
 245     membufwrite(header, &r->offset, -4);
 246     membufwrite(header, &r->length, 1);
 247     membufwrite(header, &r->refseg, -2);        /* 9 bytes written */
 248 }
 249
 250 static void write_export_rec(struct ExportRec *r)
 251 {
 252     r->segment >>= 1;
 253
 254     membufwrite(header, &r->type, 1);
 255     membufwrite(header, &r->segment, 1);
 256     membufwrite(header, &r->offset, -4);
 257     membufwrite(header, r->label, strlen(r->label) + 1);
 258 }
 259
 260 static void write_import_rec(struct ImportRec *r)
 261 {
 262     r->segment >>= 1;
 263
 264     membufwrite(header, &r->type, 1);
 265     membufwrite(header, &r->segment, -2);
 266     membufwrite(header, r->label, strlen(r->label) + 1);
 267 }
 268
 269 static void write_bss_rec(struct BSSRec *r)
 270 {
 271     membufwrite(header, &r->type, 1);
 272     membufwrite(header, &r->amount, -4);
 273 }
 274
 275 static void write_dll_rec(struct DLLRec *r)
 276 {
 277     membufwrite(header, &r->type, 1);
 278     membufwrite(header, r->libname, strlen(r->libname) + 1);
 279 }
 280
 281 static void rdf_deflabel(char *name, int32_t segment, int32_t offset,
 282                          int is_global, char *special)
 283 {
 284     struct ExportRec r;
 285     struct ImportRec ri;
 286 #ifdef VERBOSE_WARNINGS
 287     static int warned_common = 0;
 288 #endif
 289
 290     if (special)
 291         error(ERR_NONFATAL, "RDOFF format does not support any"
 292               " special symbol types");
 293
 294     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
 295         error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
 296         return;
 297     }
 298
 299     if (is_global == 2) {
 300 #ifdef VERBOSE_WARNINGS
 301         if (!warned_common) {
 302             error(ERR_WARNING,
 303                   "common declarations not supported: using extern");
 304             warned_common = 1;
 305         }
 306 #endif
 307         is_global = 1;
 308     }
 309
 310     if (segment > 4) {          /* EXTERN declaration */
 311         ri.type = 2;
 312         ri.segment = segment;
 313         strncpy(ri.label, name, 32);
 314         ri.label[32] = 0;
 315         write_import_rec(&ri);
 316     } else if (is_global) {
 317         r.type = 3;
 318         r.segment = segment;
 319         r.offset = offset;
 320         strncpy(r.label, name, 32);
 321         r.label[32] = 0;
 322         write_export_rec(&r);
 323     }
 324 }
 325
 326 static void rdf_out(int32_t segto, void *data, uint32_t type,
 327                     int32_t segment, int32_t wrt)
 328 {
 329     int32_t bytes = type & OUT_SIZMASK;
 330     struct RelocRec rr;
 331     uint8_t databuf[8], *pd;
 332
 333     if (segto == NO_SEG) {
 334         if ((type & OUT_TYPMASK) != OUT_RESERVE)
 335             error(ERR_NONFATAL,
 336                   "attempt to assemble code in ABSOLUTE space");
 337         return;
 338     }
 339
 340     segto >>= 1;                /* convert NASM segment no to RDF number */
 341
 342     if (segto != 0 && segto != 1 && segto != 2) {
 343         error(ERR_NONFATAL,
 344               "specified segment not supported by rdf output format");
 345         return;
 346     }
 347
 348     if (wrt != NO_SEG) {
 349         wrt = NO_SEG;           /* continue to do _something_ */
 350         error(ERR_NONFATAL, "WRT not supported by rdf output format");
 351     }
 352
 353     type &= OUT_TYPMASK;
 354
 355     if (segto == 2 && type != OUT_RESERVE) {
 356         error(ERR_NONFATAL, "BSS segments may not be initialized");
 357
 358         /* just reserve the space for now... */
 359
 360         if (type == OUT_REL2ADR)
 361             bytes = 2;
 362         else
 363             bytes = 4;
 364         type = OUT_RESERVE;
 365     }
 366
 367     if (type == OUT_RESERVE) {
 368         if (segto == 2)         /* BSS segment space reserverd */
 369             bsslength += bytes;
 370         else
 371             while (bytes--)
 372                 membufwrite(seg[segto], databuf, 1);
 373     } else if (type == OUT_RAWDATA) {
 374         if (segment != NO_SEG)
 375             error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
 376         membufwrite(seg[segto], data, bytes);
 377     } else if (type == OUT_ADDRESS) {
 378
 379         /* if segment == NO_SEG then we are writing an address of an
 380            object within the same segment - do not produce reloc rec. */
 381
 382         if (segment != NO_SEG) {
 383
 384             /* it's an address, so we must write a relocation record */
 385
 386             rr.type = 1;        /* type signature */
 387             rr.segment = segto; /* segment we're currently in */
 388             rr.offset = membuflength(seg[segto]);       /* current offset */
 389             rr.length = bytes;  /* length of reference */
 390             rr.refseg = segment;        /* segment referred to */
 391             write_reloc_rec(&rr);
 392         }
 393
 394         pd = databuf;           /* convert address to little-endian */
 395         WRITEADDR(pd, *(int64_t *)data, bytes);
 396         membufwrite(seg[segto], databuf, bytes);
 397     } else if (type == OUT_REL2ADR) {
 398         if (segment == segto)
 399             error(ERR_PANIC, "intra-segment OUT_REL2ADR");
 400         if (segment != NO_SEG && segment % 2) {
 401             error(ERR_NONFATAL,
 402                   "rdf format does not support segment base refs");
 403         }
 404
 405         rr.type = 1;            /* type signature */
 406         rr.segment = segto + 64;        /* segment we're currently in + rel flag */
 407         rr.offset = membuflength(seg[segto]);   /* current offset */
 408         rr.length = 2;          /* length of reference */
 409         rr.refseg = segment;    /* segment referred to */
 410         write_reloc_rec(&rr);
 411
 412         /* work out what to put in the code: offset of the end of this operand,
 413          * subtracted from any data specified, so that loader can just add
 414          * address of imported symbol onto it to get address relative to end of
 415          * instruction: import_address + data(offset) - end_of_instrn */
 416
 417         rr.offset = *(int64_t *)data - (rr.offset + bytes);
 418
 419         membufwrite(seg[segto], &rr.offset, -2);
 420     } else if (type == OUT_REL4ADR) {
 421         if ((segment == segto) && (globalbits != 64))
 422             error(ERR_PANIC, "intra-segment OUT_REL4ADR");
 423         if (segment != NO_SEG && segment % 2) {
 424             error(ERR_NONFATAL,
 425                   "rdf format does not support segment base refs");
 426         }
 427
 428         rr.type = 1;            /* type signature */
 429         rr.segment = segto + 64;        /* segment we're currently in + rel tag */
 430         rr.offset = membuflength(seg[segto]);   /* current offset */
 431         rr.length = 4;          /* length of reference */
 432         rr.refseg = segment;    /* segment referred to */
 433         write_reloc_rec(&rr);
 434
 435         rr.offset = *(int64_t *)data - (rr.offset + bytes);
 436         membufwrite(seg[segto], &rr.offset, -4);
 437     }
 438 }
 439
 440 static void rdf_cleanup(int debuginfo)
 441 {
 442     int32_t l;
 443     uint8_t b[4], *d;
 444     struct BSSRec bs;
 445
 446     (void)debuginfo;
 447
 448     /* should write imported & exported symbol declarations to header here */
 449
 450     /* generate the output file... */
 451     fwrite(RDOFFId, 6, 1, ofile);       /* file type magic number */
 452
 453     if (bsslength != 0) {       /* reserve BSS */
 454         bs.type = 5;
 455         bs.amount = bsslength;
 456         write_bss_rec(&bs);
 457     }
 458
 459     l = membuflength(header);
 460     d = b;
 461     WRITELONG(d, l);
 462
 463     fwrite(b, 4, 1, ofile);     /* write length of header */
 464     membufdump(header, ofile);  /* dump header */
 465
 466     l = membuflength(seg[0]);
 467     d = b;                      /* code segment */
 468     WRITELONG(d, l);
 469
 470     fwrite(b, 4, 1, ofile);
 471     membufdump(seg[0], ofile);
 472
 473     l = membuflength(seg[1]);
 474     d = b;                      /* data segment */
 475     WRITELONG(d, l);
 476
 477     fwrite(b, 4, 1, ofile);
 478     membufdump(seg[1], ofile);
 479
 480     freemembuf(header);
 481     freemembuf(seg[0]);
 482     freemembuf(seg[1]);
 483     fclose(ofile);
 484 }
 485
 486 static int32_t rdf_segbase(int32_t segment)
 487 {
 488     return segment;
 489 }
 490
 491 static int rdf_directive(char *directive, char *value, int pass)
 492 {
 493     struct DLLRec r;
 494
 495     if (!strcmp(directive, "library")) {
 496         if (pass == 1) {
 497             r.type = 4;
 498             strcpy(r.libname, value);
 499             write_dll_rec(&r);
 500         }
 501         return 1;
 502     }
 503
 504     return 0;
 505 }
 506
 507 static void rdf_filename(char *inname, char *outname, efunc error)
 508 {
 509     standard_extension(inname, outname, ".rdf", error);
 510 }
 511
 512 extern macros_t rdf_stdmac[];
 513
 514 static int rdf_set_info(enum geninfo type, char **val)
 515 {
 516     return 0;
 517 }
 518
 519 struct ofmt of_rdf = {
 520     "Relocatable Dynamic Object File Format v1.1",
 521 #ifdef OF_RDF2
 522     "oldrdf",
 523 #else
 524     "rdf",
 525 #endif
 526     NULL,
 527     null_debug_arr,
 528     &null_debug_form,
 529     rdf_stdmac,
 530     rdf_init,
 531     rdf_set_info,
 532     rdf_out,
 533     rdf_deflabel,
 534     rdf_section_names,
 535     rdf_segbase,
 536     rdf_directive,
 537     rdf_filename,
 538     rdf_cleanup
 539 };
 540
 541 #endif                          /* OF_RDF */