/* ----------------------------------------------------------------------- * * * 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..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; 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..start */ strcpy(label_name + base_len, ".start"); define_label(label_name, sec->start_index, 0L, false); /* section..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 */