mirror of
https://github.com/netwide-assembler/nasm.git
synced 2024-11-27 08:10:07 +08:00
9084beb1bb
The backend format names were rather redundant and not always helpful. Do some cleanup. Signed-off-by: H. Peter Anvin <hpa@zytor.com>
1668 lines
54 KiB
C
1668 lines
54 KiB
C
/* ----------------------------------------------------------------------- *
|
|
*
|
|
* 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.
|
|
*
|
|
* ----------------------------------------------------------------------- */
|
|
|
|
/*
|
|
* outbin.c output routines for the Netwide Assembler to produce
|
|
* flat-form binary files
|
|
*/
|
|
|
|
/* This is the extended version of NASM's original binary output
|
|
* format. It is backward compatible with the original BIN format,
|
|
* and contains support for multiple sections and advanced section
|
|
* ordering.
|
|
*
|
|
* Feature summary:
|
|
*
|
|
* - Users can create an arbitrary number of sections; they are not
|
|
* limited to just ".text", ".data", and ".bss".
|
|
*
|
|
* - Sections can be either progbits or nobits type.
|
|
*
|
|
* - You can specify that they be aligned at a certian boundary
|
|
* following the previous section ("align="), or positioned at an
|
|
* arbitrary byte-granular location ("start=").
|
|
*
|
|
* - You can specify a "virtual" start address for a section, which
|
|
* will be used for the calculation for all address references
|
|
* with respect to that section ("vstart=").
|
|
*
|
|
* - The ORG directive, as well as the section/segment directive
|
|
* arguments ("align=", "start=", "vstart="), can take a critical
|
|
* expression as their value. For example: "align=(1 << 12)".
|
|
*
|
|
* - You can generate map files using the 'map' directive.
|
|
*
|
|
*/
|
|
|
|
/* Uncomment the following define if you want sections to adapt
|
|
* their progbits/nobits state depending on what type of
|
|
* instructions are issued, rather than defaulting to progbits.
|
|
* Note that this behavior violates the specification.
|
|
|
|
#define ABIN_SMART_ADAPT
|
|
|
|
*/
|
|
|
|
#include "compiler.h"
|
|
|
|
#include "nctype.h"
|
|
|
|
#include "nasm.h"
|
|
#include "nasmlib.h"
|
|
#include "error.h"
|
|
#include "saa.h"
|
|
#include "stdscan.h"
|
|
#include "labels.h"
|
|
#include "eval.h"
|
|
#include "outform.h"
|
|
#include "outlib.h"
|
|
|
|
#ifdef OF_BIN
|
|
|
|
static FILE *rf = NULL;
|
|
static void (*do_output)(void);
|
|
|
|
/* Section flags keep track of which attributes the user has defined. */
|
|
#define START_DEFINED 0x001
|
|
#define ALIGN_DEFINED 0x002
|
|
#define FOLLOWS_DEFINED 0x004
|
|
#define VSTART_DEFINED 0x008
|
|
#define VALIGN_DEFINED 0x010
|
|
#define VFOLLOWS_DEFINED 0x020
|
|
#define TYPE_DEFINED 0x040
|
|
#define TYPE_PROGBITS 0x080
|
|
#define TYPE_NOBITS 0x100
|
|
|
|
/* This struct is used to keep track of symbols for map-file generation. */
|
|
static struct bin_label {
|
|
char *name;
|
|
struct bin_label *next;
|
|
} *no_seg_labels, **nsl_tail;
|
|
|
|
static struct Section {
|
|
char *name;
|
|
struct SAA *contents;
|
|
int64_t length; /* section length in bytes */
|
|
|
|
/* Section attributes */
|
|
int flags; /* see flag definitions above */
|
|
uint64_t align; /* section alignment */
|
|
uint64_t valign; /* notional section alignment */
|
|
uint64_t start; /* section start address */
|
|
uint64_t vstart; /* section virtual start address */
|
|
char *follows; /* the section that this one will follow */
|
|
char *vfollows; /* the section that this one will notionally follow */
|
|
int32_t start_index; /* NASM section id for non-relocated version */
|
|
int32_t vstart_index; /* the NASM section id */
|
|
|
|
struct bin_label *labels; /* linked-list of label handles for map output. */
|
|
struct bin_label **labels_end; /* Holds address of end of labels list. */
|
|
struct Section *prev; /* Points to previous section (implicit follows). */
|
|
struct Section *next; /* This links sections with a defined start address. */
|
|
|
|
/* The extended bin format allows for sections to have a "virtual"
|
|
* start address. This is accomplished by creating two sections:
|
|
* one beginning at the Load Memory Address and the other beginning
|
|
* at the Virtual Memory Address. The LMA section is only used to
|
|
* define the section.<section_name>.start label, but there isn't
|
|
* any other good way for us to handle that label.
|
|
*/
|
|
|
|
} *sections, *last_section;
|
|
|
|
static struct Reloc {
|
|
struct Reloc *next;
|
|
int32_t posn;
|
|
int32_t bytes;
|
|
int32_t secref;
|
|
int32_t secrel;
|
|
struct Section *target;
|
|
} *relocs, **reloctail;
|
|
|
|
static uint64_t origin;
|
|
static int origin_defined;
|
|
|
|
/* Stuff we need for map-file generation. */
|
|
#define MAP_ORIGIN 1
|
|
#define MAP_SUMMARY 2
|
|
#define MAP_SECTIONS 4
|
|
#define MAP_SYMBOLS 8
|
|
static int map_control = 0;
|
|
|
|
extern macros_t bin_stdmac[];
|
|
|
|
static void add_reloc(struct Section *s, int32_t bytes, int32_t secref,
|
|
int32_t 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 struct Section *find_section_by_name(const char *name)
|
|
{
|
|
struct Section *s;
|
|
|
|
list_for_each(s, sections)
|
|
if (!strcmp(s->name, name))
|
|
break;
|
|
return s;
|
|
}
|
|
|
|
static struct Section *find_section_by_index(int32_t index)
|
|
{
|
|
struct Section *s;
|
|
|
|
list_for_each(s, sections)
|
|
if ((index == s->vstart_index) || (index == s->start_index))
|
|
break;
|
|
return s;
|
|
}
|
|
|
|
static struct Section *create_section(char *name)
|
|
{
|
|
struct Section *s = nasm_zalloc(sizeof(*s));
|
|
|
|
s->prev = last_section;
|
|
s->name = nasm_strdup(name);
|
|
s->labels_end = &(s->labels);
|
|
s->contents = saa_init(1L);
|
|
|
|
/* Register our sections with NASM. */
|
|
s->vstart_index = seg_alloc();
|
|
s->start_index = seg_alloc();
|
|
|
|
/* FIXME: Append to a tail, we need some helper */
|
|
last_section->next = s;
|
|
last_section = s;
|
|
|
|
return last_section;
|
|
}
|
|
|
|
static void bin_cleanup(void)
|
|
{
|
|
struct Section *g, **gp;
|
|
struct Section *gs = NULL, **gsp;
|
|
struct Section *s, **sp;
|
|
struct Section *nobits = NULL, **nt;
|
|
struct Section *last_progbits;
|
|
struct bin_label *l;
|
|
struct Reloc *r;
|
|
uint64_t pend;
|
|
int h;
|
|
|
|
if (debug_level(1)) {
|
|
nasm_debug("bin_cleanup: Sections were initially referenced in this order:\n");
|
|
for (h = 0, s = sections; s; h++, s = s->next)
|
|
nasm_debug("%i. %s\n", h, s->name);
|
|
}
|
|
|
|
/* Assembly has completed, so now we need to generate the output file.
|
|
* Step 1: Separate progbits and nobits sections into separate lists.
|
|
* Step 2: Sort the progbits sections into their output order.
|
|
* Step 3: Compute start addresses for all progbits sections.
|
|
* Step 4: Compute vstart addresses for all sections.
|
|
* Step 5: Apply relocations.
|
|
* Step 6: Write the sections' data to the output file.
|
|
* Step 7: Generate the map file.
|
|
* Step 8: Release all allocated memory.
|
|
*/
|
|
|
|
/* To do: Smart section-type adaptation could leave some empty sections
|
|
* without a defined type (progbits/nobits). Won't fix now since this
|
|
* feature will be disabled. */
|
|
|
|
/* Step 1: Split progbits and nobits sections into separate lists. */
|
|
|
|
nt = &nobits;
|
|
/* Move nobits sections into a separate list. Also pre-process nobits
|
|
* sections' attributes. */
|
|
for (sp = §ions->next, s = sections->next; s; s = *sp) { /* Skip progbits sections. */
|
|
if (s->flags & TYPE_PROGBITS) {
|
|
sp = &s->next;
|
|
continue;
|
|
}
|
|
/* Do some special pre-processing on nobits sections' attributes. */
|
|
if (s->flags & (START_DEFINED | ALIGN_DEFINED | FOLLOWS_DEFINED)) { /* Check for a mixture of real and virtual section attributes. */
|
|
if (s->flags & (VSTART_DEFINED | VALIGN_DEFINED |
|
|
VFOLLOWS_DEFINED))
|
|
nasm_fatal("cannot mix real and virtual attributes"
|
|
" in nobits section (%s)", s->name);
|
|
/* Real and virtual attributes mean the same thing for nobits sections. */
|
|
if (s->flags & START_DEFINED) {
|
|
s->vstart = s->start;
|
|
s->flags |= VSTART_DEFINED;
|
|
}
|
|
if (s->flags & ALIGN_DEFINED) {
|
|
s->valign = s->align;
|
|
s->flags |= VALIGN_DEFINED;
|
|
}
|
|
if (s->flags & FOLLOWS_DEFINED) {
|
|
s->vfollows = s->follows;
|
|
s->flags |= VFOLLOWS_DEFINED;
|
|
s->flags &= ~FOLLOWS_DEFINED;
|
|
}
|
|
}
|
|
/* Every section must have a start address. */
|
|
if (s->flags & VSTART_DEFINED) {
|
|
s->start = s->vstart;
|
|
s->flags |= START_DEFINED;
|
|
}
|
|
/* Move the section into the nobits list. */
|
|
*sp = s->next;
|
|
s->next = NULL;
|
|
*nt = s;
|
|
nt = &s->next;
|
|
}
|
|
|
|
/* Step 2: Sort the progbits sections into their output order. */
|
|
|
|
/* In Step 2 we move around sections in groups. A group
|
|
* begins with a section (group leader) that has a user-
|
|
* defined start address or follows section. The remainder
|
|
* of the group is made up of the sections that implicitly
|
|
* follow the group leader (i.e., they were defined after
|
|
* the group leader and were not given an explicit start
|
|
* address or follows section by the user). */
|
|
|
|
/* For anyone attempting to read this code:
|
|
* g (group) points to a group of sections, the first one of which has
|
|
* a user-defined start address or follows section.
|
|
* gp (g previous) holds the location of the pointer to g.
|
|
* gs (g scan) is a temp variable that we use to scan to the end of the group.
|
|
* gsp (gs previous) holds the location of the pointer to gs.
|
|
* nt (nobits tail) points to the nobits section-list tail.
|
|
*/
|
|
|
|
/* Link all 'follows' groups to their proper position. To do
|
|
* this we need to know three things: the start of the group
|
|
* to relocate (g), the section it is following (s), and the
|
|
* end of the group we're relocating (gs). */
|
|
for (gp = §ions, g = sections; g; g = gs) { /* Find the next follows group that is out of place (g). */
|
|
if (!(g->flags & FOLLOWS_DEFINED)) {
|
|
while (g->next) {
|
|
if ((g->next->flags & FOLLOWS_DEFINED) &&
|
|
strcmp(g->name, g->next->follows))
|
|
break;
|
|
g = g->next;
|
|
}
|
|
if (!g->next)
|
|
break;
|
|
gp = &g->next;
|
|
g = g->next;
|
|
}
|
|
/* Find the section that this group follows (s). */
|
|
for (sp = §ions, s = sections;
|
|
s && strcmp(s->name, g->follows);
|
|
sp = &s->next, s = s->next) ;
|
|
if (!s)
|
|
nasm_fatal("section %s follows an invalid or"
|
|
" unknown section (%s)", g->name, g->follows);
|
|
if (s->next && (s->next->flags & FOLLOWS_DEFINED) &&
|
|
!strcmp(s->name, s->next->follows))
|
|
nasm_fatal("sections %s and %s can't both follow"
|
|
" section %s", g->name, s->next->name, s->name);
|
|
/* Find the end of the current follows group (gs). */
|
|
for (gsp = &g->next, gs = g->next;
|
|
gs && (gs != s) && !(gs->flags & START_DEFINED);
|
|
gsp = &gs->next, gs = gs->next) {
|
|
if (gs->next && (gs->next->flags & FOLLOWS_DEFINED) &&
|
|
strcmp(gs->name, gs->next->follows)) {
|
|
gsp = &gs->next;
|
|
gs = gs->next;
|
|
break;
|
|
}
|
|
}
|
|
/* Re-link the group after its follows section. */
|
|
*gsp = s->next;
|
|
s->next = g;
|
|
*gp = gs;
|
|
}
|
|
|
|
/* Link all 'start' groups to their proper position. Once
|
|
* again we need to know g, s, and gs (see above). The main
|
|
* difference is we already know g since we sort by moving
|
|
* groups from the 'unsorted' list into a 'sorted' list (g
|
|
* will always be the first section in the unsorted list). */
|
|
for (g = sections, sections = NULL; g; g = gs) { /* Find the section that we will insert this group before (s). */
|
|
for (sp = §ions, s = sections; s; sp = &s->next, s = s->next)
|
|
if ((s->flags & START_DEFINED) && (g->start < s->start))
|
|
break;
|
|
/* Find the end of the group (gs). */
|
|
for (gs = g->next, gsp = &g->next;
|
|
gs && !(gs->flags & START_DEFINED);
|
|
gsp = &gs->next, gs = gs->next) ;
|
|
/* Re-link the group before the target section. */
|
|
*sp = g;
|
|
*gsp = s;
|
|
}
|
|
|
|
/* Step 3: Compute start addresses for all progbits sections. */
|
|
|
|
/* Make sure we have an origin and a start address for the first section. */
|
|
if (origin_defined) {
|
|
if (sections->flags & START_DEFINED) {
|
|
/* Make sure this section doesn't begin before the origin. */
|
|
if (sections->start < origin)
|
|
nasm_fatal("section %s begins"
|
|
" before program origin", sections->name);
|
|
} else if (sections->flags & ALIGN_DEFINED) {
|
|
sections->start = ALIGN(origin, sections->align);
|
|
} else {
|
|
sections->start = origin;
|
|
}
|
|
} else {
|
|
if (!(sections->flags & START_DEFINED))
|
|
sections->start = 0;
|
|
origin = sections->start;
|
|
}
|
|
sections->flags |= START_DEFINED;
|
|
|
|
/* Make sure each section has an explicit start address. If it
|
|
* doesn't, then compute one based its alignment and the end of
|
|
* the previous section. */
|
|
for (pend = sections->start, g = s = sections; g; g = g->next) { /* Find the next section that could cause an overlap situation
|
|
* (has a defined start address, and is not zero length). */
|
|
if (g == s)
|
|
for (s = g->next;
|
|
s && ((s->length == 0) || !(s->flags & START_DEFINED));
|
|
s = s->next) ;
|
|
/* Compute the start address of this section, if necessary. */
|
|
if (!(g->flags & START_DEFINED)) { /* Default to an alignment of 4 if unspecified. */
|
|
if (!(g->flags & ALIGN_DEFINED)) {
|
|
g->align = 4;
|
|
g->flags |= ALIGN_DEFINED;
|
|
}
|
|
/* Set the section start address. */
|
|
g->start = ALIGN(pend, g->align);
|
|
g->flags |= START_DEFINED;
|
|
}
|
|
/* Ugly special case for progbits sections' virtual attributes:
|
|
* If there is a defined valign, but no vstart and no vfollows, then
|
|
* we valign after the previous progbits section. This case doesn't
|
|
* really make much sense for progbits sections with a defined start
|
|
* address, but it is possible and we must do *something*.
|
|
* Not-so-ugly special case:
|
|
* If a progbits section has no virtual attributes, we set the
|
|
* vstart equal to the start address. */
|
|
if (!(g->flags & (VSTART_DEFINED | VFOLLOWS_DEFINED))) {
|
|
if (g->flags & VALIGN_DEFINED)
|
|
g->vstart = ALIGN(pend, g->valign);
|
|
else
|
|
g->vstart = g->start;
|
|
g->flags |= VSTART_DEFINED;
|
|
}
|
|
/* Ignore zero-length sections. */
|
|
if (g->start < pend)
|
|
continue;
|
|
/* Compute the span of this section. */
|
|
pend = g->start + g->length;
|
|
/* Check for section overlap. */
|
|
if (s) {
|
|
if (s->start < origin)
|
|
nasm_fatal("section %s beings before program origin",
|
|
s->name);
|
|
if (g->start > s->start)
|
|
nasm_fatal("sections %s ~ %s and %s overlap!",
|
|
gs->name, g->name, s->name);
|
|
if (pend > s->start)
|
|
nasm_fatal("sections %s and %s overlap!",
|
|
g->name, s->name);
|
|
}
|
|
/* Remember this section as the latest >0 length section. */
|
|
gs = g;
|
|
}
|
|
|
|
/* Step 4: Compute vstart addresses for all sections. */
|
|
|
|
/* Attach the nobits sections to the end of the progbits sections. */
|
|
for (s = sections; s->next; s = s->next) ;
|
|
s->next = nobits;
|
|
last_progbits = s;
|
|
/*
|
|
* Scan for sections that don't have a vstart address. If we find
|
|
* one we'll attempt to compute its vstart. If we can't compute
|
|
* the vstart, we leave it alone and come back to it in a
|
|
* subsequent scan. We continue scanning and re-scanning until
|
|
* we've gone one full cycle without computing any vstarts.
|
|
*/
|
|
do { /* Do one full scan of the sections list. */
|
|
for (h = 0, g = sections; g; g = g->next) {
|
|
if (g->flags & VSTART_DEFINED)
|
|
continue;
|
|
/* Find the section that this one virtually follows. */
|
|
if (g->flags & VFOLLOWS_DEFINED) {
|
|
for (s = sections; s && strcmp(g->vfollows, s->name);
|
|
s = s->next) ;
|
|
if (!s)
|
|
nasm_fatal("section %s vfollows unknown section (%s)",
|
|
g->name, g->vfollows);
|
|
} else if (g->prev != NULL)
|
|
for (s = sections; s && (s != g->prev); s = s->next) ;
|
|
/* The .bss section is the only one with prev = NULL.
|
|
In this case we implicitly follow the last progbits
|
|
section. */
|
|
else
|
|
s = last_progbits;
|
|
|
|
/* If the section we're following has a vstart, we can proceed. */
|
|
if (s->flags & VSTART_DEFINED) { /* Default to virtual alignment of four. */
|
|
if (!(g->flags & VALIGN_DEFINED)) {
|
|
g->valign = 4;
|
|
g->flags |= VALIGN_DEFINED;
|
|
}
|
|
/* Compute the vstart address. */
|
|
g->vstart = ALIGN(s->vstart + s->length, g->valign);
|
|
g->flags |= VSTART_DEFINED;
|
|
h++;
|
|
/* Start and vstart mean the same thing for nobits sections. */
|
|
if (g->flags & TYPE_NOBITS)
|
|
g->start = g->vstart;
|
|
}
|
|
}
|
|
} while (h);
|
|
|
|
/* Now check for any circular vfollows references, which will manifest
|
|
* themselves as sections without a defined vstart. */
|
|
for (h = 0, s = sections; s; s = s->next) {
|
|
if (!(s->flags & VSTART_DEFINED)) { /* Non-fatal errors after assembly has completed are generally a
|
|
* no-no, but we'll throw a fatal one eventually so it's ok. */
|
|
nasm_nonfatal("cannot compute vstart for section %s", s->name);
|
|
h++;
|
|
}
|
|
}
|
|
if (h)
|
|
nasm_fatal("circular vfollows path detected");
|
|
|
|
if (debug_level(1)) {
|
|
nasm_debug("bin_cleanup: Confirm final section order for output file:\n");
|
|
for (h = 0, s = sections; s && (s->flags & TYPE_PROGBITS);
|
|
h++, s = s->next)
|
|
nasm_debug("%i. %s\n", h, s->name);
|
|
}
|
|
|
|
/* Step 5: Apply relocations. */
|
|
|
|
/* Prepare the sections for relocating. */
|
|
list_for_each(s, sections)
|
|
saa_rewind(s->contents);
|
|
/* Apply relocations. */
|
|
list_for_each(r, relocs) {
|
|
uint8_t *p, mydata[8];
|
|
int64_t l;
|
|
int b;
|
|
|
|
nasm_assert(r->bytes <= 8);
|
|
|
|
memset(mydata, 0, sizeof(mydata));
|
|
|
|
saa_fread(r->target->contents, r->posn, mydata, r->bytes);
|
|
p = mydata;
|
|
l = 0;
|
|
for (b = r->bytes - 1; b >= 0; b--)
|
|
l = (l << 8) + mydata[b];
|
|
|
|
s = find_section_by_index(r->secref);
|
|
if (s) {
|
|
if (r->secref == s->start_index)
|
|
l += s->start;
|
|
else
|
|
l += s->vstart;
|
|
}
|
|
s = find_section_by_index(r->secrel);
|
|
if (s) {
|
|
if (r->secrel == s->start_index)
|
|
l -= s->start;
|
|
else
|
|
l -= s->vstart;
|
|
}
|
|
|
|
WRITEADDR(p, l, r->bytes);
|
|
saa_fwrite(r->target->contents, r->posn, mydata, r->bytes);
|
|
}
|
|
|
|
/* Step 6: Write the section data to the output file. */
|
|
do_output();
|
|
|
|
/* Step 7: Generate the map file. */
|
|
|
|
if (map_control) {
|
|
static const char not_defined[] = "not defined";
|
|
|
|
/* Display input and output file names. */
|
|
fprintf(rf, "\n- NASM Map file ");
|
|
for (h = 63; h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\nSource file: %s\nOutput file: %s\n\n",
|
|
inname, outname);
|
|
|
|
if (map_control & MAP_ORIGIN) { /* Display program origin. */
|
|
fprintf(rf, "-- Program origin ");
|
|
for (h = 61; h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\n%08"PRIX64"\n\n", origin);
|
|
}
|
|
/* Display sections summary. */
|
|
if (map_control & MAP_SUMMARY) {
|
|
fprintf(rf, "-- Sections (summary) ");
|
|
for (h = 57; h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\nVstart Start Stop "
|
|
"Length Class Name\n");
|
|
list_for_each(s, sections) {
|
|
fprintf(rf, "%16"PRIX64" %16"PRIX64" %16"PRIX64" %08"PRIX64" ",
|
|
s->vstart, s->start, s->start + s->length,
|
|
s->length);
|
|
if (s->flags & TYPE_PROGBITS)
|
|
fprintf(rf, "progbits ");
|
|
else
|
|
fprintf(rf, "nobits ");
|
|
fprintf(rf, "%s\n", s->name);
|
|
}
|
|
fprintf(rf, "\n");
|
|
}
|
|
/* Display detailed section information. */
|
|
if (map_control & MAP_SECTIONS) {
|
|
fprintf(rf, "-- Sections (detailed) ");
|
|
for (h = 56; h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\n");
|
|
list_for_each(s, sections) {
|
|
fprintf(rf, "---- Section %s ", s->name);
|
|
if (strlen(s->name) < 65)
|
|
for (h = 65 - strlen(s->name); h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\nclass: ");
|
|
if (s->flags & TYPE_PROGBITS)
|
|
fprintf(rf, "progbits");
|
|
else
|
|
fprintf(rf, "nobits");
|
|
fprintf(rf, "\nlength: %16"PRIX64"\nstart: %16"PRIX64""
|
|
"\nalign: ", s->length, s->start);
|
|
if (s->flags & ALIGN_DEFINED)
|
|
fprintf(rf, "%16"PRIX64"", s->align);
|
|
else
|
|
fputs(not_defined, rf);
|
|
fprintf(rf, "\nfollows: ");
|
|
if (s->flags & FOLLOWS_DEFINED)
|
|
fprintf(rf, "%s", s->follows);
|
|
else
|
|
fputs(not_defined, rf);
|
|
fprintf(rf, "\nvstart: %16"PRIX64"\nvalign: ", s->vstart);
|
|
if (s->flags & VALIGN_DEFINED)
|
|
fprintf(rf, "%16"PRIX64"", s->valign);
|
|
else
|
|
fputs(not_defined, rf);
|
|
fprintf(rf, "\nvfollows: ");
|
|
if (s->flags & VFOLLOWS_DEFINED)
|
|
fprintf(rf, "%s", s->vfollows);
|
|
else
|
|
fputs(not_defined, rf);
|
|
fprintf(rf, "\n\n");
|
|
}
|
|
}
|
|
/* Display symbols information. */
|
|
if (map_control & MAP_SYMBOLS) {
|
|
int32_t segment;
|
|
int64_t offset;
|
|
bool found_label;
|
|
|
|
fprintf(rf, "-- Symbols ");
|
|
for (h = 68; h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\n");
|
|
if (no_seg_labels) {
|
|
fprintf(rf, "---- No Section ");
|
|
for (h = 63; h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\nValue Name\n");
|
|
list_for_each(l, no_seg_labels) {
|
|
found_label = lookup_label(l->name, &segment, &offset);
|
|
nasm_assert(found_label);
|
|
fprintf(rf, "%08"PRIX64" %s\n", offset, l->name);
|
|
}
|
|
fprintf(rf, "\n\n");
|
|
}
|
|
list_for_each(s, sections) {
|
|
if (s->labels) {
|
|
fprintf(rf, "---- Section %s ", s->name);
|
|
for (h = 65 - strlen(s->name); h; h--)
|
|
fputc('-', rf);
|
|
fprintf(rf, "\n\nReal Virtual Name\n");
|
|
list_for_each(l, s->labels) {
|
|
found_label = lookup_label(l->name, &segment, &offset);
|
|
nasm_assert(found_label);
|
|
fprintf(rf, "%16"PRIX64" %16"PRIX64" %s\n",
|
|
s->start + offset, s->vstart + offset,
|
|
l->name);
|
|
}
|
|
fprintf(rf, "\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Close the report file. */
|
|
if (map_control && (rf != stdout) && (rf != stderr))
|
|
fclose(rf);
|
|
|
|
/* Step 8: Release all allocated memory. */
|
|
|
|
/* Free sections, label pointer structs, etc.. */
|
|
while (sections) {
|
|
s = sections;
|
|
sections = s->next;
|
|
saa_free(s->contents);
|
|
nasm_free(s->name);
|
|
if (s->flags & FOLLOWS_DEFINED)
|
|
nasm_free(s->follows);
|
|
if (s->flags & VFOLLOWS_DEFINED)
|
|
nasm_free(s->vfollows);
|
|
while (s->labels) {
|
|
l = s->labels;
|
|
s->labels = l->next;
|
|
nasm_free(l);
|
|
}
|
|
nasm_free(s);
|
|
}
|
|
|
|
/* Free no-section labels. */
|
|
while (no_seg_labels) {
|
|
l = no_seg_labels;
|
|
no_seg_labels = l->next;
|
|
nasm_free(l);
|
|
}
|
|
|
|
/* Free relocation structures. */
|
|
while (relocs) {
|
|
r = relocs->next;
|
|
nasm_free(relocs);
|
|
relocs = r;
|
|
}
|
|
}
|
|
|
|
static void bin_out(int32_t segto, const void *data,
|
|
enum out_type type, uint64_t size,
|
|
int32_t segment, int32_t wrt)
|
|
{
|
|
uint8_t *p, mydata[8];
|
|
struct Section *s;
|
|
|
|
if (wrt != NO_SEG) {
|
|
wrt = NO_SEG; /* continue to do _something_ */
|
|
nasm_nonfatal("WRT not supported by binary output format");
|
|
}
|
|
|
|
/* Find the segment we are targeting. */
|
|
s = find_section_by_index(segto);
|
|
if (!s)
|
|
nasm_panic("code directed to nonexistent segment?");
|
|
|
|
/* "Smart" section-type adaptation code. */
|
|
if (!(s->flags & TYPE_DEFINED)) {
|
|
if (type == OUT_RESERVE)
|
|
s->flags |= TYPE_DEFINED | TYPE_NOBITS;
|
|
else
|
|
s->flags |= TYPE_DEFINED | TYPE_PROGBITS;
|
|
}
|
|
|
|
if ((s->flags & TYPE_NOBITS) && (type != OUT_RESERVE))
|
|
nasm_warn(WARN_OTHER, "attempt to initialize memory in a"
|
|
" nobits section: ignored");
|
|
|
|
switch (type) {
|
|
case OUT_ADDRESS:
|
|
{
|
|
int asize = abs((int)size);
|
|
|
|
if (segment != NO_SEG && !find_section_by_index(segment)) {
|
|
if (segment % 2)
|
|
nasm_nonfatal("binary output format does not support"
|
|
" segment base references");
|
|
else
|
|
nasm_nonfatal("binary output format does not support"
|
|
" external references");
|
|
segment = NO_SEG;
|
|
}
|
|
if (s->flags & TYPE_PROGBITS) {
|
|
if (segment != NO_SEG)
|
|
add_reloc(s, asize, segment, -1L);
|
|
p = mydata;
|
|
WRITEADDR(p, *(int64_t *)data, asize);
|
|
saa_wbytes(s->contents, mydata, asize);
|
|
}
|
|
|
|
/*
|
|
* Reassign size with sign dropped, we will need it
|
|
* for section length calculation.
|
|
*/
|
|
size = asize;
|
|
break;
|
|
}
|
|
|
|
case OUT_RAWDATA:
|
|
if (s->flags & TYPE_PROGBITS)
|
|
saa_wbytes(s->contents, data, size);
|
|
break;
|
|
|
|
case OUT_RESERVE:
|
|
if (s->flags & TYPE_PROGBITS) {
|
|
nasm_warn(WARN_ZEROING, "uninitialized space declared in"
|
|
" %s section: zeroing", s->name);
|
|
saa_wbytes(s->contents, NULL, size);
|
|
}
|
|
break;
|
|
|
|
case OUT_REL1ADR:
|
|
case OUT_REL2ADR:
|
|
case OUT_REL4ADR:
|
|
case OUT_REL8ADR:
|
|
{
|
|
int64_t addr = *(int64_t *)data - size;
|
|
size = realsize(type, size);
|
|
if (segment != NO_SEG && !find_section_by_index(segment)) {
|
|
if (segment % 2)
|
|
nasm_nonfatal("binary output format does not support"
|
|
" segment base references");
|
|
else
|
|
nasm_nonfatal("binary output format does not support"
|
|
" external references");
|
|
segment = NO_SEG;
|
|
}
|
|
if (s->flags & TYPE_PROGBITS) {
|
|
add_reloc(s, size, segment, segto);
|
|
p = mydata;
|
|
WRITEADDR(p, addr - s->length, size);
|
|
saa_wbytes(s->contents, mydata, size);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
nasm_nonfatal("unsupported relocation type %d\n", type);
|
|
break;
|
|
}
|
|
|
|
s->length += size;
|
|
}
|
|
|
|
static void bin_deflabel(char *name, int32_t segment, int64_t 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)
|
|
nasm_nonfatal("binary format does not support any"
|
|
" special symbol types");
|
|
else if (name[0] == '.' && name[1] == '.' && name[2] != '@')
|
|
nasm_nonfatal("unrecognised special symbol `%s'", name);
|
|
else if (is_global == 2)
|
|
nasm_nonfatal("binary output format does not support common"
|
|
" variables");
|
|
else {
|
|
struct Section *s;
|
|
struct bin_label ***ltp;
|
|
|
|
/* Remember label definition so we can look it up later when
|
|
* creating the map file. */
|
|
s = find_section_by_index(segment);
|
|
if (s)
|
|
ltp = &(s->labels_end);
|
|
else
|
|
ltp = &nsl_tail;
|
|
(**ltp) = nasm_malloc(sizeof(struct bin_label));
|
|
(**ltp)->name = name;
|
|
(**ltp)->next = NULL;
|
|
*ltp = &((**ltp)->next);
|
|
}
|
|
|
|
}
|
|
|
|
/* These constants and the following function are used
|
|
* by bin_secname() to parse attribute assignments. */
|
|
|
|
enum { ATTRIB_START, ATTRIB_ALIGN, ATTRIB_FOLLOWS,
|
|
ATTRIB_VSTART, ATTRIB_VALIGN, ATTRIB_VFOLLOWS,
|
|
ATTRIB_NOBITS, ATTRIB_PROGBITS
|
|
};
|
|
|
|
static int bin_read_attribute(char **line, int *attribute,
|
|
uint64_t *value)
|
|
{
|
|
expr *e;
|
|
int attrib_name_size;
|
|
struct tokenval tokval;
|
|
char *exp;
|
|
|
|
/* Skip whitespace. */
|
|
while (**line && nasm_isspace(**line))
|
|
(*line)++;
|
|
if (!**line)
|
|
return 0;
|
|
|
|
/* Figure out what attribute we're reading. */
|
|
if (!nasm_strnicmp(*line, "align=", 6)) {
|
|
*attribute = ATTRIB_ALIGN;
|
|
attrib_name_size = 6;
|
|
} else {
|
|
if (!nasm_strnicmp(*line, "start=", 6)) {
|
|
*attribute = ATTRIB_START;
|
|
attrib_name_size = 6;
|
|
} else if (!nasm_strnicmp(*line, "follows=", 8)) {
|
|
*attribute = ATTRIB_FOLLOWS;
|
|
*line += 8;
|
|
return 1;
|
|
} else if (!nasm_strnicmp(*line, "vstart=", 7)) {
|
|
*attribute = ATTRIB_VSTART;
|
|
attrib_name_size = 7;
|
|
} else if (!nasm_strnicmp(*line, "valign=", 7)) {
|
|
*attribute = ATTRIB_VALIGN;
|
|
attrib_name_size = 7;
|
|
} else if (!nasm_strnicmp(*line, "vfollows=", 9)) {
|
|
*attribute = ATTRIB_VFOLLOWS;
|
|
*line += 9;
|
|
return 1;
|
|
} else if (!nasm_strnicmp(*line, "nobits", 6) &&
|
|
(nasm_isspace((*line)[6]) || ((*line)[6] == '\0'))) {
|
|
*attribute = ATTRIB_NOBITS;
|
|
*line += 6;
|
|
return 1;
|
|
} else if (!nasm_strnicmp(*line, "progbits", 8) &&
|
|
(nasm_isspace((*line)[8]) || ((*line)[8] == '\0'))) {
|
|
*attribute = ATTRIB_PROGBITS;
|
|
*line += 8;
|
|
return 1;
|
|
} else
|
|
return 0;
|
|
}
|
|
|
|
/* Find the end of the expression. */
|
|
if ((*line)[attrib_name_size] != '(') {
|
|
/* Single term (no parenthesis). */
|
|
exp = *line += attrib_name_size;
|
|
while (**line && !nasm_isspace(**line))
|
|
(*line)++;
|
|
if (**line) {
|
|
**line = '\0';
|
|
(*line)++;
|
|
}
|
|
} else {
|
|
char c;
|
|
int pcount = 1;
|
|
|
|
/* Full expression (delimited by parenthesis) */
|
|
exp = *line += attrib_name_size + 1;
|
|
while (1) {
|
|
(*line) += strcspn(*line, "()'\"");
|
|
if (**line == '(') {
|
|
++(*line);
|
|
++pcount;
|
|
}
|
|
if (**line == ')') {
|
|
++(*line);
|
|
--pcount;
|
|
if (!pcount)
|
|
break;
|
|
}
|
|
if ((**line == '"') || (**line == '\'')) {
|
|
c = **line;
|
|
while (**line) {
|
|
++(*line);
|
|
if (**line == c)
|
|
break;
|
|
}
|
|
if (!**line) {
|
|
nasm_nonfatal("invalid syntax in `section' directive");
|
|
return -1;
|
|
}
|
|
++(*line);
|
|
}
|
|
if (!**line) {
|
|
nasm_nonfatal("expecting `)'");
|
|
return -1;
|
|
}
|
|
}
|
|
*(*line - 1) = '\0'; /* Terminate the expression. */
|
|
}
|
|
|
|
/* Check for no value given. */
|
|
if (!*exp) {
|
|
nasm_warn(WARN_OTHER, "No value given to attribute in"
|
|
" `section' directive");
|
|
return -1;
|
|
}
|
|
|
|
/* Read and evaluate the expression. */
|
|
stdscan_reset();
|
|
stdscan_set(exp);
|
|
tokval.t_type = TOKEN_INVALID;
|
|
e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
|
|
if (e) {
|
|
if (!is_really_simple(e)) {
|
|
nasm_nonfatal("section attribute value must be"
|
|
" a critical expression");
|
|
return -1;
|
|
}
|
|
} else {
|
|
nasm_nonfatal("Invalid attribute value"
|
|
" specified in `section' directive.");
|
|
return -1;
|
|
}
|
|
*value = (uint64_t)reloc_value(e);
|
|
return 1;
|
|
}
|
|
|
|
static void bin_sectalign(int32_t seg, unsigned int value)
|
|
{
|
|
struct Section *s = find_section_by_index(seg);
|
|
|
|
if (!s || !is_power2(value))
|
|
return;
|
|
|
|
if (value > s->align)
|
|
s->align = value;
|
|
|
|
if (!(s->flags & ALIGN_DEFINED))
|
|
s->flags |= ALIGN_DEFINED;
|
|
}
|
|
|
|
static void bin_assign_attributes(struct Section *sec, char *astring)
|
|
{
|
|
int attribute, check;
|
|
uint64_t value;
|
|
char *p;
|
|
|
|
while (1) { /* Get the next attribute. */
|
|
check = bin_read_attribute(&astring, &attribute, &value);
|
|
/* Skip bad attribute. */
|
|
if (check == -1)
|
|
continue;
|
|
/* Unknown section attribute, so skip it and warn the user. */
|
|
if (!check) {
|
|
if (!*astring)
|
|
break; /* End of line. */
|
|
else {
|
|
p = astring;
|
|
while (*astring && !nasm_isspace(*astring))
|
|
astring++;
|
|
if (*astring) {
|
|
*astring = '\0';
|
|
astring++;
|
|
}
|
|
nasm_warn(WARN_OTHER, "ignoring unknown section attribute: \"%s\"", p);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
switch (attribute) { /* Handle nobits attribute. */
|
|
case ATTRIB_NOBITS:
|
|
if ((sec->flags & TYPE_DEFINED)
|
|
&& (sec->flags & TYPE_PROGBITS))
|
|
nasm_nonfatal("attempt to change section type"
|
|
" from progbits to nobits");
|
|
else
|
|
sec->flags |= TYPE_DEFINED | TYPE_NOBITS;
|
|
continue;
|
|
|
|
/* Handle progbits attribute. */
|
|
case ATTRIB_PROGBITS:
|
|
if ((sec->flags & TYPE_DEFINED) && (sec->flags & TYPE_NOBITS))
|
|
nasm_nonfatal("attempt to change section type"
|
|
" from nobits to progbits");
|
|
else
|
|
sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
|
|
continue;
|
|
|
|
/* Handle align attribute. */
|
|
case ATTRIB_ALIGN:
|
|
if (!value || ((value - 1) & value)) {
|
|
nasm_nonfatal("argument to `align' is not a power of two");
|
|
} else {
|
|
/*
|
|
* Alignment is already satisfied if
|
|
* the previous align value is greater
|
|
*/
|
|
if ((sec->flags & ALIGN_DEFINED) && (value < sec->align))
|
|
value = sec->align;
|
|
|
|
/* Don't allow a conflicting align value. */
|
|
if ((sec->flags & START_DEFINED) && (sec->start & (value - 1))) {
|
|
nasm_nonfatal("`align' value conflicts with section start address");
|
|
} else {
|
|
sec->align = value;
|
|
sec->flags |= ALIGN_DEFINED;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
/* Handle valign attribute. */
|
|
case ATTRIB_VALIGN:
|
|
if (!value || ((value - 1) & value))
|
|
nasm_nonfatal("argument to `valign' is not a power of two");
|
|
else { /* Alignment is already satisfied if the previous
|
|
* align value is greater. */
|
|
if ((sec->flags & VALIGN_DEFINED) && (value < sec->valign))
|
|
value = sec->valign;
|
|
|
|
/* Don't allow a conflicting valign value. */
|
|
if ((sec->flags & VSTART_DEFINED)
|
|
&& (sec->vstart & (value - 1)))
|
|
nasm_nonfatal("`valign' value conflicts with `vstart' address");
|
|
else {
|
|
sec->valign = value;
|
|
sec->flags |= VALIGN_DEFINED;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
/* Handle start attribute. */
|
|
case ATTRIB_START:
|
|
if (sec->flags & FOLLOWS_DEFINED)
|
|
nasm_nonfatal("cannot combine `start' and `follows'"
|
|
" section attributes");
|
|
else if ((sec->flags & START_DEFINED) && (value != sec->start))
|
|
nasm_nonfatal("section start address redefined");
|
|
else {
|
|
sec->start = value;
|
|
sec->flags |= START_DEFINED;
|
|
if (sec->flags & ALIGN_DEFINED) {
|
|
if (sec->start & (sec->align - 1))
|
|
nasm_nonfatal("`start' address conflicts"
|
|
" with section alignment");
|
|
sec->flags ^= ALIGN_DEFINED;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
/* Handle vstart attribute. */
|
|
case ATTRIB_VSTART:
|
|
if (sec->flags & VFOLLOWS_DEFINED)
|
|
nasm_nonfatal("cannot combine `vstart' and `vfollows'"
|
|
" section attributes");
|
|
else if ((sec->flags & VSTART_DEFINED)
|
|
&& (value != sec->vstart))
|
|
nasm_nonfatal("section virtual start address"
|
|
" (vstart) redefined");
|
|
else {
|
|
sec->vstart = value;
|
|
sec->flags |= VSTART_DEFINED;
|
|
if (sec->flags & VALIGN_DEFINED) {
|
|
if (sec->vstart & (sec->valign - 1))
|
|
nasm_nonfatal("`vstart' address conflicts"
|
|
" with `valign' value");
|
|
sec->flags ^= VALIGN_DEFINED;
|
|
}
|
|
}
|
|
continue;
|
|
|
|
/* Handle follows attribute. */
|
|
case ATTRIB_FOLLOWS:
|
|
p = astring;
|
|
astring += strcspn(astring, " \t");
|
|
if (astring == p)
|
|
nasm_nonfatal("expecting section name for `follows'"
|
|
" attribute");
|
|
else {
|
|
*(astring++) = '\0';
|
|
if (sec->flags & START_DEFINED)
|
|
nasm_nonfatal("cannot combine `start' and `follows'"
|
|
" section attributes");
|
|
sec->follows = nasm_strdup(p);
|
|
sec->flags |= FOLLOWS_DEFINED;
|
|
}
|
|
continue;
|
|
|
|
/* Handle vfollows attribute. */
|
|
case ATTRIB_VFOLLOWS:
|
|
if (sec->flags & VSTART_DEFINED)
|
|
nasm_nonfatal("cannot combine `vstart' and `vfollows'"
|
|
" section attributes");
|
|
else {
|
|
p = astring;
|
|
astring += strcspn(astring, " \t");
|
|
if (astring == p)
|
|
nasm_nonfatal("expecting section name for `vfollows'"
|
|
" attribute");
|
|
else {
|
|
*(astring++) = '\0';
|
|
sec->vfollows = nasm_strdup(p);
|
|
sec->flags |= VFOLLOWS_DEFINED;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void bin_define_section_labels(void)
|
|
{
|
|
static int labels_defined = 0;
|
|
struct Section *sec;
|
|
char *label_name;
|
|
size_t base_len;
|
|
|
|
if (labels_defined)
|
|
return;
|
|
list_for_each(sec, sections) {
|
|
base_len = strlen(sec->name) + 8;
|
|
label_name = nasm_malloc(base_len + 8);
|
|
strcpy(label_name, "section.");
|
|
strcpy(label_name + 8, sec->name);
|
|
|
|
/* section.<name>.start */
|
|
strcpy(label_name + base_len, ".start");
|
|
define_label(label_name, sec->start_index, 0L, false);
|
|
|
|
/* section.<name>.vstart */
|
|
strcpy(label_name + base_len, ".vstart");
|
|
define_label(label_name, sec->vstart_index, 0L, false);
|
|
|
|
nasm_free(label_name);
|
|
}
|
|
labels_defined = 1;
|
|
}
|
|
|
|
static int32_t bin_secname(char *name, int *bits)
|
|
{
|
|
char *p;
|
|
struct Section *sec;
|
|
|
|
/* bin_secname is called with *name = NULL at the start of each
|
|
* pass. Use this opportunity to establish the default section
|
|
* (default is BITS-16 ".text" segment).
|
|
*/
|
|
if (!name) {
|
|
/* Reset ORG and section attributes at the start of each pass. */
|
|
origin_defined = 0;
|
|
list_for_each(sec, sections)
|
|
sec->flags &= ~(START_DEFINED | VSTART_DEFINED |
|
|
ALIGN_DEFINED | VALIGN_DEFINED);
|
|
|
|
/* Define section start and vstart labels. */
|
|
if (!pass_first())
|
|
bin_define_section_labels();
|
|
|
|
/* Establish the default (.text) section. */
|
|
*bits = 16;
|
|
sec = find_section_by_name(".text");
|
|
sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
|
|
return sec->vstart_index;
|
|
}
|
|
|
|
/* Attempt to find the requested section. If it does not
|
|
* exist, create it. */
|
|
p = name;
|
|
while (*p && !nasm_isspace(*p))
|
|
p++;
|
|
if (*p)
|
|
*p++ = '\0';
|
|
sec = find_section_by_name(name);
|
|
if (!sec) {
|
|
sec = create_section(name);
|
|
if (!strcmp(name, ".data"))
|
|
sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
|
|
else if (!strcmp(name, ".bss")) {
|
|
sec->flags |= TYPE_DEFINED | TYPE_NOBITS;
|
|
sec->prev = NULL;
|
|
}
|
|
}
|
|
|
|
/* Handle attribute assignments. */
|
|
if (!pass_first())
|
|
bin_assign_attributes(sec, p);
|
|
|
|
#ifndef ABIN_SMART_ADAPT
|
|
/* The following line disables smart adaptation of
|
|
* PROGBITS/NOBITS section types (it forces sections to
|
|
* default to PROGBITS). */
|
|
if (!pass_first() && !(sec->flags & TYPE_DEFINED))
|
|
sec->flags |= TYPE_DEFINED | TYPE_PROGBITS;
|
|
#endif
|
|
|
|
return sec->vstart_index;
|
|
}
|
|
|
|
static enum directive_result
|
|
bin_directive(enum directive directive, char *args)
|
|
{
|
|
switch (directive) {
|
|
case D_ORG:
|
|
{
|
|
struct tokenval tokval;
|
|
uint64_t value;
|
|
expr *e;
|
|
|
|
stdscan_reset();
|
|
stdscan_set(args);
|
|
tokval.t_type = TOKEN_INVALID;
|
|
e = evaluate(stdscan, NULL, &tokval, NULL, 1, NULL);
|
|
if (e) {
|
|
if (!is_really_simple(e))
|
|
nasm_nonfatal("org value must be a critical"
|
|
" expression");
|
|
else {
|
|
value = reloc_value(e);
|
|
/* Check for ORG redefinition. */
|
|
if (origin_defined && (value != origin))
|
|
nasm_nonfatal("program origin redefined");
|
|
else {
|
|
origin = value;
|
|
origin_defined = 1;
|
|
}
|
|
}
|
|
} else
|
|
nasm_nonfatal("No or invalid offset specified"
|
|
" in ORG directive.");
|
|
return DIRR_OK;
|
|
}
|
|
case D_MAP:
|
|
{
|
|
/* The 'map' directive allows the user to generate section
|
|
* and symbol information to stdout, stderr, or to a file. */
|
|
char *p;
|
|
|
|
if (!pass_first())
|
|
return DIRR_OK;
|
|
args += strspn(args, " \t");
|
|
while (*args) {
|
|
p = args;
|
|
args += strcspn(args, " \t");
|
|
if (*args != '\0')
|
|
*(args++) = '\0';
|
|
if (!nasm_stricmp(p, "all"))
|
|
map_control |=
|
|
MAP_ORIGIN | MAP_SUMMARY | MAP_SECTIONS | MAP_SYMBOLS;
|
|
else if (!nasm_stricmp(p, "brief"))
|
|
map_control |= MAP_ORIGIN | MAP_SUMMARY;
|
|
else if (!nasm_stricmp(p, "sections"))
|
|
map_control |= MAP_ORIGIN | MAP_SUMMARY | MAP_SECTIONS;
|
|
else if (!nasm_stricmp(p, "segments"))
|
|
map_control |= MAP_ORIGIN | MAP_SUMMARY | MAP_SECTIONS;
|
|
else if (!nasm_stricmp(p, "symbols"))
|
|
map_control |= MAP_SYMBOLS;
|
|
else if (!rf) {
|
|
if (!nasm_stricmp(p, "stdout"))
|
|
rf = stdout;
|
|
else if (!nasm_stricmp(p, "stderr"))
|
|
rf = stderr;
|
|
else { /* Must be a filename. */
|
|
rf = nasm_open_write(p, NF_TEXT);
|
|
if (!rf) {
|
|
nasm_warn(WARN_OTHER|ERR_PASS1, "unable to open map file `%s'", p);
|
|
map_control = 0;
|
|
return DIRR_OK;
|
|
}
|
|
}
|
|
} else
|
|
nasm_warn(WARN_OTHER|ERR_PASS1, "map file already specified");
|
|
}
|
|
if (map_control == 0)
|
|
map_control |= MAP_ORIGIN | MAP_SUMMARY;
|
|
if (!rf)
|
|
rf = stdout;
|
|
return DIRR_OK;
|
|
}
|
|
default:
|
|
return DIRR_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
const struct ofmt of_bin, of_ith, of_srec;
|
|
static void binfmt_init(void);
|
|
static void do_output_bin(void);
|
|
static void do_output_ith(void);
|
|
static void do_output_srec(void);
|
|
|
|
static void bin_init(void)
|
|
{
|
|
do_output = do_output_bin;
|
|
binfmt_init();
|
|
}
|
|
|
|
static void ith_init(void)
|
|
{
|
|
do_output = do_output_ith;
|
|
binfmt_init();
|
|
}
|
|
|
|
static void srec_init(void)
|
|
{
|
|
do_output = do_output_srec;
|
|
binfmt_init();
|
|
}
|
|
|
|
static void binfmt_init(void)
|
|
{
|
|
relocs = NULL;
|
|
reloctail = &relocs;
|
|
origin_defined = 0;
|
|
no_seg_labels = NULL;
|
|
nsl_tail = &no_seg_labels;
|
|
|
|
/* Create default section (.text). */
|
|
sections = last_section = nasm_zalloc(sizeof(struct Section));
|
|
last_section->name = nasm_strdup(".text");
|
|
last_section->contents = saa_init(1L);
|
|
last_section->flags = TYPE_DEFINED | TYPE_PROGBITS;
|
|
last_section->labels_end = &(last_section->labels);
|
|
last_section->start_index = seg_alloc();
|
|
last_section->vstart_index = seg_alloc();
|
|
}
|
|
|
|
/* Generate binary file output */
|
|
static void do_output_bin(void)
|
|
{
|
|
struct Section *s;
|
|
uint64_t addr = origin;
|
|
|
|
/* Write the progbits sections to the output file. */
|
|
list_for_each(s, sections) {
|
|
/* Skip non-progbits sections */
|
|
if (!(s->flags & TYPE_PROGBITS))
|
|
continue;
|
|
/* Skip zero-length sections */
|
|
if (s->length == 0)
|
|
continue;
|
|
|
|
/* Pad the space between sections. */
|
|
nasm_assert(addr <= s->start);
|
|
fwritezero(s->start - addr, ofile);
|
|
|
|
/* Write the section to the output file. */
|
|
saa_fpwrite(s->contents, ofile);
|
|
|
|
/* Keep track of the current file position */
|
|
addr = s->start + s->length;
|
|
}
|
|
}
|
|
|
|
/* Generate Intel hex file output */
|
|
static void write_ith_record(unsigned int len, uint16_t addr,
|
|
uint8_t type, void *data)
|
|
{
|
|
char buf[1+2+4+2+255*2+2+2];
|
|
char *p = buf;
|
|
uint8_t csum, *dptr = data;
|
|
unsigned int i;
|
|
|
|
nasm_assert(len <= 255);
|
|
|
|
csum = len + addr + (addr >> 8) + type;
|
|
for (i = 0; i < len; i++)
|
|
csum += dptr[i];
|
|
csum = -csum;
|
|
|
|
p += sprintf(p, ":%02X%04X%02X", len, addr, type);
|
|
for (i = 0; i < len; i++)
|
|
p += sprintf(p, "%02X", dptr[i]);
|
|
p += sprintf(p, "%02X\n", csum);
|
|
|
|
nasm_write(buf, p-buf, ofile);
|
|
}
|
|
|
|
static void do_output_ith(void)
|
|
{
|
|
uint8_t buf[32];
|
|
struct Section *s;
|
|
uint64_t addr, hiaddr, hilba;
|
|
uint64_t length;
|
|
unsigned int chunk;
|
|
|
|
/* Write the progbits sections to the output file. */
|
|
hilba = 0;
|
|
list_for_each(s, sections) {
|
|
/* Skip non-progbits sections */
|
|
if (!(s->flags & TYPE_PROGBITS))
|
|
continue;
|
|
/* Skip zero-length sections */
|
|
if (s->length == 0)
|
|
continue;
|
|
|
|
addr = s->start;
|
|
length = s->length;
|
|
saa_rewind(s->contents);
|
|
|
|
while (length) {
|
|
hiaddr = addr >> 16;
|
|
if (hiaddr != hilba) {
|
|
buf[0] = hiaddr >> 8;
|
|
buf[1] = hiaddr;
|
|
write_ith_record(2, 0, 4, buf);
|
|
hilba = hiaddr;
|
|
}
|
|
|
|
chunk = 32 - (addr & 31);
|
|
if (length < chunk)
|
|
chunk = length;
|
|
|
|
saa_rnbytes(s->contents, buf, chunk);
|
|
write_ith_record(chunk, (uint16_t)addr, 0, buf);
|
|
|
|
addr += chunk;
|
|
length -= chunk;
|
|
}
|
|
}
|
|
|
|
/* Write closing record */
|
|
write_ith_record(0, 0, 1, NULL);
|
|
}
|
|
|
|
/* Generate Motorola S-records */
|
|
static void write_srecord(unsigned int len, unsigned int alen,
|
|
uint32_t addr, uint8_t type, void *data)
|
|
{
|
|
char buf[2+2+8+255*2+2+2];
|
|
char *p = buf;
|
|
uint8_t csum, *dptr = data;
|
|
unsigned int i;
|
|
|
|
nasm_assert(len <= 255);
|
|
|
|
switch (alen) {
|
|
case 2:
|
|
addr &= 0xffff;
|
|
break;
|
|
case 3:
|
|
addr &= 0xffffff;
|
|
break;
|
|
case 4:
|
|
break;
|
|
default:
|
|
panic();
|
|
break;
|
|
}
|
|
|
|
csum = (len+alen+1) + addr + (addr >> 8) + (addr >> 16) + (addr >> 24);
|
|
for (i = 0; i < len; i++)
|
|
csum += dptr[i];
|
|
csum = 0xff-csum;
|
|
|
|
p += sprintf(p, "S%c%02X%0*X", type, len+alen+1, alen*2, addr);
|
|
for (i = 0; i < len; i++)
|
|
p += sprintf(p, "%02X", dptr[i]);
|
|
p += sprintf(p, "%02X\n", csum);
|
|
|
|
nasm_write(buf, p-buf, ofile);
|
|
}
|
|
|
|
static void do_output_srec(void)
|
|
{
|
|
uint8_t buf[32];
|
|
struct Section *s;
|
|
uint64_t addr, maxaddr;
|
|
uint64_t length;
|
|
int alen;
|
|
unsigned int chunk;
|
|
char dtype, etype;
|
|
|
|
maxaddr = 0;
|
|
list_for_each(s, sections) {
|
|
/* Skip non-progbits sections */
|
|
if (!(s->flags & TYPE_PROGBITS))
|
|
continue;
|
|
/* Skip zero-length sections */
|
|
if (s->length == 0)
|
|
continue;
|
|
|
|
addr = s->start + s->length - 1;
|
|
if (addr > maxaddr)
|
|
maxaddr = addr;
|
|
}
|
|
|
|
if (maxaddr <= 0xffff) {
|
|
alen = 2;
|
|
dtype = '1'; /* S1 = 16-bit data */
|
|
etype = '9'; /* S9 = 16-bit end */
|
|
} else if (maxaddr <= 0xffffff) {
|
|
alen = 3;
|
|
dtype = '2'; /* S2 = 24-bit data */
|
|
etype = '8'; /* S8 = 24-bit end */
|
|
} else {
|
|
alen = 4;
|
|
dtype = '3'; /* S3 = 32-bit data */
|
|
etype = '7'; /* S7 = 32-bit end */
|
|
}
|
|
|
|
/* Write head record */
|
|
write_srecord(0, 2, 0, '0', NULL);
|
|
|
|
/* Write the progbits sections to the output file. */
|
|
list_for_each(s, sections) {
|
|
/* Skip non-progbits sections */
|
|
if (!(s->flags & TYPE_PROGBITS))
|
|
continue;
|
|
/* Skip zero-length sections */
|
|
if (s->length == 0)
|
|
continue;
|
|
|
|
addr = s->start;
|
|
length = s->length;
|
|
saa_rewind(s->contents);
|
|
|
|
while (length) {
|
|
chunk = 32 - (addr & 31);
|
|
if (length < chunk)
|
|
chunk = length;
|
|
|
|
saa_rnbytes(s->contents, buf, chunk);
|
|
write_srecord(chunk, alen, (uint32_t)addr, dtype, buf);
|
|
|
|
addr += chunk;
|
|
length -= chunk;
|
|
}
|
|
}
|
|
|
|
/* Write closing record */
|
|
write_srecord(0, alen, 0, etype, NULL);
|
|
}
|
|
|
|
|
|
const struct ofmt of_bin = {
|
|
"Flat raw binary (MS-DOS, embedded, ...)",
|
|
"bin",
|
|
"",
|
|
0,
|
|
64,
|
|
null_debug_arr,
|
|
&null_debug_form,
|
|
bin_stdmac,
|
|
bin_init,
|
|
null_reset,
|
|
nasm_do_legacy_output,
|
|
bin_out,
|
|
bin_deflabel,
|
|
bin_secname,
|
|
NULL,
|
|
bin_sectalign,
|
|
null_segbase,
|
|
bin_directive,
|
|
bin_cleanup,
|
|
NULL /* pragma list */
|
|
};
|
|
|
|
const struct ofmt of_ith = {
|
|
"Intel Hex encoded flat binary",
|
|
"ith",
|
|
".ith", /* really should have been ".hex"... */
|
|
OFMT_TEXT,
|
|
64,
|
|
null_debug_arr,
|
|
&null_debug_form,
|
|
bin_stdmac,
|
|
ith_init,
|
|
null_reset,
|
|
nasm_do_legacy_output,
|
|
bin_out,
|
|
bin_deflabel,
|
|
bin_secname,
|
|
NULL,
|
|
bin_sectalign,
|
|
null_segbase,
|
|
bin_directive,
|
|
bin_cleanup,
|
|
NULL /* pragma list */
|
|
};
|
|
|
|
const struct ofmt of_srec = {
|
|
"Motorola S-records encoded flat binary",
|
|
"srec",
|
|
".srec",
|
|
OFMT_TEXT,
|
|
64,
|
|
null_debug_arr,
|
|
&null_debug_form,
|
|
bin_stdmac,
|
|
srec_init,
|
|
null_reset,
|
|
nasm_do_legacy_output,
|
|
bin_out,
|
|
bin_deflabel,
|
|
bin_secname,
|
|
NULL,
|
|
bin_sectalign,
|
|
null_segbase,
|
|
bin_directive,
|
|
bin_cleanup,
|
|
NULL /* pragma list */
|
|
};
|
|
|
|
#endif /* #ifdef OF_BIN */
|