396 lines
9.3 KiB
C
396 lines
9.3 KiB
C
/* outbin.c output routines for the Netwide Assembler to produce
|
|
* flat-form binary files
|
|
*
|
|
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
|
|
* Julian Hall. All rights reserved. The software is
|
|
* redistributable under the licence given in the file "Licence"
|
|
* distributed in the NASM archive.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
|
|
#include "nasm.h"
|
|
#include "nasmlib.h"
|
|
#include "outform.h"
|
|
|
|
#ifdef OF_BIN
|
|
|
|
static FILE *fp;
|
|
static efunc error;
|
|
|
|
static struct Section {
|
|
struct SAA *contents;
|
|
long length;
|
|
long index;
|
|
} textsect, datasect;
|
|
static long bsslen, bssindex;
|
|
|
|
static struct Reloc {
|
|
struct Reloc *next;
|
|
long posn;
|
|
long bytes;
|
|
long secref;
|
|
long secrel;
|
|
struct Section *target;
|
|
} *relocs, **reloctail;
|
|
|
|
static long data_align, bss_align;
|
|
|
|
static long start_point;
|
|
|
|
static void add_reloc (struct Section *s, long bytes, long secref,
|
|
long secrel)
|
|
{
|
|
struct Reloc *r;
|
|
|
|
r = *reloctail = nasm_malloc(sizeof(struct Reloc));
|
|
reloctail = &r->next;
|
|
r->next = NULL;
|
|
r->posn = s->length;
|
|
r->bytes = bytes;
|
|
r->secref = secref;
|
|
r->secrel = secrel;
|
|
r->target = s;
|
|
}
|
|
|
|
static void bin_init (FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval)
|
|
{
|
|
fp = afp;
|
|
|
|
(void) eval; /* Don't warn that this parameter is unused */
|
|
|
|
error = errfunc;
|
|
(void) ldef; /* placate optimisers */
|
|
|
|
start_point = 0L; /* default */
|
|
textsect.contents = saa_init(1L);
|
|
datasect.contents = saa_init(1L);
|
|
textsect.length = datasect.length = 0;
|
|
textsect.index = seg_alloc();
|
|
datasect.index = seg_alloc();
|
|
bsslen = 0;
|
|
bssindex = seg_alloc();
|
|
relocs = NULL;
|
|
reloctail = &relocs;
|
|
data_align = bss_align = 4;
|
|
}
|
|
|
|
static void bin_cleanup (int debuginfo)
|
|
{
|
|
struct Reloc *r;
|
|
long datapos, datagap, bsspos;
|
|
|
|
(void) debuginfo;
|
|
|
|
datapos = start_point + textsect.length;
|
|
datapos = (datapos + data_align-1) & ~(data_align-1);
|
|
datagap = datapos - (start_point + textsect.length);
|
|
bsspos = datapos + datasect.length;
|
|
bsspos = (bsspos + bss_align-1) & ~(bss_align-1);
|
|
|
|
saa_rewind (textsect.contents);
|
|
saa_rewind (datasect.contents);
|
|
|
|
for (r = relocs; r; r = r->next)
|
|
{
|
|
unsigned char *p, *q, mydata[4];
|
|
long l;
|
|
|
|
saa_fread (r->target->contents, r->posn, mydata, r->bytes);
|
|
p = q = mydata;
|
|
l = *p++;
|
|
if (r->bytes > 1) {
|
|
l += ((long)*p++) << 8;
|
|
if (r->bytes == 4) {
|
|
l += ((long)*p++) << 16;
|
|
l += ((long)*p++) << 24;
|
|
}
|
|
}
|
|
|
|
if (r->secref == textsect.index)
|
|
l += start_point;
|
|
else if (r->secref == datasect.index)
|
|
l += datapos;
|
|
else if (r->secref == bssindex)
|
|
l += bsspos;
|
|
|
|
if (r->secrel == textsect.index)
|
|
l -= start_point;
|
|
else if (r->secrel == datasect.index)
|
|
l -= datapos;
|
|
else if (r->secrel == bssindex)
|
|
l -= bsspos;
|
|
|
|
if (r->bytes == 4)
|
|
WRITELONG(q, l);
|
|
else if (r->bytes == 2)
|
|
WRITESHORT(q, l);
|
|
else
|
|
*q++ = l & 0xFF;
|
|
saa_fwrite (r->target->contents, r->posn, mydata, r->bytes);
|
|
}
|
|
saa_fpwrite (textsect.contents, fp);
|
|
if (datasect.length > 0) {
|
|
while (datagap--)
|
|
fputc('\0', fp);
|
|
saa_fpwrite (datasect.contents, fp);
|
|
}
|
|
fclose (fp);
|
|
saa_free (textsect.contents);
|
|
saa_free (datasect.contents);
|
|
while (relocs) {
|
|
r = relocs->next;
|
|
nasm_free (relocs);
|
|
relocs = r;
|
|
}
|
|
}
|
|
|
|
static void bin_out (long segto, void *data, unsigned long type,
|
|
long segment, long wrt)
|
|
{
|
|
unsigned char *p, mydata[4];
|
|
struct Section *s;
|
|
long realbytes;
|
|
|
|
if (wrt != NO_SEG) {
|
|
wrt = NO_SEG; /* continue to do _something_ */
|
|
error (ERR_NONFATAL, "WRT not supported by binary output format");
|
|
}
|
|
|
|
/*
|
|
* handle absolute-assembly (structure definitions)
|
|
*/
|
|
if (segto == NO_SEG) {
|
|
if ((type & OUT_TYPMASK) != OUT_RESERVE)
|
|
error (ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
|
|
" space");
|
|
return;
|
|
}
|
|
|
|
if (segto == bssindex) { /* BSS */
|
|
if ((type & OUT_TYPMASK) != OUT_RESERVE)
|
|
error(ERR_WARNING, "attempt to initialise memory in the"
|
|
" BSS section: ignored");
|
|
s = NULL;
|
|
} else if (segto == textsect.index) {
|
|
s = &textsect;
|
|
} else if (segto == datasect.index) {
|
|
s = &datasect;
|
|
} else {
|
|
error(ERR_WARNING, "attempt to assemble code in"
|
|
" segment %d: defaulting to `.text'", segto);
|
|
s = &textsect;
|
|
}
|
|
|
|
if ((type & OUT_TYPMASK) == OUT_ADDRESS) {
|
|
if (segment != NO_SEG &&
|
|
segment != textsect.index &&
|
|
segment != datasect.index &&
|
|
segment != bssindex) {
|
|
if (segment % 2)
|
|
error(ERR_NONFATAL, "binary output format does not support"
|
|
" segment base references");
|
|
else
|
|
error(ERR_NONFATAL, "binary output format does not support"
|
|
" external references");
|
|
segment = NO_SEG;
|
|
}
|
|
if (s) {
|
|
if (segment != NO_SEG)
|
|
add_reloc (s, type & OUT_SIZMASK, segment, -1L);
|
|
p = mydata;
|
|
if ((type & OUT_SIZMASK) == 4)
|
|
WRITELONG (p, *(long *)data);
|
|
else
|
|
WRITESHORT (p, *(long *)data);
|
|
saa_wbytes (s->contents, mydata, type & OUT_SIZMASK);
|
|
s->length += type & OUT_SIZMASK;
|
|
} else
|
|
bsslen += type & OUT_SIZMASK;
|
|
} else if ((type & OUT_TYPMASK) == OUT_RAWDATA) {
|
|
type &= OUT_SIZMASK;
|
|
p = data;
|
|
if (s) {
|
|
saa_wbytes (s->contents, data, type);
|
|
s->length += type;
|
|
} else
|
|
bsslen += type;
|
|
} else if ((type & OUT_TYPMASK) == OUT_RESERVE) {
|
|
if (s) {
|
|
error(ERR_WARNING, "uninitialised space declared in"
|
|
" %s section: zeroing",
|
|
(segto == textsect.index ? "code" : "data"));
|
|
}
|
|
type &= OUT_SIZMASK;
|
|
if (s) {
|
|
saa_wbytes (s->contents, NULL, type);
|
|
s->length += type;
|
|
} else
|
|
bsslen += type;
|
|
}
|
|
else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
|
|
(type & OUT_TYPMASK) == OUT_REL4ADR)
|
|
{
|
|
realbytes = ((type & OUT_TYPMASK) == OUT_REL4ADR ? 4 : 2);
|
|
if (segment != NO_SEG &&
|
|
segment != textsect.index &&
|
|
segment != datasect.index &&
|
|
segment != bssindex) {
|
|
if (segment % 2)
|
|
error(ERR_NONFATAL, "binary output format does not support"
|
|
" segment base references");
|
|
else
|
|
error(ERR_NONFATAL, "binary output format does not support"
|
|
" external references");
|
|
segment = NO_SEG;
|
|
}
|
|
if (s) {
|
|
add_reloc (s, realbytes, segment, segto);
|
|
p = mydata;
|
|
if (realbytes == 4)
|
|
WRITELONG (p, *(long*)data - realbytes - s->length);
|
|
else
|
|
WRITESHORT (p, *(long*)data - realbytes - s->length);
|
|
saa_wbytes (s->contents, mydata, realbytes);
|
|
s->length += realbytes;
|
|
} else
|
|
bsslen += realbytes;
|
|
}
|
|
}
|
|
|
|
static void bin_deflabel (char *name, long segment, long offset,
|
|
int is_global, char *special)
|
|
{
|
|
|
|
(void) segment; /* Don't warn that this parameter is unused */
|
|
(void) offset; /* Don't warn that this parameter is unused */
|
|
|
|
if (special)
|
|
error (ERR_NONFATAL, "binary format does not support any"
|
|
" special symbol types");
|
|
|
|
if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
|
|
error (ERR_NONFATAL, "unrecognised special symbol `%s'", name);
|
|
return;
|
|
}
|
|
|
|
if (is_global == 2) {
|
|
error (ERR_NONFATAL, "binary output format does not support common"
|
|
" variables");
|
|
}
|
|
}
|
|
|
|
static long bin_secname (char *name, int pass, int *bits)
|
|
{
|
|
int sec_index;
|
|
long *sec_align;
|
|
char *p;
|
|
|
|
(void) pass; /* Don't warn that this parameter is unused */
|
|
|
|
/*
|
|
* Default is 16 bits.
|
|
*/
|
|
if (!name)
|
|
*bits = 16;
|
|
|
|
if (!name)
|
|
return textsect.index;
|
|
|
|
p = name;
|
|
while (*p && !isspace(*p)) p++;
|
|
if (*p) *p++ = '\0';
|
|
if (!strcmp(name, ".text")) {
|
|
sec_index = textsect.index;
|
|
sec_align = NULL;
|
|
} else if (!strcmp(name, ".data")) {
|
|
sec_index = datasect.index;
|
|
sec_align = &data_align;
|
|
} else if (!strcmp(name, ".bss")) {
|
|
sec_index = bssindex;
|
|
sec_align = &bss_align;
|
|
} else
|
|
return NO_SEG;
|
|
|
|
if (*p) {
|
|
if (!nasm_strnicmp(p,"align=",6)) {
|
|
if (sec_align == NULL)
|
|
error(ERR_NONFATAL, "cannot specify an alignment to"
|
|
" the `.text' section");
|
|
else if (p[6+strspn(p+6,"0123456789")])
|
|
error(ERR_NONFATAL, "argument to `align' is not numeric");
|
|
else {
|
|
unsigned int align = atoi(p+6);
|
|
if (!align || ((align-1) & align))
|
|
error(ERR_NONFATAL, "argument to `align' is not a"
|
|
" power of two");
|
|
else
|
|
*sec_align = align;
|
|
}
|
|
}
|
|
}
|
|
|
|
return sec_index;
|
|
}
|
|
|
|
static long bin_segbase (long segment)
|
|
{
|
|
return segment;
|
|
}
|
|
|
|
static int bin_directive (char *directive, char *value, int pass)
|
|
{
|
|
int rn_error;
|
|
|
|
(void) pass; /* Don't warn that this parameter is unused */
|
|
|
|
if (!strcmp(directive, "org")) {
|
|
start_point = readnum (value, &rn_error);
|
|
if (rn_error)
|
|
error (ERR_NONFATAL, "argument to ORG should be numeric");
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
static void bin_filename (char *inname, char *outname, efunc error)
|
|
{
|
|
standard_extension (inname, outname, "", error);
|
|
}
|
|
|
|
static char *bin_stdmac[] = {
|
|
"%define __SECT__ [section .text]",
|
|
"%imacro org 1+.nolist",
|
|
"[org %1]",
|
|
"%endmacro",
|
|
"%macro __NASM_CDecl__ 1",
|
|
"%endmacro",
|
|
NULL
|
|
};
|
|
|
|
static int bin_set_info(enum geninfo type, char **val)
|
|
{
|
|
return 0;
|
|
}
|
|
struct ofmt of_bin = {
|
|
"flat-form binary files (e.g. DOS .COM, .SYS)",
|
|
"bin",
|
|
NULL,
|
|
null_debug_arr,
|
|
&null_debug_form,
|
|
bin_stdmac,
|
|
bin_init,
|
|
bin_set_info,
|
|
bin_out,
|
|
bin_deflabel,
|
|
bin_secname,
|
|
bin_segbase,
|
|
bin_directive,
|
|
bin_filename,
|
|
bin_cleanup
|
|
};
|
|
|
|
#endif /* OF_BIN */
|