/* ----------------------------------------------------------------------- * * * Copyright 1996-2016 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. * * ----------------------------------------------------------------------- */ /* * outieee.c output routines for the Netwide Assembler to produce * IEEE-std object files */ /* notes: I have tried to make this correspond to the IEEE version * of the standard, specifically the primary ASCII version. It should * be trivial to create the binary version given this source (which is * one of MANY things that have to be done to make this correspond to * the hp-microtek version of the standard). * * 16-bit support is assumed to use 24-bit addresses * The linker can sort out segmentation-specific stuff * if it keeps track of externals * in terms of being relative to section bases * * A non-standard variable type, the 'Yn' variable, has been introduced. * Basically it is a reference to extern 'n'- denoting the low limit * (L-variable) of the section that extern 'n' is defined in. Like the * x variable, there may be no explicit assignment to it, it is derived * from the public definition corresponding to the extern name. This * is required because the one thing the mufom guys forgot to do well was * take into account segmented architectures. * * I use comment classes for various things and these are undefined by * the standard. * * Debug info should be considered totally non-standard (local labels are * standard but linenum records are not covered by the standard. * Type defs have the standard format but absolute meanings for ordinal * types are not covered by the standard.) * * David Lindauer, LADsoft */ #include "compiler.h" #include #include /* For toupper() */ #include "nctype.h" #include "nasm.h" #include "nasmlib.h" #include "error.h" #include "ver.h" #include "outform.h" #include "outlib.h" #ifdef OF_IEEE #define ARRAY_BOT 0x1 static char ieee_infile[FILENAME_MAX]; static int ieee_uppercase; static bool any_segs; static int arrindex; #define HUNKSIZE 1024 /* Size of the data hunk */ #define EXT_BLKSIZ 512 #define LDPERLINE 32 /* bytes per line in output */ struct ieeeSection; struct LineNumber { struct LineNumber *next; struct ieeeSection *segment; int32_t offset; int32_t lineno; }; static struct FileName { struct FileName *next; char *name; int32_t index; } *fnhead, **fntail; static struct Array { struct Array *next; unsigned size; int basetype; } *arrhead, **arrtail; static struct ieeePublic { struct ieeePublic *next; char *name; int32_t offset; int32_t segment; /* only if it's far-absolute */ int32_t index; int type; /* for debug purposes */ } *fpubhead, **fpubtail, *last_defined; static struct ieeeExternal { struct ieeeExternal *next; char *name; int32_t commonsize; } *exthead, **exttail; static int externals; static struct ExtBack { struct ExtBack *next; int index[EXT_BLKSIZ]; } *ebhead, **ebtail; /* NOTE: the first segment MUST be the lineno segment */ static struct ieeeSection { struct ieeeSection *next; char *name; struct ieeeObjData *data, *datacurr; struct ieeeFixupp *fptr, *flptr; int32_t index; /* the NASM segment id */ int32_t ieee_index; /* the IEEE-file segment index */ int32_t currentpos; int32_t align; /* can be SEG_ABS + absolute addr */ int32_t startpos; int32_t use32; /* is this segment 32-bit? */ int64_t pass_last_seen; struct ieeePublic *pubhead, **pubtail, *lochead, **loctail; enum { CMB_PRIVATE = 0, CMB_PUBLIC = 2, CMB_COMMON = 6 } combine; } *seghead, **segtail, *ieee_seg_needs_update; struct ieeeObjData { struct ieeeObjData *next; uint8_t data[HUNKSIZE]; }; struct ieeeFixupp { struct ieeeFixupp *next; enum { FT_SEG = 0, FT_REL = 1, FT_OFS = 2, FT_EXT = 3, FT_WRT = 4, FT_EXTREL = 5, FT_EXTWRT = 6, FT_EXTSEG = 7 } ftype; int16_t size; int32_t id1; int32_t id2; int32_t offset; int32_t addend; }; static int32_t ieee_entry_seg, ieee_entry_ofs; static int checksum; extern const struct ofmt of_ieee; static const struct dfmt ladsoft_debug_form; static void ieee_data_new(struct ieeeSection *); static void ieee_write_fixup(int32_t, int32_t, struct ieeeSection *, int, uint64_t, int32_t); static void ieee_install_fixup(struct ieeeSection *, struct ieeeFixupp *); static int32_t ieee_segment(char *, int *); static void ieee_write_file(void); static void ieee_write_byte(struct ieeeSection *, int); static void ieee_write_word(struct ieeeSection *, int); static void ieee_write_dword(struct ieeeSection *, int32_t); static void ieee_putascii(char *, ...); static void ieee_putcs(int); static int32_t ieee_putld(int32_t, int32_t, uint8_t *); static int32_t ieee_putlr(struct ieeeFixupp *); static void ieee_unqualified_name(char *, char *); /* * pup init */ static void ieee_init(void) { strlcpy(ieee_infile, inname, sizeof(ieee_infile)); any_segs = false; fpubhead = NULL; fpubtail = &fpubhead; exthead = NULL; exttail = &exthead; externals = 1; ebhead = NULL; ebtail = &ebhead; seghead = ieee_seg_needs_update = NULL; segtail = &seghead; ieee_entry_seg = NO_SEG; ieee_uppercase = false; checksum = 0; } /* * Rundown */ static void ieee_cleanup(void) { ieee_write_file(); dfmt->cleanup(); while (seghead) { struct ieeeSection *segtmp = seghead; seghead = seghead->next; while (segtmp->pubhead) { struct ieeePublic *pubtmp = segtmp->pubhead; segtmp->pubhead = pubtmp->next; nasm_free(pubtmp); } while (segtmp->fptr) { struct ieeeFixupp *fixtmp = segtmp->fptr; segtmp->fptr = fixtmp->next; nasm_free(fixtmp); } while (segtmp->data) { struct ieeeObjData *dattmp = segtmp->data; segtmp->data = dattmp->next; nasm_free(dattmp); } nasm_free(segtmp); } while (fpubhead) { struct ieeePublic *pubtmp = fpubhead; fpubhead = fpubhead->next; nasm_free(pubtmp); } while (exthead) { struct ieeeExternal *exttmp = exthead; exthead = exthead->next; nasm_free(exttmp); } while (ebhead) { struct ExtBack *ebtmp = ebhead; ebhead = ebhead->next; nasm_free(ebtmp); } } /* * callback for labels */ static void ieee_deflabel(char *name, int32_t segment, int64_t offset, int is_global, char *special) { /* * We have three cases: * * (i) `segment' is a segment-base. If so, set the name field * for the segment structure it refers to, and then * return. * * (ii) `segment' is one of our segments, or a SEG_ABS segment. * Save the label position for later output of a PUBDEF record. * * * (iii) `segment' is not one of our segments. Save the label * position for later output of an EXTDEF. */ struct ieeeExternal *ext; struct ExtBack *eb; struct ieeeSection *seg; int i; if (special) nasm_nonfatal("unrecognised symbol type `%s'", special); /* * First check for the double-period, signifying something * unusual. */ if (name[0] == '.' && name[1] == '.' && name[2] != '@') { if (!strcmp(name, "..start")) { ieee_entry_seg = segment; ieee_entry_ofs = offset; } return; } /* * Case (i): */ if (ieee_seg_needs_update) { ieee_seg_needs_update->name = name; return; } if (segment < SEG_ABS && segment != NO_SEG && segment % 2) return; /* * case (ii) */ if (segment >= SEG_ABS) { /* * SEG_ABS subcase of (ii). */ if (is_global) { struct ieeePublic *pub; pub = *fpubtail = nasm_malloc(sizeof(*pub)); fpubtail = &pub->next; pub->next = NULL; pub->name = name; pub->offset = offset; pub->segment = segment & ~SEG_ABS; } return; } for (seg = seghead; seg && is_global; seg = seg->next) if (seg->index == segment) { struct ieeePublic *pub; last_defined = pub = *seg->pubtail = nasm_malloc(sizeof(*pub)); seg->pubtail = &pub->next; pub->next = NULL; pub->name = name; pub->offset = offset; pub->index = seg->ieee_index; pub->segment = -1; return; } /* * Case (iii). */ if (is_global) { ext = *exttail = nasm_malloc(sizeof(*ext)); ext->next = NULL; exttail = &ext->next; ext->name = name; if (is_global == 2) ext->commonsize = offset; else ext->commonsize = 0; i = segment / 2; eb = ebhead; if (!eb) { eb = *ebtail = nasm_zalloc(sizeof(*eb)); eb->next = NULL; ebtail = &eb->next; } while (i > EXT_BLKSIZ) { if (eb && eb->next) eb = eb->next; else { eb = *ebtail = nasm_zalloc(sizeof(*eb)); eb->next = NULL; ebtail = &eb->next; } i -= EXT_BLKSIZ; } eb->index[i] = externals++; } } /* * Put data out */ static void ieee_out(int32_t segto, const void *data, enum out_type type, uint64_t size, int32_t segment, int32_t wrt) { const uint8_t *ucdata; int32_t ldata; struct ieeeSection *seg; /* * If `any_segs' is still false, we must define a default * segment. */ if (!any_segs) { int tempint; /* ignored */ if (segto != ieee_segment("__NASMDEFSEG", &tempint)) nasm_panic("strange segment conditions in IEEE driver"); } /* * Find the segment we are targetting. */ for (seg = seghead; seg; seg = seg->next) if (seg->index == segto) break; if (!seg) nasm_panic("code directed to nonexistent segment?"); if (type == OUT_RAWDATA) { ucdata = data; while (size--) ieee_write_byte(seg, *ucdata++); } else if (type == OUT_ADDRESS || type == OUT_REL2ADR || type == OUT_REL4ADR) { if (type == OUT_ADDRESS) size = abs((int)size); else if (segment == NO_SEG) nasm_nonfatal("relative call to absolute address not" " supported by IEEE format"); ldata = *(int64_t *)data; if (type == OUT_REL2ADR) ldata += (size - 2); if (type == OUT_REL4ADR) ldata += (size - 4); ieee_write_fixup(segment, wrt, seg, size, type, ldata); if (size == 2) ieee_write_word(seg, ldata); else ieee_write_dword(seg, ldata); } else if (type == OUT_RESERVE) { while (size--) ieee_write_byte(seg, 0); } } static void ieee_data_new(struct ieeeSection *segto) { if (!segto->data) segto->data = segto->datacurr = nasm_malloc(sizeof(*(segto->datacurr))); else segto->datacurr = segto->datacurr->next = nasm_malloc(sizeof(*(segto->datacurr))); segto->datacurr->next = NULL; } /* * this routine is unalduterated bloatware. I usually don't do this * but I might as well see what it is like on a harmless program. * If anyone wants to optimize this is a good canditate! */ static void ieee_write_fixup(int32_t segment, int32_t wrt, struct ieeeSection *segto, int size, uint64_t realtype, int32_t offset) { struct ieeeSection *target; struct ieeeFixupp s; /* Don't put a fixup for things NASM can calculate */ if (wrt == NO_SEG && segment == NO_SEG) return; s.ftype = -1; /* if it is a WRT offset */ if (wrt != NO_SEG) { s.ftype = FT_WRT; s.addend = offset; if (wrt >= SEG_ABS) s.id1 = -(wrt - SEG_ABS); else { if (wrt % 2 && realtype != OUT_REL2ADR && realtype != OUT_REL4ADR) { wrt--; for (target = seghead; target; target = target->next) if (target->index == wrt) break; if (target) { s.id1 = target->ieee_index; for (target = seghead; target; target = target->next) if (target->index == segment) break; if (target) s.id2 = target->ieee_index; else { /* * Now we assume the segment field is being used * to hold an extern index */ int32_t i = segment / 2; struct ExtBack *eb = ebhead; while (i > EXT_BLKSIZ) { if (eb) eb = eb->next; else break; i -= EXT_BLKSIZ; } /* if we have an extern decide the type and make a record */ if (eb) { s.ftype = FT_EXTWRT; s.addend = 0; s.id2 = eb->index[i]; } else nasm_nonfatal("source of WRT must be an offset"); } } else nasm_panic("unrecognised WRT value in ieee_write_fixup"); } else nasm_nonfatal("target of WRT must be a section"); } s.size = size; ieee_install_fixup(segto, &s); return; } /* Pure segment fixup ? */ if (segment != NO_SEG) { s.ftype = FT_SEG; s.id1 = 0; if (segment >= SEG_ABS) { /* absolute far segment fixup */ s.id1 = -(segment - ~SEG_ABS); } else if (segment % 2) { /* fixup to named segment */ /* look it up */ for (target = seghead; target; target = target->next) if (target->index == segment - 1) break; if (target) s.id1 = target->ieee_index; else { /* * Now we assume the segment field is being used * to hold an extern index */ int32_t i = segment / 2; struct ExtBack *eb = ebhead; while (i > EXT_BLKSIZ) { if (eb) eb = eb->next; else break; i -= EXT_BLKSIZ; } /* if we have an extern decide the type and make a record */ if (eb) { if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) { nasm_panic("Segment of a rel not supported in ieee_write_fixup"); } else { /* If we want the segment */ s.ftype = FT_EXTSEG; s.addend = 0; s.id1 = eb->index[i]; } } else /* If we get here the seg value doesn't make sense */ nasm_panic("unrecognised segment value in ieee_write_fixup"); } } else { /* Assume we are offsetting directly from a section * So look up the target segment */ for (target = seghead; target; target = target->next) if (target->index == segment) break; if (target) { if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) { /* PC rel to a known offset */ s.id1 = target->ieee_index; s.ftype = FT_REL; s.size = size; s.addend = offset; } else { /* We were offsetting from a seg */ s.id1 = target->ieee_index; s.ftype = FT_OFS; s.size = size; s.addend = offset; } } else { /* * Now we assume the segment field is being used * to hold an extern index */ int32_t i = segment / 2; struct ExtBack *eb = ebhead; while (i > EXT_BLKSIZ) { if (eb) eb = eb->next; else break; i -= EXT_BLKSIZ; } /* if we have an extern decide the type and make a record */ if (eb) { if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) { s.ftype = FT_EXTREL; s.addend = 0; s.id1 = eb->index[i]; } else { /* else we want the external offset */ s.ftype = FT_EXT; s.addend = 0; s.id1 = eb->index[i]; } } else /* If we get here the seg value doesn't make sense */ nasm_panic("unrecognised segment value in ieee_write_fixup"); } } if (size != 2 && s.ftype == FT_SEG) nasm_nonfatal("IEEE format can only handle 2-byte" " segment base references"); s.size = size; ieee_install_fixup(segto, &s); return; } /* should never get here */ } static void ieee_install_fixup(struct ieeeSection *seg, struct ieeeFixupp *fix) { struct ieeeFixupp *f; f = nasm_malloc(sizeof(struct ieeeFixupp)); memcpy(f, fix, sizeof(struct ieeeFixupp)); f->offset = seg->currentpos; seg->currentpos += fix->size; f->next = NULL; if (seg->fptr) seg->flptr = seg->flptr->next = f; else seg->fptr = seg->flptr = f; } /* * segment registry */ static int32_t ieee_segment(char *name, int *bits) { /* * We call the label manager here to define a name for the new * segment, and when our _own_ label-definition stub gets * called in return, it should register the new segment name * using the pointer it gets passed. That way we save memory, * by sponging off the label manager. */ if (!name) { *bits = 16; if (!any_segs) return 0; return seghead->index; } else { struct ieeeSection *seg; int ieee_idx, attrs; bool rn_error; char *p; /* * Look for segment attributes. */ attrs = 0; while (*name == '.') name++; /* hack, but a documented one */ p = name; while (*p && !nasm_isspace(*p)) p++; if (*p) { *p++ = '\0'; while (*p && nasm_isspace(*p)) *p++ = '\0'; } while (*p) { while (*p && !nasm_isspace(*p)) p++; if (*p) { *p++ = '\0'; while (*p && nasm_isspace(*p)) *p++ = '\0'; } attrs++; } ieee_idx = 1; for (seg = seghead; seg; seg = seg->next) { ieee_idx++; if (!strcmp(seg->name, name)) { if (attrs > 0 && seg->pass_last_seen == pass_count()) nasm_warn(WARN_OTHER, "segment attributes specified on" " redeclaration of segment: ignoring"); if (seg->use32) *bits = 32; else *bits = 16; seg->pass_last_seen = pass_count(); return seg->index; } } *segtail = seg = nasm_malloc(sizeof(*seg)); seg->next = NULL; segtail = &seg->next; seg->index = seg_alloc(); seg->ieee_index = ieee_idx; any_segs = true; seg->name = NULL; seg->currentpos = 0; seg->align = 1; /* default */ seg->use32 = *bits == 32; /* default to user spec */ seg->combine = CMB_PUBLIC; /* default */ seg->pubhead = NULL; seg->pubtail = &seg->pubhead; seg->data = NULL; seg->fptr = NULL; seg->lochead = NULL; seg->loctail = &seg->lochead; /* * Process the segment attributes. */ p = name; while (attrs--) { p += strlen(p); while (!*p) p++; /* * `p' contains a segment attribute. */ if (!nasm_stricmp(p, "private")) seg->combine = CMB_PRIVATE; else if (!nasm_stricmp(p, "public")) seg->combine = CMB_PUBLIC; else if (!nasm_stricmp(p, "common")) seg->combine = CMB_COMMON; else if (!nasm_stricmp(p, "use16")) seg->use32 = false; else if (!nasm_stricmp(p, "use32")) seg->use32 = true; else if (!nasm_strnicmp(p, "align=", 6)) { seg->align = readnum(p + 6, &rn_error); if (seg->align == 0) seg->align = 1; if (rn_error) { seg->align = 1; nasm_nonfatal("segment alignment should be numeric"); } switch (seg->align) { case 1: /* BYTE */ case 2: /* WORD */ case 4: /* DWORD */ case 16: /* PARA */ case 256: /* PAGE */ case 8: case 32: case 64: case 128: break; default: nasm_nonfatal("invalid alignment value %d", seg->align); seg->align = 1; break; } } else if (!nasm_strnicmp(p, "absolute=", 9)) { seg->align = SEG_ABS + readnum(p + 9, &rn_error); if (rn_error) nasm_nonfatal("argument to `absolute' segment" " attribute should be numeric"); } } ieee_seg_needs_update = seg; if (seg->align >= SEG_ABS) define_label(name, NO_SEG, seg->align - SEG_ABS, false); else define_label(name, seg->index + 1, 0L, false); ieee_seg_needs_update = NULL; if (seg->use32) *bits = 32; else *bits = 16; return seg->index; } } /* * directives supported */ static enum directive_result ieee_directive(enum directive directive, char *value) { (void)value; switch (directive) { case D_UPPERCASE: ieee_uppercase = true; return DIRR_OK; default: return DIRR_UNKNOWN; } } static void ieee_sectalign(int32_t seg, unsigned int value) { struct ieeeSection *s; list_for_each(s, seghead) { if (s->index == seg) break; } /* * 256 is maximum there, note it may happen * that align is issued on "absolute" segment * it's fine since SEG_ABS > 256 and we never * get escape this test */ if (!s || !is_power2(value) || value > 256) return; if ((unsigned int)s->align < value) s->align = value; } /* * Return segment data */ static int32_t ieee_segbase(int32_t segment) { struct ieeeSection *seg; /* * Find the segment in our list. */ for (seg = seghead; seg; seg = seg->next) if (seg->index == segment - 1) break; if (!seg) return segment; /* not one of ours - leave it alone */ if (seg->align >= SEG_ABS) return seg->align; /* absolute segment */ return segment; /* no special treatment */ } static void ieee_write_file(void) { const struct tm * const thetime = &official_compile_time.local; struct FileName *fn; struct ieeeSection *seg; struct ieeePublic *pub, *loc; struct ieeeExternal *ext; struct ieeeObjData *data; struct ieeeFixupp *fix; struct Array *arr; int i; const bool debuginfo = (dfmt == &ladsoft_debug_form); /* * Write the module header */ ieee_putascii("MBFNASM,%02X%s.\n", strlen(ieee_infile), ieee_infile); /* * Write the NASM boast comment. */ ieee_putascii("CO0,%02X%s.\n", nasm_comment_len(), nasm_comment()); /* * write processor-specific information */ ieee_putascii("AD8,4,L.\n"); /* * date and time */ ieee_putascii("DT%04d%02d%02d%02d%02d%02d.\n", 1900 + thetime->tm_year, thetime->tm_mon + 1, thetime->tm_mday, thetime->tm_hour, thetime->tm_min, thetime->tm_sec); /* * if debugging, dump file names */ for (fn = fnhead; fn && debuginfo; fn = fn->next) { ieee_putascii("C0105,%02X%s.\n", strlen(fn->name), fn->name); } ieee_putascii("CO101,07ENDHEAD.\n"); /* * the standard doesn't specify when to put checksums, * we'll just do it periodically. */ ieee_putcs(false); /* * Write the section headers */ seg = seghead; if (!debuginfo && !strcmp(seg->name, "??LINE")) seg = seg->next; while (seg) { char buf[256]; char attrib; switch (seg->combine) { case CMB_PUBLIC: default: attrib = 'C'; break; case CMB_PRIVATE: attrib = 'S'; break; case CMB_COMMON: attrib = 'M'; break; } ieee_unqualified_name(buf, seg->name); if (seg->align >= SEG_ABS) { ieee_putascii("ST%X,A,%02X%s.\n", seg->ieee_index, strlen(buf), buf); ieee_putascii("ASL%X,%lX.\n", seg->ieee_index, (seg->align - SEG_ABS) * 16); } else { ieee_putascii("ST%X,%c,%02X%s.\n", seg->ieee_index, attrib, strlen(buf), buf); ieee_putascii("SA%X,%lX.\n", seg->ieee_index, seg->align); ieee_putascii("ASS%X,%X.\n", seg->ieee_index, seg->currentpos); } seg = seg->next; } /* * write the start address if there is one */ if (ieee_entry_seg) { for (seg = seghead; seg; seg = seg->next) if (seg->index == ieee_entry_seg) break; if (!seg) nasm_panic("Start address records are incorrect"); else ieee_putascii("ASG,R%X,%lX,+.\n", seg->ieee_index, ieee_entry_ofs); } ieee_putcs(false); /* * Write the publics */ i = 1; for (seg = seghead; seg; seg = seg->next) { for (pub = seg->pubhead; pub; pub = pub->next) { char buf[256]; ieee_unqualified_name(buf, pub->name); ieee_putascii("NI%X,%02X%s.\n", i, strlen(buf), buf); if (pub->segment == -1) ieee_putascii("ASI%X,R%X,%lX,+.\n", i, pub->index, pub->offset); else ieee_putascii("ASI%X,%lX,%lX,+.\n", i, pub->segment * 16, pub->offset); if (debuginfo) { if (pub->type >= 0x100) ieee_putascii("ATI%X,T%X.\n", i, pub->type - 0x100); else ieee_putascii("ATI%X,%X.\n", i, pub->type); } i++; } } pub = fpubhead; i = 1; while (pub) { char buf[256]; ieee_unqualified_name(buf, pub->name); ieee_putascii("NI%X,%02X%s.\n", i, strlen(buf), buf); if (pub->segment == -1) ieee_putascii("ASI%X,R%X,%lX,+.\n", i, pub->index, pub->offset); else ieee_putascii("ASI%X,%lX,%lX,+.\n", i, pub->segment * 16, pub->offset); if (debuginfo) { if (pub->type >= 0x100) ieee_putascii("ATI%X,T%X.\n", i, pub->type - 0x100); else ieee_putascii("ATI%X,%X.\n", i, pub->type); } i++; pub = pub->next; } /* * Write the externals */ ext = exthead; i = 1; while (ext) { char buf[256]; ieee_unqualified_name(buf, ext->name); ieee_putascii("NX%X,%02X%s.\n", i++, strlen(buf), buf); ext = ext->next; } ieee_putcs(false); /* * IEEE doesn't have a standard pass break record * so use the ladsoft variant */ ieee_putascii("CO100,06ENDSYM.\n"); /* * now put types */ i = ARRAY_BOT; for (arr = arrhead; arr && debuginfo; arr = arr->next) { ieee_putascii("TY%X,20,%X,%lX.\n", i++, arr->basetype, arr->size); } /* * now put locals */ i = 1; for (seg = seghead; seg && debuginfo; seg = seg->next) { for (loc = seg->lochead; loc; loc = loc->next) { char buf[256]; ieee_unqualified_name(buf, loc->name); ieee_putascii("NN%X,%02X%s.\n", i, strlen(buf), buf); if (loc->segment == -1) ieee_putascii("ASN%X,R%X,%lX,+.\n", i, loc->index, loc->offset); else ieee_putascii("ASN%X,%lX,%lX,+.\n", i, loc->segment * 16, loc->offset); if (debuginfo) { if (loc->type >= 0x100) ieee_putascii("ATN%X,T%X.\n", i, loc->type - 0x100); else ieee_putascii("ATN%X,%X.\n", i, loc->type); } i++; } } /* * put out section data; */ seg = seghead; if (!debuginfo && !strcmp(seg->name, "??LINE")) seg = seg->next; while (seg) { if (seg->currentpos) { int32_t size, org = 0; data = seg->data; ieee_putascii("SB%X.\n", seg->ieee_index); fix = seg->fptr; while (fix) { size = HUNKSIZE - (org % HUNKSIZE); size = size + org > seg->currentpos ? seg->currentpos - org : size; size = fix->offset - org > size ? size : fix->offset - org; org = ieee_putld(org, org + size, data->data); if (org % HUNKSIZE == 0) data = data->next; if (org == fix->offset) { org += ieee_putlr(fix); fix = fix->next; } } while (org < seg->currentpos && data) { size = seg->currentpos - org > HUNKSIZE ? HUNKSIZE : seg->currentpos - org; org = ieee_putld(org, org + size, data->data); data = data->next; } ieee_putcs(false); } seg = seg->next; } /* * module end record */ ieee_putascii("ME.\n"); } static void ieee_write_byte(struct ieeeSection *seg, int data) { int temp; if (!(temp = seg->currentpos++ % HUNKSIZE)) ieee_data_new(seg); seg->datacurr->data[temp] = data; } static void ieee_write_word(struct ieeeSection *seg, int data) { ieee_write_byte(seg, data & 0xFF); ieee_write_byte(seg, (data >> 8) & 0xFF); } static void ieee_write_dword(struct ieeeSection *seg, int32_t data) { ieee_write_byte(seg, data & 0xFF); ieee_write_byte(seg, (data >> 8) & 0xFF); ieee_write_byte(seg, (data >> 16) & 0xFF); ieee_write_byte(seg, (data >> 24) & 0xFF); } static void ieee_putascii(char *format, ...) { char buffer[256]; int i, l; va_list ap; va_start(ap, format); vsnprintf(buffer, sizeof(buffer), format, ap); l = strlen(buffer); for (i = 0; i < l; i++) if ((uint8_t)buffer[i] > 31) checksum += buffer[i]; va_end(ap); fputs(buffer, ofile); } /* * put out a checksum record */ static void ieee_putcs(int toclear) { if (toclear) { ieee_putascii("CS.\n"); } else { checksum += 'C'; checksum += 'S'; ieee_putascii("CS%02X.\n", checksum & 127); } checksum = 0; } static int32_t ieee_putld(int32_t start, int32_t end, uint8_t *buf) { int32_t val; if (start == end) return (start); val = start % HUNKSIZE; /* fill up multiple lines */ while (end - start >= LDPERLINE) { int i; ieee_putascii("LD"); for (i = 0; i < LDPERLINE; i++) { ieee_putascii("%02X", buf[val++]); start++; } ieee_putascii(".\n"); } /* if no partial lines */ if (start == end) return (start); /* make a partial line */ ieee_putascii("LD"); while (start < end) { ieee_putascii("%02X", buf[val++]); start++; } ieee_putascii(".\n"); return (start); } static int32_t ieee_putlr(struct ieeeFixupp *p) { /* * To deal with the vagaries of segmentation the LADsoft linker * defines two types of segments: absolute and virtual. Note that * 'absolute' in this context is a different thing from the IEEE * definition of an absolute segment type, which is also supported. If a * sement is linked in virtual mode the low limit (L-var) is * subtracted from each R,X, and P variable which appears in an * expression, so that we can have relative offsets. Meanwhile * in the ABSOLUTE mode this subtraction is not done and * so we can use absolute offsets from 0. In the LADsoft linker * this configuration is not done in the assemblker source but in * a source the linker reads. Generally this type of thing only * becomes an issue if real mode code is used. A pure 32-bit linker could * get away without defining the virtual mode... */ char buf[40]; int32_t size = p->size; switch (p->ftype) { case FT_SEG: if (p->id1 < 0) sprintf(buf, "%"PRIX32"", -p->id1); else sprintf(buf, "L%"PRIX32",10,/", p->id1); break; case FT_OFS: sprintf(buf, "R%"PRIX32",%"PRIX32",+", p->id1, p->addend); break; case FT_REL: sprintf(buf, "R%"PRIX32",%"PRIX32",+,P,-,%X,-", p->id1, p->addend, p->size); break; case FT_WRT: if (p->id2 < 0) sprintf(buf, "R%"PRIX32",%"PRIX32",+,L%"PRIX32",+,%"PRIX32",-", p->id2, p->addend, p->id2, -p->id1 * 16); else sprintf(buf, "R%"PRIX32",%"PRIX32",+,L%"PRIX32",+,L%"PRIX32",-", p->id2, p->addend, p->id2, p->id1); break; case FT_EXT: sprintf(buf, "X%"PRIX32"", p->id1); break; case FT_EXTREL: sprintf(buf, "X%"PRIX32",P,-,%"PRIX32",-", p->id1, size); break; case FT_EXTSEG: /* We needed a non-ieee hack here. * We introduce the Y variable, which is the low * limit of the native segment the extern resides in */ sprintf(buf, "Y%"PRIX32",10,/", p->id1); break; case FT_EXTWRT: if (p->id2 < 0) sprintf(buf, "X%"PRIX32",Y%"PRIX32",+,%"PRIX32",-", p->id2, p->id2, -p->id1 * 16); else sprintf(buf, "X%"PRIX32",Y%"PRIX32",+,L%"PRIX32",-", p->id2, p->id2, p->id1); break; } ieee_putascii("LR(%s,%"PRIX32").\n", buf, size); return (size); } /* Dump all segment data (text and fixups )*/ static void ieee_unqualified_name(char *dest, char *source) { if (ieee_uppercase) { while (*source) *dest++ = toupper(*source++); *dest = 0; } else strcpy(dest, source); } static void dbgls_init(void) { int tempint; fnhead = NULL; fntail = &fnhead; arrindex = ARRAY_BOT; arrhead = NULL; arrtail = &arrhead; ieee_segment("??LINE", &tempint); any_segs = false; } static void dbgls_cleanup(void) { struct ieeeSection *segtmp; while (fnhead) { struct FileName *fntemp = fnhead; fnhead = fnhead->next; nasm_free(fntemp->name); nasm_free(fntemp); } for (segtmp = seghead; segtmp; segtmp = segtmp->next) { while (segtmp->lochead) { struct ieeePublic *loctmp = segtmp->lochead; segtmp->lochead = loctmp->next; nasm_free(loctmp->name); nasm_free(loctmp); } } while (arrhead) { struct Array *arrtmp = arrhead; arrhead = arrhead->next; nasm_free(arrtmp); } } /* * because this routine is not bracketed in * the main program, this routine will be called even if there * is no request for debug info * so, we have to make sure the ??LINE segment is avaialbe * as the first segment when this debug format is selected */ static void dbgls_linnum(const char *lnfname, int32_t lineno, int32_t segto) { struct FileName *fn; struct ieeeSection *seg; int i = 0; if (segto == NO_SEG) return; /* * If `any_segs' is still false, we must define a default * segment. */ if (!any_segs) { int tempint; /* ignored */ if (segto != ieee_segment("__NASMDEFSEG", &tempint)) nasm_panic("strange segment conditions in IEEE driver"); } /* * Find the segment we are targetting. */ for (seg = seghead; seg; seg = seg->next) if (seg->index == segto) break; if (!seg) nasm_panic("lineno directed to nonexistent segment?"); for (fn = fnhead; fn; fn = fn->next) { if (!nasm_stricmp(lnfname, fn->name)) break; i++; } if (!fn) { fn = nasm_malloc(sizeof(*fn)); fn->name = nasm_malloc(strlen(lnfname) + 1); fn->index = i; strcpy(fn->name, lnfname); fn->next = NULL; *fntail = fn; fntail = &fn->next; } ieee_write_byte(seghead, fn->index); ieee_write_word(seghead, lineno); ieee_write_fixup(segto, NO_SEG, seghead, 4, OUT_ADDRESS, seg->currentpos); } static void dbgls_deflabel(char *name, int32_t segment, int64_t offset, int is_global, char *special) { struct ieeeSection *seg; /* Keep compiler from warning about special */ (void)special; /* * Note: ..[^@] special symbols are filtered in labels.c */ /* * If it's a special-retry from pass two, discard it. */ if (is_global == 3) return; /* * Case (i): */ if (ieee_seg_needs_update) return; if (segment < SEG_ABS && segment != NO_SEG && segment % 2) return; if (segment >= SEG_ABS || segment == NO_SEG) { return; } /* * If `any_segs' is still false, we might need to define a * default segment, if they're trying to declare a label in * `first_seg'. But the label should exist due to a prior * call to ieee_deflabel so we can skip that. */ for (seg = seghead; seg; seg = seg->next) if (seg->index == segment) { struct ieeePublic *loc; /* * Case (ii). Maybe MODPUB someday? */ if (!is_global) { last_defined = loc = nasm_malloc(sizeof(*loc)); *seg->loctail = loc; seg->loctail = &loc->next; loc->next = NULL; loc->name = nasm_strdup(name); loc->offset = offset; loc->segment = -1; loc->index = seg->ieee_index; } } } static void dbgls_typevalue(int32_t type) { int elem = TYM_ELEMENTS(type); type = TYM_TYPE(type); if (!last_defined) return; switch (type) { case TY_BYTE: last_defined->type = 1; /* uint8_t */ break; case TY_WORD: last_defined->type = 3; /* unsigned word */ break; case TY_DWORD: last_defined->type = 5; /* unsigned dword */ break; case TY_FLOAT: last_defined->type = 9; /* float */ break; case TY_QWORD: last_defined->type = 10; /* qword */ break; case TY_TBYTE: last_defined->type = 11; /* TBYTE */ break; default: last_defined->type = 0x10; /* near label */ break; } if (elem > 1) { struct Array *arrtmp = nasm_malloc(sizeof(*arrtmp)); int vtype = last_defined->type; arrtmp->size = elem; arrtmp->basetype = vtype; arrtmp->next = NULL; last_defined->type = arrindex++ + 0x100; *arrtail = arrtmp; arrtail = &(arrtmp->next); } last_defined = NULL; } static void dbgls_output(int output_type, void *param) { (void)output_type; (void)param; } static const struct dfmt ladsoft_debug_form = { "LADsoft Debug Records", "ladsoft", dbgls_init, dbgls_linnum, dbgls_deflabel, null_debug_directive, dbgls_typevalue, dbgls_output, dbgls_cleanup, NULL /* pragma list */ }; static const struct dfmt * const ladsoft_debug_arr[3] = { &ladsoft_debug_form, &null_debug_form, NULL }; const struct ofmt of_ieee = { "IEEE-695 (LADsoft variant) object file format", "ieee", ".o", OFMT_TEXT, 32, ladsoft_debug_arr, &ladsoft_debug_form, NULL, ieee_init, null_reset, nasm_do_legacy_output, ieee_out, ieee_deflabel, ieee_segment, NULL, ieee_sectalign, ieee_segbase, ieee_directive, ieee_cleanup, NULL /* pragma list */ }; #endif /* OF_IEEE */