aniani/nasm
0
0
Fork 1
mirror of https://github.com/netwide-assembler/nasm.git synced 2025-10-10 00:25:06 -04:00
Code Activity
Files
1284cb15d962d7377646060e280efcb0c4600b68
nasm/output/outas86.c
H. Peter Anvin 2726aefb06 output: remove the legacy output entry point 
Remove the legacy output entry point. It has proven impossible to find
the time to completely port the backends all at once.

Instead, always generate the legacy output data, but put them into the
out_data structure. Then add a macro to explode these arguments into
separate variables, equivalent to the old function arguments. This
also centralizes the type definitions for these variables.

Most importantly, it means that the entire struct out_data is now
always available, which means that backends that need the additional
information available in that structure, such as the specific
instruction template, can access that information without needing to
revamp the entire backend code all at once.

Signed-off-by: H. Peter Anvin (Intel) <hpa@zytor.com>
2025-08-13 13:51:25 -07:00

610 lines
17 KiB
C
Raw Blame History

/* ----------------------------------------------------------------------- *
*
* Copyright 1996-2025 The NASM Authors - All Rights Reserved
* See the file AUTHORS included with the NASM distribution for
* the specific copyright holders.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following
* conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ----------------------------------------------------------------------- */
/*
* outas86.c output routines for the Netwide Assembler to produce
* Linux as86 (bin86-0.3) object files
*/
#include "compiler.h"
#include "nctype.h"
#include "nasm.h"
#include "nasmlib.h"
#include "error.h"
#include "saa.h"
#include "raa.h"
#include "outform.h"
#include "outlib.h"
#ifdef OF_AS86
struct Piece {
struct Piece *next;
int type; /* 0 = absolute, 1 = seg, 2 = sym */
int32_t offset; /* relative offset */
int number; /* symbol/segment number (4=bss) */
int32_t bytes; /* size of reloc or of absolute data */
bool relative; /* relative address? */
};
struct Symbol {
int32_t strpos; /* string table position of name */
int flags; /* symbol flags */
int segment; /* 4=bss at this point */
int32_t value; /* address, or COMMON variable size */
};
/*
* Section IDs - used in Piece.number and Symbol.segment.
*/
#define SECT_TEXT 0 /* text section */
#define SECT_DATA 3 /* data section */
#define SECT_BSS 4 /* bss section */
/*
* Flags used in Symbol.flags.
*/
#define SYM_ENTRY (1<<8)
#define SYM_EXPORT (1<<7)
#define SYM_IMPORT (1<<6)
#define SYM_ABSOLUTE (1<<4)
struct Section {
struct SAA *data;
uint32_t datalen, size, len;
int32_t index;
struct Piece *head, *last, **tail;
};
static struct Section stext, sdata;
static uint32_t bsslen;
static int32_t bssindex;
static struct SAA *syms;
static uint32_t nsyms;
static struct RAA *bsym;
static struct SAA *strs;
static size_t strslen;
static int as86_reloc_size;
static void as86_write(void);
static void as86_write_section(struct Section *, int);
static size_t as86_add_string(const char *name);
static void as86_sect_write(struct Section *, const uint8_t *,
uint32_t);
static void as86_init(void)
{
stext.data = saa_init(1L);
stext.datalen = 0L;
stext.head = stext.last = NULL;
stext.tail = &stext.head;
sdata.data = saa_init(1L);
sdata.datalen = 0L;
sdata.head = sdata.last = NULL;
sdata.tail = &sdata.head;
bsslen =
stext.len = stext.datalen = stext.size =
sdata.len = sdata.datalen = sdata.size = 0;
stext.index = seg_alloc();
sdata.index = seg_alloc();
bssindex = seg_alloc();
syms = saa_init((int32_t)sizeof(struct Symbol));
nsyms = 0;
bsym = raa_init();
strs = saa_init(1L);
strslen = 0;
/* as86 module name = input file minus extension */
as86_add_string(filename_set_extension(inname, ""));
}
static void as86_cleanup(void)
{
struct Piece *p;
as86_write();
saa_free(stext.data);
while (stext.head) {
p = stext.head;
stext.head = stext.head->next;
nasm_free(p);
}
saa_free(sdata.data);
while (sdata.head) {
p = sdata.head;
sdata.head = sdata.head->next;
nasm_free(p);
}
saa_free(syms);
raa_free(bsym);
saa_free(strs);
}
static int32_t as86_section_names(char *name, int *bits)
{
/*
* Default is 16 bits.
*/
if (!name) {
*bits = 16;
return stext.index;
}
if (!strcmp(name, ".text"))
return stext.index;
else if (!strcmp(name, ".data"))
return sdata.index;
else if (!strcmp(name, ".bss"))
return bssindex;
else
return NO_SEG;
}
static size_t as86_add_string(const char *name)
{
size_t pos = strslen;
size_t length = strlen(name);
saa_wbytes(strs, name, length + 1);
strslen += 1 + length;
return pos;
}
static void as86_deflabel(char *name, int32_t segment, int64_t offset,
int is_global, char *special)
{
bool is_start = false;
struct Symbol *sym;
if (special)
nasm_nonfatal("as86 format does not support any"
" special symbol types");
if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
if (strcmp(name, "..start")) {
nasm_nonfatal("unrecognised special symbol `%s'", name);
return;
} else {
is_start = true;
}
}
sym = saa_wstruct(syms);
sym->strpos = as86_add_string(name);
sym->flags = 0;
if (is_start)
sym->flags = SYM_ENTRY;
if (segment == NO_SEG)
sym->flags |= SYM_ABSOLUTE, sym->segment = 0;
else if (segment == stext.index)
sym->segment = SECT_TEXT;
else if (segment == sdata.index)
sym->segment = SECT_DATA;
else if (segment == bssindex)
sym->segment = SECT_BSS;
else {
sym->flags |= SYM_IMPORT;
sym->segment = 15;
}
if (is_global == 2)
sym->segment = 3; /* already have IMPORT */
if (is_global && !(sym->flags & SYM_IMPORT))
sym->flags |= SYM_EXPORT;
sym->value = offset;
/*
* define the references from external-symbol segment numbers
* to these symbol records.
*/
if (segment != NO_SEG && segment != stext.index &&
segment != sdata.index && segment != bssindex)
bsym = raa_write(bsym, segment, nsyms);
nsyms++;
}
static void as86_add_piece(struct Section *sect, int type, int32_t offset,
int32_t segment, int32_t bytes, int relative)
{
struct Piece *p;
sect->len += bytes;
if (type == 0 && sect->last && sect->last->type == 0) {
sect->last->bytes += bytes;
return;
}
p = sect->last = *sect->tail = nasm_malloc(sizeof(struct Piece));
sect->tail = &p->next;
p->next = NULL;
p->type = type;
p->offset = offset;
p->bytes = bytes;
p->relative = relative;
if (type == 1 && segment == stext.index)
p->number = SECT_TEXT;
else if (type == 1 && segment == sdata.index)
p->number = SECT_DATA;
else if (type == 1 && segment == bssindex)
p->number = SECT_BSS;
else if (type == 1)
p->number = raa_read(bsym, segment), p->type = 2;
}
static void as86_out(const struct out_data *out)
{
OUT_LEGACY(out,segto,data,type,size,segment,wrt);
struct Section *s;
int32_t offset;
uint8_t mydata[4], *p;
if (wrt != NO_SEG) {
wrt = NO_SEG; /* continue to do _something_ */
nasm_nonfatal("WRT not supported by as86 output format");
}
if (segto == stext.index)
s = &stext;
else if (segto == sdata.index)
s = &sdata;
else if (segto == bssindex)
s = NULL;
else {
nasm_warn(WARN_OTHER, "attempt to assemble code in"
" segment %d: defaulting to `.text'", segto);
s = &stext;
}
if (!s && type != OUT_RESERVE) {
nasm_warn(WARN_OTHER, "attempt to initialize memory in the"
" BSS section: ignored");
bsslen += realsize(type, size);
return;
}
memset(mydata, 0, sizeof(mydata));
if (type == OUT_RESERVE) {
if (s) {
nasm_warn(WARN_ZEROING, "uninitialized space declared in"
" %s section: zeroing",
(segto == stext.index ? "code" : "data"));
as86_sect_write(s, NULL, size);
as86_add_piece(s, 0, 0L, 0L, size, 0);
} else
bsslen += size;
} else if (type == OUT_RAWDATA) {
as86_sect_write(s, data, size);
as86_add_piece(s, 0, 0L, 0L, size, 0);
} else if (type == OUT_ADDRESS) {
int asize = abs((int)size);
if (segment != NO_SEG) {
if (segment % 2) {
nasm_nonfatal("as86 format does not support"
" segment base references");
} else {
offset = *(int64_t *)data;
as86_add_piece(s, 1, offset, segment, asize, 0);
}
} else {
p = mydata;
WRITELONG(p, *(int64_t *)data);
as86_sect_write(s, data, asize);
as86_add_piece(s, 0, 0L, 0L, asize, 0);
}
} else if (type == OUT_REL2ADR) {
if (segment != NO_SEG) {
if (segment % 2) {
nasm_nonfatal("as86 format does not support"
" segment base references");
} else {
offset = *(int64_t *)data;
as86_add_piece(s, 1, offset - size + 2, segment, 2L,
1);
}
}
} else if (type == OUT_REL4ADR) {
if (segment != NO_SEG) {
if (segment % 2) {
nasm_nonfatal("as86 format does not support"
" segment base references");
} else {
offset = *(int64_t *)data;
as86_add_piece(s, 1, offset - size + 4, segment, 4L,
1);
}
}
}
}
static void as86_write(void)
{
uint32_t i;
int32_t 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 ((uint32_t)stext.len > 65535L)
segsize |= 0x03000000L, seglen += 4;
else
segsize |= 0x02000000L, seglen += 2;
if ((uint32_t)sdata.len > 65535L)
segsize |= 0xC0000000L, seglen += 4;
else
segsize |= 0x80000000L, seglen += 2;
/*
* Emit the as86 header.
*/
fwriteint32_t(0x000186A3L, ofile);
fputc(0x2A, ofile);
fwriteint32_t(27 + symlen + seglen + strslen, ofile); /* header length */
fwriteint32_t(stext.len + sdata.len + bsslen, ofile);
fwriteint16_t(strslen, ofile);
fwriteint16_t(0, ofile); /* class = revision = 0 */
fwriteint32_t(0x55555555L, ofile); /* segment max sizes: always this */
fwriteint32_t(segsize, ofile); /* segment size descriptors */
if (segsize & 0x01000000L)
fwriteint32_t(stext.len, ofile);
else
fwriteint16_t(stext.len, ofile);
if (segsize & 0x40000000L)
fwriteint32_t(sdata.len + bsslen, ofile);
else
fwriteint16_t(sdata.len + bsslen, ofile);
fwriteint16_t(nsyms, ofile);
/*
* Write the symbol table.
*/
saa_rewind(syms);
for (i = 0; i < nsyms; i++) {
struct Symbol *sym = saa_rstruct(syms);
fwriteint16_t(sym->strpos, ofile);
fwriteint16_t(sym->flags, ofile);
switch (sym->flags & (3 << 14)) {
case 0 << 14:
break;
case 1 << 14:
fputc(sym->value, ofile);
break;
case 2 << 14:
fwriteint16_t(sym->value, ofile);
break;
case 3 << 14:
fwriteint32_t(sym->value, ofile);
break;
}
}
/*
* Write out the string table.
*/
saa_fpwrite(strs, ofile);
/*
* 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, ofile);
fwriteint32_t(bsslen, ofile);
} else if (bsslen > 255) {
fputc(0x12, ofile);
fwriteint16_t(bsslen, ofile);
} else if (bsslen) {
fputc(0x11, ofile);
fputc(bsslen, ofile);
}
fputc(0, ofile); /* termination */
}
static void as86_set_rsize(int size)
{
if (as86_reloc_size != size) {
switch (as86_reloc_size = size) {
case 1:
fputc(0x01, ofile);
break;
case 2:
fputc(0x02, ofile);
break;
case 4:
fputc(0x03, ofile);
break;
default:
nasm_panic("bizarre relocation size %d", size);
break;
}
}
}
static void as86_write_section(struct Section *sect, int index)
{
struct Piece *p;
uint32_t s;
int32_t length;
fputc(0x20 + index, ofile); /* 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];
int32_t tmplen = (length > 64 ? 64 : length);
fputc(0x40 | (tmplen & 0x3F), ofile);
saa_rnbytes(sect->data, buf, tmplen);
nasm_write(buf, tmplen, ofile);
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, ofile);
if (as86_reloc_size == 2)
fwriteint16_t(p->offset, ofile);
else
fwriteint32_t(p->offset, ofile);
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, ofile);
if (p->number > 255)
fwriteint16_t(p->number, ofile);
else
fputc(p->number, ofile);
switch (s) {
case 0:
break;
case 1:
fputc(p->offset, ofile);
break;
case 2:
fwriteint16_t(p->offset, ofile);
break;
case 3:
fwriteint32_t(p->offset, ofile);
break;
}
break;
}
}
static void as86_sect_write(struct Section *sect,
const uint8_t *data, uint32_t len)
{
saa_wbytes(sect->data, data, len);
sect->datalen += len;
}
extern macros_t as86_stdmac[];
const struct ofmt of_as86 = {
"as86 (bin86/dev86 toolchain)",
"as86",
".o",
0,
32,
null_debug_arr,
&null_debug_form,
as86_stdmac,
as86_init,
null_reset,
as86_out,
as86_deflabel,
as86_section_names,
NULL,
null_sectalign,
null_segbase,
null_directive,
as86_cleanup,
NULL /* pragma list */
};
#endif /* OF_AS86 */
View Git Blame Copy Permalink