outas86.c

   1 /* outas86.c    output routines for the Netwide Assembler to produce
   2  *              Linux as86 (bin86-0.3) object files
   3  *
   4  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   5  * Julian Hall. All rights reserved. The software is
   6  * redistributable under the licence given in the file "Licence"
   7  * distributed in the NASM archive.
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <ctype.h>
  14
  15 #include "nasm.h"
  16 #include "nasmlib.h"
  17 #include "outform.h"
  18
  19 #ifdef OF_AS86
  20
  21 struct Piece {
  22     struct Piece *next;
  23     int type;                          /* 0 = absolute, 1 = seg, 2 = sym */
  24     long offset;                       /* relative offset */
  25     int number;                        /* symbol/segment number (4=bss) */
  26     long bytes;                        /* size of reloc or of absolute data */
  27     int relative;                      /* TRUE or FALSE */
  28 };
  29
  30 struct Symbol {
  31     long strpos;                       /* string table position of name */
  32     int flags;                         /* symbol flags */
  33     int segment;                       /* 4=bss at this point */
  34     long value;                        /* address, or COMMON variable size */
  35 };
  36
  37 /*
  38  * Section IDs - used in Piece.number and Symbol.segment.
  39  */
  40 #define SECT_TEXT 0                    /* text section */
  41 #define SECT_DATA 3                    /* data section */
  42 #define SECT_BSS 4                     /* bss section */
  43
  44 /*
  45  * Flags used in Symbol.flags.
  46  */
  47 #define SYM_ENTRY (1<<8)
  48 #define SYM_EXPORT (1<<7)
  49 #define SYM_IMPORT (1<<6)
  50 #define SYM_ABSOLUTE (1<<4)
  51
  52 struct Section {
  53     struct SAA *data;
  54     unsigned long datalen, size, len;
  55     long index;
  56     struct Piece *head, *last, **tail;
  57 };
  58
  59 static char as86_module[FILENAME_MAX];
  60
  61 static struct Section stext, sdata;
  62 static unsigned long bsslen;
  63 static long bssindex;
  64
  65 static struct SAA *syms;
  66 static unsigned long nsyms;
  67
  68 static struct RAA *bsym;
  69
  70 static struct SAA *strs;
  71 static unsigned long strslen;
  72
  73 static int as86_reloc_size;
  74
  75 static FILE *as86fp;
  76 static efunc error;
  77
  78 static void as86_write(void);
  79 static void as86_write_section (struct Section *, int);
  80 static int as86_add_string (char *name);
  81 static void as86_sect_write(struct Section *, unsigned char *, unsigned long);
  82
  83 static void as86_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
  84     as86fp = fp;
  85     error = errfunc;
  86     (void) ldef;                       /* placate optimisers */
  87     stext.data = saa_init(1L); stext.datalen = 0L;
  88     stext.head = stext.last = NULL;
  89     stext.tail = &stext.head;
  90     sdata.data = saa_init(1L); sdata.datalen = 0L;
  91     sdata.head = sdata.last = NULL;
  92     sdata.tail = &sdata.head;
  93     bsslen =
  94         stext.len = stext.datalen = stext.size =
  95         sdata.len = sdata.datalen = sdata.size = 0;
  96     stext.index = seg_alloc();
  97     sdata.index = seg_alloc();
  98     bssindex = seg_alloc();
  99     syms = saa_init((long)sizeof(struct Symbol));
 100     nsyms = 0;
 101     bsym = raa_init();
 102     strs = saa_init(1L);
 103     strslen = 0;
 104
 105     as86_add_string (as86_module);
 106 }
 107
 108 static void as86_cleanup(void) {
 109     struct Piece *p;
 110
 111     as86_write();
 112     fclose (as86fp);
 113     saa_free (stext.data);
 114     while (stext.head) {
 115         p = stext.head;
 116         stext.head = stext.head->next;
 117         nasm_free (p);
 118     }
 119     saa_free (sdata.data);
 120     while (sdata.head) {
 121         p = sdata.head;
 122         sdata.head = sdata.head->next;
 123         nasm_free (p);
 124     }
 125     saa_free (syms);
 126     raa_free (bsym);
 127     saa_free (strs);
 128 }
 129
 130 static long as86_section_names (char *name, int pass, int *bits) {
 131     /*
 132      * Default is 16 bits.
 133      */
 134     if (!name)
 135         *bits = 16;
 136
 137     if (!name)
 138         return stext.index;
 139
 140     if (!strcmp(name, ".text"))
 141         return stext.index;
 142     else if (!strcmp(name, ".data"))
 143         return sdata.index;
 144     else if (!strcmp(name, ".bss"))
 145         return bssindex;
 146     else
 147         return NO_SEG;
 148 }
 149
 150 static int as86_add_string (char *name) {
 151     int pos = strslen;
 152     int length = strlen(name);
 153
 154     saa_wbytes (strs, name, (long)(length+1));
 155     strslen += 1+length;
 156
 157     return pos;
 158 }
 159
 160 static void as86_deflabel (char *name, long segment, long offset,
 161                            int is_global, char *special) {
 162     struct Symbol *sym;
 163
 164     if (special)
 165         error (ERR_NONFATAL, "as86 format does not support any"
 166                " special symbol types");
 167
 168     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
 169         error (ERR_NONFATAL, "unrecognised special symbol `%s'", name);
 170         return;
 171     }
 172
 173     sym = saa_wstruct (syms);
 174
 175     sym->strpos = as86_add_string (name);
 176     sym->flags = 0;
 177     if (segment == NO_SEG)
 178         sym->flags |= SYM_ABSOLUTE, sym->segment = 0;
 179     else if (segment == stext.index)
 180         sym->segment = SECT_TEXT;
 181     else if (segment == sdata.index)
 182         sym->segment = SECT_DATA;
 183     else if (segment == bssindex)
 184         sym->segment = SECT_BSS;
 185     else {
 186         sym->flags |= SYM_IMPORT;
 187         sym->segment = 15;
 188     }
 189
 190     if (is_global == 2)
 191         sym->segment = 3;       /* already have IMPORT */
 192
 193     if (is_global && !(sym->flags & SYM_IMPORT))
 194         sym->flags |= SYM_EXPORT;
 195
 196     sym->value = offset;
 197
 198     /*
 199      * define the references from external-symbol segment numbers
 200      * to these symbol records.
 201      */
 202     if (segment != NO_SEG && segment != stext.index &&
 203         segment != sdata.index && segment != bssindex)
 204         bsym = raa_write (bsym, segment, nsyms);
 205
 206     nsyms++;
 207 }
 208
 209 static void as86_add_piece (struct Section *sect, int type, long offset,
 210                             long segment, long bytes, int relative) {
 211     struct Piece *p;
 212
 213     sect->len += bytes;
 214
 215     if (type == 0 && sect->last && sect->last->type == 0) {
 216         sect->last->bytes += bytes;
 217         return;
 218     }
 219
 220     p = sect->last = *sect->tail = nasm_malloc(sizeof(struct Piece));
 221     sect->tail = &p->next;
 222     p->next = NULL;
 223
 224     p->type = type;
 225     p->offset = offset;
 226     p->bytes = bytes;
 227     p->relative = relative;
 228
 229     if (type == 1 && segment == stext.index)
 230         p->number = SECT_TEXT;
 231     else if (type == 1 && segment == sdata.index)
 232         p->number = SECT_DATA;
 233     else if (type == 1 && segment == bssindex)
 234         p->number = SECT_BSS;
 235     else if (type == 1)
 236         p->number = raa_read (bsym, segment), p->type = 2;
 237 }
 238
 239 static void as86_out (long segto, void *data, unsigned long type,
 240                       long segment, long wrt) {
 241     struct Section *s;
 242     long realbytes = type & OUT_SIZMASK;
 243     long offset;
 244     unsigned char mydata[4], *p;
 245
 246     if (wrt != NO_SEG) {
 247         wrt = NO_SEG;                  /* continue to do _something_ */
 248         error (ERR_NONFATAL, "WRT not supported by as86 output format");
 249     }
 250
 251     type &= OUT_TYPMASK;
 252
 253     /*
 254      * handle absolute-assembly (structure definitions)
 255      */
 256     if (segto == NO_SEG) {
 257         if (type != OUT_RESERVE)
 258             error (ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
 259                    " space");
 260         return;
 261     }
 262
 263     if (segto == stext.index)
 264         s = &stext;
 265     else if (segto == sdata.index)
 266         s = &sdata;
 267     else if (segto == bssindex)
 268         s = NULL;
 269     else {
 270         error(ERR_WARNING, "attempt to assemble code in"
 271               " segment %d: defaulting to `.text'", segto);
 272         s = &stext;
 273     }
 274
 275     if (!s && type != OUT_RESERVE) {
 276         error(ERR_WARNING, "attempt to initialise memory in the"
 277               " BSS section: ignored");
 278         if (type == OUT_REL2ADR)
 279             realbytes = 2;
 280         else if (type == OUT_REL4ADR)
 281             realbytes = 4;
 282         bsslen += realbytes;
 283         return;
 284     }
 285
 286     if (type == OUT_RESERVE) {
 287         if (s) {
 288             error(ERR_WARNING, "uninitialised space declared in"
 289                   " %s section: zeroing",
 290                   (segto == stext.index ? "code" : "data"));
 291             as86_sect_write (s, NULL, realbytes);
 292             as86_add_piece (s, 0, 0L, 0L, realbytes, 0);
 293         } else
 294             bsslen += realbytes;
 295     } else if (type == OUT_RAWDATA) {
 296         if (segment != NO_SEG)
 297             error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
 298         as86_sect_write (s, data, realbytes);
 299         as86_add_piece (s, 0, 0L, 0L, realbytes, 0);
 300     } else if (type == OUT_ADDRESS) {
 301         if (segment != NO_SEG) {
 302             if (segment % 2) {
 303                 error(ERR_NONFATAL, "as86 format does not support"
 304                       " segment base references");
 305             } else{
 306                 offset = * (long *) data;
 307                 as86_add_piece (s, 1, offset, segment, realbytes, 0);
 308             }
 309         } else {
 310             p = mydata;
 311             WRITELONG (p, * (long *) data);
 312             as86_sect_write (s, data, realbytes);
 313             as86_add_piece (s, 0, 0L, 0L, realbytes, 0);
 314         }
 315     } else if (type == OUT_REL2ADR) {
 316         if (segment == segto)
 317             error(ERR_PANIC, "intra-segment OUT_REL2ADR");
 318         if (segment != NO_SEG) {
 319             if (segment % 2) {
 320                 error(ERR_NONFATAL, "as86 format does not support"
 321                       " segment base references");
 322             } else {
 323                 offset = * (long *) data;
 324                 as86_add_piece (s, 1, offset-realbytes+2, segment, 2L, 1);
 325             }
 326         }
 327     } else if (type == OUT_REL4ADR) {
 328         if (segment == segto)
 329             error(ERR_PANIC, "intra-segment OUT_REL4ADR");
 330         if (segment != NO_SEG) {
 331             if (segment % 2) {
 332                 error(ERR_NONFATAL, "as86 format does not support"
 333                       " segment base references");
 334             } else {
 335                 offset = * (long *) data;
 336                 as86_add_piece (s, 1, offset-realbytes+4, segment, 4L, 1);
 337             }
 338         }
 339     }
 340 }
 341
 342 static void as86_write(void) {
 343     int i;
 344     long symlen, seglen, segsize;
 345
 346     /*
 347      * First, go through the symbol records working out how big
 348      * each will be. Also fix up BSS references at this time, and
 349      * set the flags words up completely.
 350      */
 351     symlen = 0;
 352     saa_rewind (syms);
 353     for (i = 0; i < nsyms; i++) {
 354         struct Symbol *sym = saa_rstruct (syms);
 355         if (sym->segment == SECT_BSS)
 356             sym->segment = SECT_DATA, sym->value += sdata.len;
 357         sym->flags |= sym->segment;
 358         if (sym->value == 0)
 359             sym->flags |= 0 << 14, symlen += 4;
 360         else if (sym->value >= 0 && sym->value <= 255)
 361             sym->flags |= 1 << 14, symlen += 5;
 362         else if (sym->value >= 0 && sym->value <= 65535L)
 363             sym->flags |= 2 << 14, symlen += 6;
 364         else
 365             sym->flags |= 3 << 14, symlen += 8;
 366     }
 367
 368     /*
 369      * Now do the same for the segments, and get the segment size
 370      * descriptor word at the same time.
 371      */
 372     seglen = segsize = 0;
 373     if ((unsigned long) stext.len > 65535L)
 374         segsize |= 0x03000000L, seglen += 4;
 375     else
 376         segsize |= 0x02000000L, seglen += 2;
 377     if ((unsigned long) sdata.len > 65535L)
 378         segsize |= 0xC0000000L, seglen += 4;
 379     else
 380         segsize |= 0x80000000L, seglen += 2;
 381
 382     /*
 383      * Emit the as86 header.
 384      */
 385     fwritelong (0x000186A3L, as86fp);
 386     fputc (0x2A, as86fp);
 387     fwritelong (27+symlen+seglen+strslen, as86fp);   /* header length */
 388     fwritelong (stext.len+sdata.len, as86fp);
 389     fwriteshort (strslen, as86fp);
 390     fwriteshort (0, as86fp);           /* class = revision = 0 */
 391     fwritelong (0x55555555L, as86fp);   /* segment max sizes: always this */
 392     fwritelong (segsize, as86fp);      /* segment size descriptors */
 393     if (segsize & 0x01000000L)
 394         fwritelong (stext.len, as86fp);
 395     else
 396         fwriteshort (stext.len, as86fp);
 397     if (segsize & 0x40000000L)
 398         fwritelong (sdata.len, as86fp);
 399     else
 400         fwriteshort (sdata.len, as86fp);
 401     fwriteshort (nsyms, as86fp);
 402
 403     /*
 404      * Write the symbol table.
 405      */
 406     saa_rewind (syms);
 407     for (i = 0; i < nsyms; i++) {
 408         struct Symbol *sym = saa_rstruct (syms);
 409         fwriteshort (sym->strpos, as86fp);
 410         fwriteshort (sym->flags, as86fp);
 411         switch (sym->flags & (3<<14)) {
 412           case 0<<14: break;
 413           case 1<<14: fputc (sym->value, as86fp); break;
 414           case 2<<14: fwriteshort (sym->value, as86fp); break;
 415           case 3<<14: fwritelong (sym->value, as86fp); break;
 416         }
 417     }
 418
 419     /*
 420      * Write out the string table.
 421      */
 422     saa_fpwrite (strs, as86fp);
 423
 424     /*
 425      * Write the program text.
 426      */
 427     as86_reloc_size = -1;
 428     as86_write_section (&stext, SECT_TEXT);
 429     as86_write_section (&sdata, SECT_DATA);
 430     fputc (0, as86fp);                 /* termination */
 431 }
 432
 433 static void as86_set_rsize (int size) {
 434     if (as86_reloc_size != size) {
 435         switch (as86_reloc_size = size) {
 436           case 1: fputc (0x01, as86fp); break;
 437           case 2: fputc (0x02, as86fp); break;
 438           case 4: fputc (0x03, as86fp); break;
 439           default: error (ERR_PANIC, "bizarre relocation size %d", size);
 440         }
 441     }
 442 }
 443
 444 static void as86_write_section (struct Section *sect, int index) {
 445     struct Piece *p;
 446     unsigned long s;
 447     long length;
 448
 449     fputc (0x20+index, as86fp);        /* select the right section */
 450
 451     saa_rewind (sect->data);
 452
 453     for (p = sect->head; p; p = p->next)
 454         switch (p->type) {
 455           case 0:
 456             /*
 457              * Absolute data. Emit it in chunks of at most 64
 458              * bytes.
 459              */
 460             length = p->bytes;
 461             do {
 462                 char buf[64];
 463                 long tmplen = (length > 64 ? 64 : length);
 464                 fputc (0x40 | (tmplen & 0x3F), as86fp);
 465                 saa_rnbytes (sect->data, buf, tmplen);
 466                 fwrite (buf, 1, tmplen, as86fp);
 467                 length -= tmplen;
 468             } while (length > 0);
 469             break;
 470           case 1:
 471             /*
 472              * A segment-type relocation. First fix up the BSS.
 473              */
 474             if (p->number == SECT_BSS)
 475                 p->number = SECT_DATA, p->offset += sdata.len;
 476             as86_set_rsize (p->bytes);
 477             fputc (0x80 | (p->relative ? 0x20 : 0) | p->number, as86fp);
 478             if (as86_reloc_size == 2)
 479                 fwriteshort (p->offset, as86fp);
 480             else
 481                 fwritelong (p->offset, as86fp);
 482             break;
 483           case 2:
 484             /*
 485              * A symbol-type relocation.
 486              */
 487             as86_set_rsize (p->bytes);
 488             s = p->offset;
 489             if (s > 65535L)
 490                 s = 3;
 491             else if (s > 255)
 492                 s = 2;
 493             else if (s > 0)
 494                 s = 1;
 495             else
 496                 s = 0;
 497             fputc (0xC0 |
 498                    (p->relative ? 0x20 : 0) |
 499                    (p->number > 255 ? 0x04 : 0) | s, as86fp);
 500             if (p->number > 255)
 501                 fwriteshort (p->number, as86fp);
 502             else
 503                 fputc (p->number, as86fp);
 504             switch ((int)s) {
 505               case 0: break;
 506               case 1: fputc (p->offset, as86fp); break;
 507               case 2: fwriteshort (p->offset, as86fp); break;
 508               case 3: fwritelong (p->offset, as86fp); break;
 509             }
 510             break;
 511         }
 512 }
 513
 514 static void as86_sect_write (struct Section *sect,
 515                              unsigned char *data, unsigned long len) {
 516     saa_wbytes (sect->data, data, len);
 517     sect->datalen += len;
 518 }
 519
 520 static long as86_segbase (long segment) {
 521     return segment;
 522 }
 523
 524 static int as86_directive (char *directive, char *value, int pass) {
 525     return 0;
 526 }
 527
 528 static void as86_filename (char *inname, char *outname, efunc error) {
 529     char *p;
 530
 531     if ( (p = strrchr (inname, '.')) != NULL) {
 532         strncpy (as86_module, inname, p-inname);
 533         as86_module[p-inname] = '\0';
 534     } else
 535         strcpy (as86_module, inname);
 536
 537     standard_extension (inname, outname, ".o", error);
 538 }
 539
 540 static char *as86_stdmac[] = {
 541     "%define __SECT__ [section .text]",
 542     NULL
 543 };
 544
 545 struct ofmt of_as86 = {
 546     "Linux as86 (bin86 version 0.3) object files",
 547     "as86",
 548     as86_stdmac,
 549     as86_init,
 550     as86_out,
 551     as86_deflabel,
 552     as86_section_names,
 553     as86_segbase,
 554     as86_directive,
 555     as86_filename,
 556     as86_cleanup
 557 };
 558
 559 #endif /* OF_AS86 */