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