mirror/nasm
2
0
Fork 0
mirror of https://github.com/netwide-assembler/nasm.git synced 2024-11-27 08:10:07 +08:00
Code Issues Packages Projects Releases Wiki Activity
2469b8b66e
nasm/output/outbin.c
Cyrill Gorcunov 8c735c58d1 BR3392739: output/outbin: fix nil dereference for self following sections 
In case if section follows itself we should yield
an error, otherwise we hit nil dereference because
there won't be any group of sections.

After all "follow" attribute is rather to group
sections other than self.



Signed-off-by: Cyrill Gorcunov <gorcunov@gmail.com>
2021-02-21 01:05:28 +03:00

1670 lines
54 KiB
C
Raw Blame History

/* ----------------------------------------------------------------------- *
*
* 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 = &sections->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 = &sections, 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 = &sections, 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 == g)
nasm_fatal("section %s is self following", s->name);
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 = &sections, 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;
enum label_type 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 != LBL_none);
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 != LBL_none);
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, "unable to open map file `%s'", p);
map_control = 0;
return DIRR_OK;
}
}
} else
nasm_warn(WARN_OTHER, "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 */
Reference in New Issue View Git Blame Copy Permalink