outas86.c

32位汇编编译器nasm源代码

                      " segment base references");
            } else {
                offset = *(long *)data;
                as86_add_piece(s, 1, offset, segment, realbytes, 0);
            }
        } else {
            p = mydata;
            WRITELONG(p, *(long *)data);
            as86_sect_write(s, data, realbytes);
            as86_add_piece(s, 0, 0L, 0L, realbytes, 0);
        }
    } else if (type == OUT_REL2ADR) {
        if (segment == segto)
            error(ERR_PANIC, "intra-segment OUT_REL2ADR");
        if (segment != NO_SEG) {
            if (segment % 2) {
                error(ERR_NONFATAL, "as86 format does not support"
                      " segment base references");
            } else {
                offset = *(long *)data;
                as86_add_piece(s, 1, offset - realbytes + 2, segment, 2L,
                               1);
            }
        }
    } else if (type == OUT_REL4ADR) {
        if (segment == segto)
            error(ERR_PANIC, "intra-segment OUT_REL4ADR");
        if (segment != NO_SEG) {
            if (segment % 2) {
                error(ERR_NONFATAL, "as86 format does not support"
                      " segment base references");
            } else {
                offset = *(long *)data;
                as86_add_piece(s, 1, offset - realbytes + 4, segment, 4L,
                               1);
            }
        }
    }
}

static void as86_write(void)
{
    unsigned long i;
    long symlen, seglen, segsize;

    /*
     * First, go through the symbol records working out how big
     * each will be. Also fix up BSS references at this time, and
     * set the flags words up completely.
     */
    symlen = 0;
    saa_rewind(syms);
    for (i = 0; i < nsyms; i++) {
        struct Symbol *sym = saa_rstruct(syms);
        if (sym->segment == SECT_BSS)
            sym->segment = SECT_DATA, sym->value += sdata.len;
        sym->flags |= sym->segment;
        if (sym->value == 0)
            sym->flags |= 0 << 14, symlen += 4;
        else if (sym->value >= 0 && sym->value <= 255)
            sym->flags |= 1 << 14, symlen += 5;
        else if (sym->value >= 0 && sym->value <= 65535L)
            sym->flags |= 2 << 14, symlen += 6;
        else
            sym->flags |= 3 << 14, symlen += 8;
    }

    /*
     * Now do the same for the segments, and get the segment size
     * descriptor word at the same time.
     */
    seglen = segsize = 0;
    if ((unsigned long)stext.len > 65535L)
        segsize |= 0x03000000L, seglen += 4;
    else
        segsize |= 0x02000000L, seglen += 2;
    if ((unsigned long)sdata.len > 65535L)
        segsize |= 0xC0000000L, seglen += 4;
    else
        segsize |= 0x80000000L, seglen += 2;

    /*
     * Emit the as86 header.
     */
    fwritelong(0x000186A3L, as86fp);
    fputc(0x2A, as86fp);
    fwritelong(27 + symlen + seglen + strslen, as86fp); /* header length */
    fwritelong(stext.len + sdata.len + bsslen, as86fp);
    fwriteshort(strslen, as86fp);
    fwriteshort(0, as86fp);     /* class = revision = 0 */
    fwritelong(0x55555555L, as86fp);    /* segment max sizes: always this */
    fwritelong(segsize, as86fp);        /* segment size descriptors */
    if (segsize & 0x01000000L)
        fwritelong(stext.len, as86fp);
    else
        fwriteshort(stext.len, as86fp);
    if (segsize & 0x40000000L)
        fwritelong(sdata.len + bsslen, as86fp);
    else
        fwriteshort(sdata.len + bsslen, as86fp);
    fwriteshort(nsyms, as86fp);

    /*
     * Write the symbol table.
     */
    saa_rewind(syms);
    for (i = 0; i < nsyms; i++) {
        struct Symbol *sym = saa_rstruct(syms);
        fwriteshort(sym->strpos, as86fp);
        fwriteshort(sym->flags, as86fp);
        switch (sym->flags & (3 << 14)) {
        case 0 << 14:
            break;
        case 1 << 14:
            fputc(sym->value, as86fp);
            break;
        case 2 << 14:
            fwriteshort(sym->value, as86fp);
            break;
        case 3 << 14:
            fwritelong(sym->value, as86fp);
            break;
        }
    }

    /*
     * Write out the string table.
     */
    saa_fpwrite(strs, as86fp);

    /*
     * Write the program text.
     */
    as86_reloc_size = -1;
    as86_write_section(&stext, SECT_TEXT);
    as86_write_section(&sdata, SECT_DATA);
    /*
     * Append the BSS section to the .data section
     */
    if (bsslen > 65535L) {
        fputc(0x13, as86fp);
        fwritelong(bsslen, as86fp);
    } else if (bsslen > 255) {
        fputc(0x12, as86fp);
        fwriteshort(bsslen, as86fp);
    } else if (bsslen) {
        fputc(0x11, as86fp);
        fputc(bsslen, as86fp);
    }

    fputc(0, as86fp);           /* termination */
}

