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