/* ----------------------------------------------------------------------- *
*
* Copyright 1996-2017 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(int32_t segto, const void *data,
enum out_type type, uint64_t size,
int32_t segment, int32_t 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,
nasm_do_legacy_output,
as86_out,
as86_deflabel,
as86_section_names,
NULL,
null_sectalign,
null_segbase,
null_directive,
as86_cleanup,
NULL /* pragma list */
};
#endif /* OF_AS86 */