static void as86_set_rsize(int size)
{
    if (as86_reloc_size != size) {
        switch (as86_reloc_size = size) {
        case 1:
            fputc(0x01, as86fp);
            break;
        case 2:
            fputc(0x02, as86fp);
            break;
        case 4:
            fputc(0x03, as86fp);
            break;
        default:
            error(ERR_PANIC, "bizarre relocation size %d", size);
        }
    }
}

static void as86_write_section(struct Section *sect, int index)
{
    struct Piece *p;
    unsigned long s;
    long length;

    fputc(0x20 + index, as86fp);        /* select the right section */

    saa_rewind(sect->data);

    for (p = sect->head; p; p = p->next)
        switch (p->type) {
        case 0:
            /*
             * Absolute data. Emit it in chunks of at most 64
             * bytes.
             */
            length = p->bytes;
            do {
                char buf[64];
                long tmplen = (length > 64 ? 64 : length);
                fputc(0x40 | (tmplen & 0x3F), as86fp);
                saa_rnbytes(sect->data, buf, tmplen);
                fwrite(buf, 1, tmplen, as86fp);
                length -= tmplen;
            } while (length > 0);
            break;
        case 1:
            /*
             * A segment-type relocation. First fix up the BSS.
             */
            if (p->number == SECT_BSS)
                p->number = SECT_DATA, p->offset += sdata.len;
            as86_set_rsize(p->bytes);
            fputc(0x80 | (p->relative ? 0x20 : 0) | p->number, as86fp);
            if (as86_reloc_size == 2)
                fwriteshort(p->offset, as86fp);
            else
                fwritelong(p->offset, as86fp);
            break;
        case 2:
            /*
             * A symbol-type relocation.
             */
            as86_set_rsize(p->bytes);
            s = p->offset;
            if (s > 65535L)
                s = 3;
            else if (s > 255)
                s = 2;
            else if (s > 0)
                s = 1;
            else
                s = 0;
            fputc(0xC0 |
                  (p->relative ? 0x20 : 0) |
                  (p->number > 255 ? 0x04 : 0) | s, as86fp);
            if (p->number > 255)
                fwriteshort(p->number, as86fp);
            else
                fputc(p->number, as86fp);
            switch ((int)s) {
            case 0:
                break;
            case 1:
                fputc(p->offset, as86fp);
                break;
            case 2:
                fwriteshort(p->offset, as86fp);
                break;
            case 3:
                fwritelong(p->offset, as86fp);
                break;
            }
            break;
        }
}

static void as86_sect_write(struct Section *sect,
                            const unsigned char *data, unsigned long len)
{
    saa_wbytes(sect->data, data, len);
    sect->datalen += len;
}

static long as86_segbase(long segment)
{
    return segment;
}

static int as86_directive(char *directive, char *value, int pass)
{
    return 0;
}

static void as86_filename(char *inname, char *outname, efunc error)
{
    char *p;

    if ((p = strrchr(inname, '.')) != NULL) {
        strncpy(as86_module, inname, p - inname);
        as86_module[p - inname] = '\0';
    } else
        strcpy(as86_module, inname);

    standard_extension(inname, outname, ".o", error);
}

static const char *as86_stdmac[] = {
    "%define __SECT__ [section .text]",
    "%macro __NASM_CDecl__ 1",
    "%endmacro",
    NULL
};

static int as86_set_info(enum geninfo type, char **val)
{
    return 0;
}
void as86_linenumber(char *name, long segment, long offset, int is_main,
                     int lineno)
{
}
struct ofmt of_as86 = {
    "Linux as86 (bin86 version 0.3) object files",
    "as86",
    NULL,
    null_debug_arr,
    &null_debug_form,
    as86_stdmac,
    as86_init,
    as86_set_info,
    as86_out,
    as86_deflabel,
    as86_section_names,
    as86_segbase,
    as86_directive,
    as86_filename,
    as86_cleanup
};

#endif                          /* OF_AS86 */