diff options
Diffstat (limited to 'vere/ext/nasm/output/outbin.c')
| -rw-r--r-- | vere/ext/nasm/output/outbin.c | 1669 |
1 files changed, 1669 insertions, 0 deletions
diff --git a/vere/ext/nasm/output/outbin.c b/vere/ext/nasm/output/outbin.c new file mode 100644 index 0000000..1522e5c --- /dev/null +++ b/vere/ext/nasm/output/outbin.c @@ -0,0 +1,1669 @@ +/* ----------------------------------------------------------------------- * + * + * 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 certain 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 == 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 = §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; + 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 */ |