开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
outas86.c
资源名称：nasm-0.98.zip　[点击查看]
上传用户：yuppie_zhu
上传日期：2007-01-08
资源大小：535k
文件大小：15k
源码类别：

编译器/解释器

开发平台：

C/C++

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