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