Separated DOS archives into main-program and documentation to reduce
download size.
+
+0.98 not released yet
+---------------------
+
+Fixed a bug whereby STRUC didn't work at all in RDF.
+
+Fixed a problem with group specification in PUBDEFs in OBJ.
+
+Improved ease of adding new output formats. Contribution due to
+Fox Cutter.
+
+Fixed a bug in relocations in the `bin' format: was showing up when
+a relocatable reference crossed an 8192-byte boundary in any output
+section.
+
+Fixed a bug in local labels: local-label lookups were inconsistent
+between passes one and two if an EQU occurred between the definition
+of a global label and the subsequent use of a local label local to
+that global.
+
+Fixed a seg-fault in the preprocessor (again) which happened when
+you use a blank line as the first line of a multi-line macro
+definition and then defined a label on the same line as a call to
+that macro.
+
+Fixed a stale-pointer bug in the handling of the NASM environment
+variable. Thanks to Thomas McWilliams.
+
+ELF had a hard limit on the number of sections which caused
+segfaults when transgressed. Fixed.
+
+Added ability for ndisasm to read from stdin by using `-' as the
+filename.
+
+ndisasm wasn't outputting the TO keyword. Fixed.
+
+Fixed error cascade on bogus expression in %if - an error in
+evaluation was causing the entire %if to be discarded, thus creating
+trouble later when the %else or %endif was encountered.
+
+Forward reference tracking was instruction-granular not operand-
+granular, which was causing 286-specific code to be generated
+needlessly on code of the form `shr word [forwardref],1'. Thanks to
+Jim Hague for sending a patch.
+
+All messages now appear on stdout, as sending them to stderr serves
+no useful purpose other than to make redirection difficult.
+
+Fixed the problem with EQUs pointing to an external symbol - this
+now generates an error message.
+
+Allowed multiple size prefixes to an operand, of which only the first
+is taken into account.
+
+Incorporated John Fine's changes, including fixes of a large number
+of preprocessor bugs, some small problems in OBJ, and a reworking of
+label handling to define labels before their line is assembled, rather
+than after.
+
+Reformatted a lot of the source code to be more readable. Included
+'coding.txt' as a guideline for how to format code for contributors.
+
+Stopped nested %reps causing a panic - they now cause a slightly more
+friendly error message instead.
+
+Fixed floating point constant problems (patch by Pedro Gimeno)
+
+Fixed the return value of insn_size() not being checked for -1, indicating
+an error.
+
+Incorporated 3D now instructions.
+
+Fixed the 'mov eax, eax + ebx' bug.
+
+Fixed the GLOBAL EQU bug in ELF. Released developers release 3.
+
+Incorporated John Fine's command line parsing changes
+
+Incorporated David Lindauer's OMF debug support
+
+Made changes for LCC 4.0 support (__NASM_CDecl__, removed register size
+specification warning when sizes agree).
+
+Released NASM 0.98 Pre-release 1
+
+fixed bug in outcoff.c to do with truncating section names longer
+than 8 characters, referencing beyond end of string; 0.98 pre-release 2
+
+added response file support, improved command line handling, new layout
+help screen
+
+fixed limit checking bug, 'OUT byte nn, reg' bug, and a couple of rdoff
+related bugs, updated Wishlist; 0.98 Prerelease 3.
+
NASM Wishlist
=============
-- forward-reference tracking is instruction-granular not operand-
- granular. Bummer.
+Numbers on right hand side are version numbers that it would be nice to
+have this done by. ? means I haven't looked at it yet.
-- see if BITS can be made to do anything sensible in obj (eg set the
+- Create a binary RDF tools distribution. Should probably be distributed 0.98
+ seperately.
+
+- Check misc/ide.cfg into RCS as Watcom IDE enhancement thingy. 0.98
+ (nop@dlc.fi)
+
+- Package the Linux Assembler HOWTO. 0.98
+
+- AMD 3dNow extensions need documenting. 0.98
+
+- prototypes of lrotate don't match in test/*. Fix. 0.98
+
+- Build djgpp binaries for 0.98 onwards. Look into PMODE/W as a stub 0.98
+ - it might be a lot better than CWSDPMI. It's in PMW133.ZIP.
+
+- Fix `%error' giving error messages twice. 0.99
+ Not especially important, as changes planned for 1.1x below will make
+ the preprocessor be only called once.
+
+- Sort out problems with OBJ: 0.99
+ * TLINK32 doesn't seem to like SEGDEF32 et al. So for that, we
+ should avoid xxx32 records wherever we can.
+ * However, didn't we change _to_ using xxx32 at some stage? Try
+ to remember why and when.
+ * Apparently Delphi's linker has trouble with two or more
+ globals being defined inside a PUBDEF32. Don't even know if it
+ _can_ cope with a PUBDEF16.
+ * Might need extra flags. *sigh*
+
+- Symbol table output may possibly be useful. 0.99
+ Ken Martwick (kenm@efn.org) wants the following format:
+ labelname type offset(hex) repetition count
+ Possibly include xref addresses after repetition count?
+
+- There are various other bugs in outelf.c that make certain kinds 0.99
+ of relocation not work. See zbrown.asm. Looks like we may have to do
+ a major rewrite of parts of it. Compare some NASM code output with
+ equivalent GAS code output. Look at the ELF spec. Generally fix things.
+
+- NASM is currently using a kludge in ELF that involves defining 0.99
+ a symbol at a zero absolute offset. This isn't needed, as the
+ documented solution to the problem that this solves is to use
+ SHN_UNDEF.
+
+- Debug information, in all formats it can be usefully done in. 0.99
+ * including line-number record support.
+ * "George C. Lindauer" <gclind01@starbase.spd.louisville.edu>
+ wants to have some say in how this goes through.
+ * Andrew Crabtree <andrewc@rosemail.rose.hp.com> wants to help out.
+
+- Think about a line-continuation character. 0.99
+
+- Consider allowing declaration of two labels on the same line,
+ syntax 'label1[:] label2[:] ... instruction'. Need to investigate
+ feasibility. 0.99
+
+- Quoting of quotes by doubling them, in string and char constants. 0.99
+
+- Two-operand syntax for SEGMENT/SECTION macro to avoid warnings 0.99
+ of ignored section parameters on reissue of __SECT__.
+ Or maybe skip the warning if the given parameters are identical to
+ what was actually stored. Investigate.
+
+- Apparently we are not missing a PSRAQ instruction, because it
+ doesn't exist. Check that it doesn't exist as an undocumented
+ instruction, or something stupid like that. 0.99
+
+- Any assembled form starting 0x80 can also start 0x82. ndisasm 1.00
+ should know this. New special code in instruction encodings,
+ probably.
+
+- Pointing an EQU at an external symbol now generates an error. There 1.05
+ may be a better way of handling this; we should look into it.
+ Ideally, the label mechanism should be changed to cope with one
+ label being declared relative to another - that may work, but could be
+ a pain to implement (or is it? it may be easy enough that you just
+ need to declare a new offset in the same segment...) This should be done
+ before v1.0 is released. There is a comment regarding this in labels.c,
+ towards the end of the file, which discusses ways of fixing this.
+
+- nested %rep used to cause a panic. Now a more informative error 1.10
+ message is produced. This problem whould be fixed before v1.0.
+ See comment in switch() statement block for PP_REP in do_directive()
+ in preproc.c (line 1585, or thereabouts)
+
+- Contribution: zgraeme.tar contains improved hash table routines ?
+ contributed by Graeme Defty <graeme@HK.Super.NET> for use in the
+ label manager.
+
+- Contribution: zsyntax.zip contains a syntax-highlighting mode for ?
+ NASM, for use with the Aurora text editor (??).
+
+- Contribution: zvim.zip contains a syntax-highlighting mode for ?
+ NASM, for use with vim.
+
+- Contribution: zkendal1.zip and zkendal2.zip contain Kendall ?
+ Bennett's (<KendallB@scitechsoft.com>) alternative syntax stuff,
+ providing an alternative syntax mode for NASM which allows a macro
+ set to be written that allows the same source files to be
+ assembled with NASM and TASM.
+
+- Add the UD2 instruction. ?
+
+- Add the four instructions documented in 24368901.pdf (Intel's own ?
+ document).
+
+- Some means of avoiding MOV memoffs,EAX which apparently the 1.10?
+ Pentium pairing detector thinks modifies EAX. Similar means of
+ choosing instruction encodings where necessary.
+
+- The example of ..@ makes it clear that a ..@ label isn't just ?
+ local, but doesn't make it clear that it isn't just global either.
+
+- hpa wants an evaluator operator for ceil(log2(x)). ?
+
+- Extra reloc types in ELF: R_386_16 type 20, PC16 is 21, 8 is 22, PC8 is 23.
+ Add support for the 16s at least. ?
+
+
+- Lazy section creation or selective section output, in COFF/win32 ?
+ at least and probably other formats: don't bother to emit a section
+ if it contains no data. Particularly the default auto-created
+ section. We believe zero-length sections crash at least WLINK (in
+ win32).
+
+- Make the flags field in `struct itemplate' in insns.h a long ?
+ instead of an int.
+
+- Implement %ifref to check whether a single-line macro has ever been ?
+ expanded since (last re) definition. Or maybe not. We'll see.
+
+- add pointer to \k{insLEAVE} and \k{insENTER} in chapters about ?
+ mixed-language programming.
+
+- Some equivalent to TASM's GLOBAL directive, ie something which ?
+ defines a symbol as external if it doesn't end up being defined
+ but defines it as public if it does end up being defined.
+
+- Documentation doesn't explain about C++ name mangling. ?
+
+- see if BITS can be made to do anything sensible in obj (eg set the ?
default new-segment property to Use32).
-- __DATE__, __TIME__, and text variants of __NASM_MAJOR__ and
+- OBJ: coalesce consecutive offset and segment fixups for the same ?
+ location into full-32bit-pointer fixups. This is apparently
+ necessary because some twazzock in the PowerBASIC development
+ team didn't deign to support the OMF spec the way the rest of the
+ world sees it.
+
+- Allow % to be separated from the rest of a preproc directive, for ?
+ alternative directive indentation styles.
+
+- __DATE__, __TIME__, and text variants of __NASM_MAJOR__ and ?
__NASM_MINOR__.
-- Warn on TIMES combined with multi-line macros. TIMES gets applied
+- Warn on TIMES combined with multi-line macros. TIMES gets applied 1.00
to first line only - should bring to users' attention.
-- Add support for lcc 4.0.
- * If-when this happens, remember to bump the `supported lcc
- version' number in Readme.
-
-- Re-work the evaluator, again, with a per-object-format fixup
+- Re-work the evaluator, again, with a per-object-format fixup 1.10
routine, so as to be able to cope with section offsets "really"
being pure numbers; should be able to allow at _least_ the two
common idioms
had to. (_Always_ returning UNKNOWN on pass one, though a lovely
clean design, breaks the first of the above examples.)
-- Preprocessor identifier concatenation?
+- Preprocessor identifier concatenation? 1.10
-- Arbitrary section names in `bin'.
+- Arbitrary section names in `bin'. ?
+ Is this necessary? Is it even desirable?
-- Ability to read from a pipe. Obviously not useful under dos, so
+- Ability to read from a pipe. Obviously not useful under dos, so 1.10
memory problems with storing entire input file aren't a problem
either.
-- Subsection support?
+ Related topic: file caching under DOS/32 bit... 1.10?
+ maybe even implement discardable buffers that get thrown away
+ when we get a NULL returned from malloc(). Only really useful under
+ DOS. Think about it.
+
+ Another related topic: possibly spool out the pre-processed 1.10?
+ stuff to a file, to avoid having to re-process it. Possible problems
+ with preprocessor values not known on pass 1? Have a look...
+
+ Or maybe we can spool out a pre-parsed version...? 1.10
+ Need to investigate feasibility. Does the results from the parser
+ change from pass 1 to pass 2? Would it be feasible to alter it so that
+ the parser returns an invariant result, and this is then processed
+ afterwards to resolve label references, etc?
-- A good ALIGN mechanism, similar to GAS's. GAS pads out space by
+- Subsection support? ?
+
+- A good ALIGN mechanism, similar to GAS's. GAS pads out space by 1.10?
means of the following (32-bit) instructions:
8DB42600000000 lea esi,[esi+0x0]
8DB600000000 lea esi,[esi+0x0]
Also re-work the macro form so that when given one argument in a
code section it calls this feature.
-- Possibly a means whereby FP constants can be specified as
+- Possibly a means whereby FP constants can be specified as ?
immediate operands to non-FP instructions.
* Possible syntax: MOV EAX,FLOAT 1.2 to get a single-precision FP
constant. Then maybe MOV EAX,HI_FLOAT 1.2 and MOV EAX,LO_FLOAT
chunks, one-byte chunks, even stranger chunks, and pieces of
ten-byte reals to be bandied around as well.
-- A UNION macro might be quite cool, now that ABSOLUTE is sane
+- A UNION macro might be quite cool, now that ABSOLUTE is sane ?
enough to be able to handle it.
-- An equivalent to gcc's ## stringify operator, plus string
+- An equivalent to gcc's ## stringify operator, plus string ?
concatenation, somehow implemented without undue ugliness, so as
to be able to do `%include "/my/path/%1"' in a macro, or something
similar...
-- Actually _do_ something with the processor, privileged and
- undocumented flags in the instruction table.
+- Actually _do_ something with the processor, privileged and 1.10
+ undocumented flags in the instruction table. When this happens,
+ consider allowing PMULHRW to map to either of the Cyrix or AMD
+ versions?
-- Maybe NEC V20/V30 instructions?
+- Maybe NEC V20/V30 instructions? ?
- Yet more object formats.
- * Possibly direct support for .EXE files?
-
-- Debug information, in all formats it can be usefully done in.
- * including line-number record support.
+ * Possibly direct support for .EXE files? 1.10
-- Symbol map in binary format. Format-specific options...
+- Symbol map in binary format. Format-specific options... 1.10?
-- REDESIGN: Think about EQU dependency, and about start-point
+- REDESIGN: Think about EQU dependency, and about start-point 1.20?
specification in OBJ. Possibly re-think directive support.
-- Think about a wrapper program like gcc? Possibly invent a _patch_
+- Think about a wrapper program like gcc? Possibly invent a _patch_ 2.00?
for gcc so that it can take .asm files on the command line?
-- If a wrapper happens, think about adding an option to cause the
+- If a wrapper happens, think about adding an option to cause the ?
resulting executable file to be executed immediately, thus
allowing NASM source files to have #!... (probably silly)
-- Multi-platform support? If so: definitely Alpha; possibly Java
+- Multi-platform support? If so: definitely Alpha; possibly Java ?
byte code; probably ARM/StrongARM; maybe Sparc; maybe Mips; maybe
Vax. Perhaps Z80 and 6502, just for a laugh?
+
+- Consider a 'verbose' option that prints information about the resulting ?
+ object file onto stdout.
+
+
static long calcsize (long, long, int, insn *, char *);
static void gencode (long, long, int, insn *, char *, long);
-static int regval (operand *o);
-static int matches (struct itemplate *, insn *);
-static ea *process_ea (operand *, ea *, int, int, int);
-static int chsize (operand *, int);
+static int regval (operand *o);
+static int matches (struct itemplate *, insn *);
+static ea * process_ea (operand *, ea *, int, int, int);
+static int chsize (operand *, int);
/*
* This routine wrappers the real output format's output routine,
* generator at the same time.
*/
static void out (long offset, long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
+ static long lineno;
+ static char *lnfname;
+
if ((type & OUT_TYPMASK) == OUT_ADDRESS) {
if (segment != NO_SEG || wrt != NO_SEG) {
/*
* OUT_ADDRESS, so there's no work to be done here.
*/
list->output (offset, data, type);
- } else {
+ }
+ else {
unsigned char p[4], *q = p;
/*
* This is a non-relocated address, and we're going to
if ((type & OUT_SIZMASK) == 4) {
WRITELONG (q, * (long *) data);
list->output (offset, p, OUT_RAWDATA+4);
- } else {
+ }
+ else {
WRITESHORT (q, * (long *) data);
list->output (offset, p, OUT_RAWDATA+2);
}
}
- } else if ((type & OUT_TYPMASK) == OUT_RAWDATA) {
+ }
+ else if ((type & OUT_TYPMASK) == OUT_RAWDATA) {
list->output (offset, data, type);
- } else if ((type & OUT_TYPMASK) == OUT_RESERVE) {
+ }
+ else if ((type & OUT_TYPMASK) == OUT_RESERVE) {
list->output (offset, NULL, type);
- } else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
+ }
+ else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
(type & OUT_TYPMASK) == OUT_REL4ADR) {
list->output (offset, data, type);
}
+ if (src_get(&lineno,&lnfname))
+ outfmt->current_dfmt->linenum(lnfname,lineno,segto);
+
outfmt->output (segto, data, type, segment, wrt);
}
long assemble (long segment, long offset, int bits,
insn *instruction, struct ofmt *output, efunc error,
- ListGen *listgen) {
- int j, size_prob;
- long insn_end, itimes;
- long start = offset;
+ ListGen *listgen)
+{
struct itemplate *temp;
+ int j;
+ int size_prob;
+ long insn_end;
+ long itimes;
+ long start = offset;
+ long wsize = 0; /* size for DB etc. */
errfunc = error; /* to pass to other functions */
outfmt = output; /* likewise */
list = listgen; /* and again */
- if (instruction->opcode == -1)
- return 0;
-
- if (instruction->opcode == I_DB ||
- instruction->opcode == I_DW ||
- instruction->opcode == I_DD ||
- instruction->opcode == I_DQ ||
- instruction->opcode == I_DT) {
- extop *e;
- long wsize = 0; /* placate gcc */
- long t = instruction->times;
-
- switch (instruction->opcode) {
- case I_DB: wsize = 1; break;
- case I_DW: wsize = 2; break;
- case I_DD: wsize = 4; break;
- case I_DQ: wsize = 8; break;
- case I_DT: wsize = 10; break;
- }
+ switch (instruction->opcode)
+ {
+ case -1: return 0;
+ case I_DB: wsize = 1; break;
+ case I_DW: wsize = 2; break;
+ case I_DD: wsize = 4; break;
+ case I_DQ: wsize = 8; break;
+ case I_DT: wsize = 10; break;
+ }
- while (t--) {
- for (e = instruction->eops; e; e = e->next) {
- if (e->type == EOT_DB_NUMBER) {
+ if (wsize) {
+ extop * e;
+ long t = instruction->times;
+ if (t < 0)
+ errfunc(ERR_PANIC, "instruction->times < 0 (%ld) in assemble()",t);
+
+ while (t--) /* repeat TIMES times */
+ {
+ for (e = instruction->eops; e; e = e->next)
+ {
+ if (e->type == EOT_DB_NUMBER)
+ {
if (wsize == 1) {
if (e->segment != NO_SEG)
errfunc (ERR_NONFATAL,
"one-byte relocation attempted");
else {
- unsigned char c = e->offset;
- out (offset, segment, &c, OUT_RAWDATA+1,
+ out (offset, segment, &e->offset, OUT_RAWDATA+1,
NO_SEG, NO_SEG);
}
- } else if (wsize > 5) {
+ }
+ else if (wsize > 5) {
errfunc (ERR_NONFATAL, "integer supplied to a D%c"
" instruction", wsize==8 ? 'Q' : 'T');
- } else
+ }
+ else
out (offset, segment, &e->offset,
OUT_ADDRESS+wsize, e->segment,
e->wrt);
offset += wsize;
- } else if (e->type == EOT_DB_STRING) {
+ }
+ else if (e->type == EOT_DB_STRING)
+ {
int align;
- align = (-e->stringlen) % wsize;
- if (align < 0)
- align += wsize;
out (offset, segment, e->stringval,
OUT_RAWDATA+e->stringlen, NO_SEG, NO_SEG);
- if (align)
- out (offset, segment, "\0\0\0\0",
+ align = e->stringlen % wsize;
+
+ if (align) {
+ align = wsize - align;
+ out (offset, segment, "\0\0\0\0\0\0\0\0",
OUT_RAWDATA+align, NO_SEG, NO_SEG);
+ }
offset += e->stringlen + align;
}
}
- if (t > 0 && t == instruction->times-1) {
+ if (t > 0 && t == instruction->times-1)
+ {
/*
* Dummy call to list->output to give the offset to the
* listing module.
return offset - start;
}
- if (instruction->opcode == I_INCBIN) {
+ if (instruction->opcode == I_INCBIN)
+ {
static char fname[FILENAME_MAX];
- FILE *fp;
- long len;
+ FILE * fp;
+ long len;
len = FILENAME_MAX-1;
if (len > instruction->eops->stringlen)
len = instruction->eops->stringlen;
strncpy (fname, instruction->eops->stringval, len);
fname[len] = '\0';
- if (!(fp = fopen(fname, "rb")))
+
+ if ( (fp = fopen(fname, "rb")) == NULL)
error (ERR_NONFATAL, "`incbin': unable to open file `%s'", fname);
else if (fseek(fp, 0L, SEEK_END) < 0)
error (ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
fname);
- else {
+ else
+ {
static char buf[2048];
long t = instruction->times;
- long l;
+ long base = 0;
len = ftell (fp);
if (instruction->eops->next) {
- len -= instruction->eops->next->offset;
+ base = instruction->eops->next->offset;
+ len -= base;
if (instruction->eops->next->next &&
len > instruction->eops->next->next->offset)
len = instruction->eops->next->next->offset;
*/
list->output (offset, NULL, OUT_RAWDATA);
list->uplevel(LIST_INCBIN);
- while (t--) {
- fseek (fp,
- (instruction->eops->next ?
- instruction->eops->next->offset : 0),
- SEEK_SET);
+ while (t--)
+ {
+ long l;
+
+ fseek (fp, base, SEEK_SET);
l = len;
while (l > 0) {
long m = fread (buf, 1, (l>sizeof(buf)?sizeof(buf):l),
*/
error (ERR_NONFATAL, "`incbin': unexpected EOF while"
" reading file `%s'", fname);
- return 0; /* it doesn't much matter... */
+ t=0; /* Try to exit cleanly */
+ break;
}
out (offset, segment, buf, OUT_RAWDATA+m,
NO_SEG, NO_SEG);
temp = nasm_instructions[instruction->opcode];
while (temp->opcode != -1) {
int m = matches (temp, instruction);
- if (m == 100) { /* matches! */
+
+ if (m == 100) /* matches! */
+ {
char *codes = temp->code;
long insn_size = calcsize(segment, offset, bits,
instruction, codes);
else while (itimes--) {
insn_end = offset + insn_size;
for (j=0; j<instruction->nprefix; j++) {
- unsigned char c;
+ unsigned char c=0;
switch (instruction->prefixes[j]) {
case P_LOCK:
c = 0xF0; break;
case R_GS: c = 0x65; break;
case R_SS: c = 0x36; break;
case P_A16:
- if (bits == 16)
- c = 0; /* no prefix */
- else
+ if (bits != 16)
c = 0x67;
break;
case P_A32:
- if (bits == 32)
- c = 0; /* no prefix */
- else
+ if (bits != 32)
c = 0x67;
break;
case P_O16:
- if (bits == 16)
- c = 0; /* no prefix */
- else
+ if (bits != 16)
c = 0x66;
break;
case P_O32:
- if (bits == 32)
- c = 0; /* no prefix */
- else
+ if (bits != 32)
c = 0x66;
break;
default:
error (ERR_PANIC,
"invalid instruction prefix");
}
- if (c != 0)
+ if (c != 0) {
out (offset, segment, &c, OUT_RAWDATA+1,
NO_SEG, NO_SEG);
- offset++;
+ offset++;
+ }
}
gencode (segment, offset, bits, instruction, codes, insn_end);
offset += insn_size;
}
temp++;
}
+
if (temp->opcode == -1) { /* didn't match any instruction */
if (size_prob == 1) /* would have matched, but for size */
error (ERR_NONFATAL, "operation size not specified");
}
long insn_size (long segment, long offset, int bits,
- insn *instruction, efunc error) {
+ insn *instruction, efunc error)
+{
struct itemplate *temp;
errfunc = error; /* to pass to other functions */
instruction->opcode == I_DW ||
instruction->opcode == I_DD ||
instruction->opcode == I_DQ ||
- instruction->opcode == I_DT) {
+ instruction->opcode == I_DT)
+ {
extop *e;
long isize, osize, wsize = 0; /* placate gcc */
isize = 0;
- switch (instruction->opcode) {
+ switch (instruction->opcode)
+ {
case I_DB: wsize = 1; break;
case I_DW: wsize = 2; break;
case I_DD: wsize = 4; break;
case I_DT: wsize = 10; break;
}
- for (e = instruction->eops; e; e = e->next) {
+ for (e = instruction->eops; e; e = e->next)
+ {
long align;
osize = 0;
return isize * instruction->times;
}
- if (instruction->opcode == I_INCBIN) {
- char fname[FILENAME_MAX];
- FILE *fp;
- long len;
+ if (instruction->opcode == I_INCBIN)
+ {
+ char fname[FILENAME_MAX];
+ FILE * fp;
+ long len;
len = FILENAME_MAX-1;
if (len > instruction->eops->stringlen)
len = instruction->eops->stringlen;
strncpy (fname, instruction->eops->stringval, len);
fname[len] = '\0';
- if (!(fp = fopen(fname, "rb")))
+ if ( (fp = fopen(fname, "rb")) == NULL )
error (ERR_NONFATAL, "`incbin': unable to open file `%s'", fname);
else if (fseek(fp, 0L, SEEK_END) < 0)
error (ERR_NONFATAL, "`incbin': unable to seek on file `%s'",
fname);
- else {
+ else
+ {
len = ftell (fp);
fclose (fp);
- if (instruction->eops->next) {
+ if (instruction->eops->next)
+ {
len -= instruction->eops->next->offset;
if (instruction->eops->next->next &&
len > instruction->eops->next->next->offset)
+ {
len = instruction->eops->next->next->offset;
+ }
}
return instruction->times * len;
}
while (temp->opcode != -1) {
if (matches(temp, instruction) == 100) {
/* we've matched an instruction. */
- long isize;
- char *codes = temp->code;
- int j;
+ long isize;
+ char * codes = temp->code;
+ int j;
isize = calcsize(segment, offset, bits, instruction, codes);
if (isize < 0)
return -1;
- for (j = 0; j < instruction->nprefix; j++) {
+ for (j = 0; j < instruction->nprefix; j++)
+ {
if ((instruction->prefixes[j] != P_A16 &&
instruction->prefixes[j] != P_O16 && bits==16) ||
(instruction->prefixes[j] != P_A32 &&
instruction->prefixes[j] != P_O32 && bits==32))
+ {
isize++;
+ }
}
return isize * instruction->times;
}
}
static long calcsize (long segment, long offset, int bits,
- insn *ins, char *codes) {
- long length = 0;
- unsigned char c;
+ insn *ins, char *codes)
+{
+ long length = 0;
+ unsigned char c;
+
+ (void) segment; /* Don't warn that this parameter is unused */
+ (void) offset; /* Don't warn that this parameter is unused */
while (*codes) switch (c = *codes++) {
case 01: case 02: case 03:
}
static void gencode (long segment, long offset, int bits,
- insn *ins, char *codes, long insn_end) {
+ insn *ins, char *codes, long insn_end)
+{
static char condval[] = { /* conditional opcodes */
0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xF, 0xD, 0xC, 0xE, 0x6, 0x2,
0x3, 0x7, 0x3, 0x5, 0xE, 0xC, 0xD, 0xF, 0x1, 0xB, 0x9, 0x5,
0x0, 0xA, 0xA, 0xB, 0x8, 0x4
};
- unsigned char c, bytes[4];
- long data, size;
-
- while (*codes) switch (c = *codes++) {
- case 01: case 02: case 03:
- out (offset, segment, codes, OUT_RAWDATA+c, NO_SEG, NO_SEG);
- codes += c;
- offset += c;
- break;
- case 04: case 06:
- switch (ins->oprs[0].basereg) {
- case R_CS: bytes[0] = 0x0E + (c == 0x04 ? 1 : 0); break;
- case R_DS: bytes[0] = 0x1E + (c == 0x04 ? 1 : 0); break;
- case R_ES: bytes[0] = 0x06 + (c == 0x04 ? 1 : 0); break;
- case R_SS: bytes[0] = 0x16 + (c == 0x04 ? 1 : 0); break;
- default:
- errfunc (ERR_PANIC, "bizarre 8086 segment register received");
- }
- out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- offset++;
- break;
- case 05: case 07:
- switch (ins->oprs[0].basereg) {
- case R_FS: bytes[0] = 0xA0 + (c == 0x05 ? 1 : 0); break;
- case R_GS: bytes[0] = 0xA8 + (c == 0x05 ? 1 : 0); break;
- default:
- errfunc (ERR_PANIC, "bizarre 386 segment register received");
- }
- out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- offset++;
- break;
- case 010: case 011: case 012:
- bytes[0] = *codes++ + regval(&ins->oprs[c-010]);
- out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- offset += 1;
- break;
- case 017:
- bytes[0] = 0;
- out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- offset += 1;
- break;
- case 014: case 015: case 016:
- if (ins->oprs[c-014].offset < -128 || ins->oprs[c-014].offset > 127)
- errfunc (ERR_WARNING, "signed byte value exceeds bounds");
- if (ins->oprs[c-014].segment != NO_SEG) {
- data = ins->oprs[c-014].offset;
- out (offset, segment, &data, OUT_ADDRESS+1,
- ins->oprs[c-014].segment, ins->oprs[c-014].wrt);
- } else {
- bytes[0] = ins->oprs[c-014].offset;
+ unsigned char c;
+ unsigned char bytes[4];
+ long data, size;
+
+ while (*codes)
+ switch (c = *codes++)
+ {
+ case 01: case 02: case 03:
+ out (offset, segment, codes, OUT_RAWDATA+c, NO_SEG, NO_SEG);
+ codes += c;
+ offset += c;
+ break;
+
+ case 04: case 06:
+ switch (ins->oprs[0].basereg)
+ {
+ case R_CS:
+ bytes[0] = 0x0E + (c == 0x04 ? 1 : 0); break;
+ case R_DS:
+ bytes[0] = 0x1E + (c == 0x04 ? 1 : 0); break;
+ case R_ES:
+ bytes[0] = 0x06 + (c == 0x04 ? 1 : 0); break;
+ case R_SS:
+ bytes[0] = 0x16 + (c == 0x04 ? 1 : 0); break;
+ default:
+ errfunc (ERR_PANIC, "bizarre 8086 segment register received");
+ }
out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- }
- offset += 1;
- break;
- case 020: case 021: case 022:
- if (ins->oprs[c-020].offset < -256 || ins->oprs[c-020].offset > 255)
- errfunc (ERR_WARNING, "byte value exceeds bounds");
- if (ins->oprs[c-020].segment != NO_SEG) {
- data = ins->oprs[c-020].offset;
- out (offset, segment, &data, OUT_ADDRESS+1,
- ins->oprs[c-020].segment, ins->oprs[c-020].wrt);
- } else {
- bytes[0] = ins->oprs[c-020].offset;
+ offset++;
+ break;
+
+ case 05: case 07:
+ switch (ins->oprs[0].basereg) {
+ case R_FS: bytes[0] = 0xA0 + (c == 0x05 ? 1 : 0); break;
+ case R_GS: bytes[0] = 0xA8 + (c == 0x05 ? 1 : 0); break;
+ default:
+ errfunc (ERR_PANIC, "bizarre 386 segment register received");
+ }
out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- }
- offset += 1;
- break;
- case 024: case 025: case 026:
- if (ins->oprs[c-024].offset < 0 || ins->oprs[c-024].offset > 255)
- errfunc (ERR_WARNING, "unsigned byte value exceeds bounds");
- if (ins->oprs[c-024].segment != NO_SEG) {
- data = ins->oprs[c-024].offset;
- out (offset, segment, &data, OUT_ADDRESS+1,
- ins->oprs[c-024].segment, ins->oprs[c-024].wrt);
- } else {
- bytes[0] = ins->oprs[c-024].offset;
+ offset++;
+ break;
+
+ case 010: case 011: case 012:
+ bytes[0] = *codes++ + regval(&ins->oprs[c-010]);
out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- }
- offset += 1;
- break;
- case 030: case 031: case 032:
- if (ins->oprs[c-030].segment == NO_SEG &&
- ins->oprs[c-030].wrt == NO_SEG &&
- (ins->oprs[c-030].offset < -65536L ||
- ins->oprs[c-030].offset > 65535L))
- errfunc (ERR_WARNING, "word value exceeds bounds");
- data = ins->oprs[c-030].offset;
- out (offset, segment, &data, OUT_ADDRESS+2,
- ins->oprs[c-030].segment, ins->oprs[c-030].wrt);
- offset += 2;
- break;
- case 034: case 035: case 036:
- data = ins->oprs[c-034].offset;
- size = ((ins->oprs[c-034].addr_size ?
- ins->oprs[c-034].addr_size : bits) == 16 ? 2 : 4);
- if (size==16 && (data < -65536L || data > 65535L))
- errfunc (ERR_WARNING, "word value exceeds bounds");
- out (offset, segment, &data, OUT_ADDRESS+size,
- ins->oprs[c-034].segment, ins->oprs[c-034].wrt);
- offset += size;
- break;
- case 037:
- if (ins->oprs[0].segment == NO_SEG)
- errfunc (ERR_NONFATAL, "value referenced by FAR is not"
- " relocatable");
- data = 0L;
- out (offset, segment, &data, OUT_ADDRESS+2,
- outfmt->segbase(1+ins->oprs[0].segment),
- ins->oprs[0].wrt);
- offset += 2;
- break;
- case 040: case 041: case 042:
- data = ins->oprs[c-040].offset;
- out (offset, segment, &data, OUT_ADDRESS+4,
- ins->oprs[c-040].segment, ins->oprs[c-040].wrt);
- offset += 4;
- break;
- case 050: case 051: case 052:
- if (ins->oprs[c-050].segment != segment)
- errfunc (ERR_NONFATAL, "short relative jump outside segment");
- data = ins->oprs[c-050].offset - insn_end;
- if (data > 127 || data < -128)
- errfunc (ERR_NONFATAL, "short jump is out of range");
- bytes[0] = data;
- out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
- offset += 1;
- break;
- case 060: case 061: case 062:
- if (ins->oprs[c-060].segment != segment) {
- data = ins->oprs[c-060].offset;
- out (offset, segment, &data, OUT_REL2ADR+insn_end-offset,
- ins->oprs[c-060].segment, ins->oprs[c-060].wrt);
- } else {
- data = ins->oprs[c-060].offset - insn_end;
- out (offset, segment, &data,
- OUT_ADDRESS+2, NO_SEG, NO_SEG);
- }
- offset += 2;
- break;
- case 064: case 065: case 066:
- size = ((ins->oprs[c-064].addr_size ?
- ins->oprs[c-064].addr_size : bits) == 16 ? 2 : 4);
- if (ins->oprs[c-064].segment != segment) {
- data = ins->oprs[c-064].offset;
- size = (bits == 16 ? OUT_REL2ADR : OUT_REL4ADR);
- out (offset, segment, &data, size+insn_end-offset,
- ins->oprs[c-064].segment, ins->oprs[c-064].wrt);
- size = (bits == 16 ? 2 : 4);
- } else {
- data = ins->oprs[c-064].offset - insn_end;
- out (offset, segment, &data,
- OUT_ADDRESS+size, NO_SEG, NO_SEG);
- }
- offset += size;
- break;
- case 070: case 071: case 072:
- if (ins->oprs[c-070].segment != segment) {
- data = ins->oprs[c-070].offset;
- out (offset, segment, &data, OUT_REL4ADR+insn_end-offset,
- ins->oprs[c-070].segment, ins->oprs[c-070].wrt);
- } else {
- data = ins->oprs[c-070].offset - insn_end;
- out (offset, segment, &data,
- OUT_ADDRESS+4, NO_SEG, NO_SEG);
- }
- offset += 4;
- break;
- case 0300: case 0301: case 0302:
- if (chsize (&ins->oprs[c-0300], bits)) {
- *bytes = 0x67;
- out (offset, segment, bytes,
- OUT_RAWDATA+1, NO_SEG, NO_SEG);
offset += 1;
- } else
- offset += 0;
- break;
- case 0310:
- if (bits==32) {
- *bytes = 0x67;
- out (offset, segment, bytes,
- OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ break;
+
+ case 017:
+ bytes[0] = 0;
+ out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
offset += 1;
- } else
- offset += 0;
- break;
- case 0311:
- if (bits==16) {
- *bytes = 0x67;
- out (offset, segment, bytes,
- OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ break;
+
+ case 014: case 015: case 016:
+ if (ins->oprs[c-014].offset < -128
+ || ins->oprs[c-014].offset > 127)
+ {
+ errfunc (ERR_WARNING, "signed byte value exceeds bounds");
+ }
+
+ if (ins->oprs[c-014].segment != NO_SEG)
+ {
+ data = ins->oprs[c-014].offset;
+ out (offset, segment, &data, OUT_ADDRESS+1,
+ ins->oprs[c-014].segment, ins->oprs[c-014].wrt);
+ }
+ else {
+ bytes[0] = ins->oprs[c-014].offset;
+ out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ }
offset += 1;
- } else
- offset += 0;
- break;
- case 0312:
- break;
- case 0320:
- if (bits==32) {
- *bytes = 0x66;
- out (offset, segment, bytes,
- OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ break;
+
+ case 020: case 021: case 022:
+ if (ins->oprs[c-020].offset < -256
+ || ins->oprs[c-020].offset > 255)
+ {
+ errfunc (ERR_WARNING, "byte value exceeds bounds");
+ }
+ if (ins->oprs[c-020].segment != NO_SEG) {
+ data = ins->oprs[c-020].offset;
+ out (offset, segment, &data, OUT_ADDRESS+1,
+ ins->oprs[c-020].segment, ins->oprs[c-020].wrt);
+ }
+ else {
+ bytes[0] = ins->oprs[c-020].offset;
+ out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ }
offset += 1;
- } else
- offset += 0;
- break;
- case 0321:
- if (bits==16) {
- *bytes = 0x66;
- out (offset, segment, bytes,
- OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ break;
+
+ case 024: case 025: case 026:
+ if (ins->oprs[c-024].offset < 0 || ins->oprs[c-024].offset > 255)
+ errfunc (ERR_WARNING, "unsigned byte value exceeds bounds");
+ if (ins->oprs[c-024].segment != NO_SEG) {
+ data = ins->oprs[c-024].offset;
+ out (offset, segment, &data, OUT_ADDRESS+1,
+ ins->oprs[c-024].segment, ins->oprs[c-024].wrt);
+ }
+ else {
+ bytes[0] = ins->oprs[c-024].offset;
+ out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ }
offset += 1;
- } else
- offset += 0;
- break;
- case 0322:
- break;
- case 0330:
- *bytes = *codes++ + condval[ins->condition];
- out (offset, segment, bytes,
- OUT_RAWDATA+1, NO_SEG, NO_SEG);
- offset += 1;
- break;
- case 0340: case 0341: case 0342:
- if (ins->oprs[0].segment != NO_SEG)
- errfunc (ERR_PANIC, "non-constant BSS size in pass two");
- else {
- long size = ins->oprs[0].offset << (c-0340);
- if (size > 0)
- out (offset, segment, NULL,
- OUT_RESERVE+size, NO_SEG, NO_SEG);
+ break;
+
+ case 030: case 031: case 032:
+ if (ins->oprs[c-030].segment == NO_SEG &&
+ ins->oprs[c-030].wrt == NO_SEG &&
+ (ins->oprs[c-030].offset < -65536L ||
+ ins->oprs[c-030].offset > 65535L))
+ {
+ errfunc (ERR_WARNING, "word value exceeds bounds");
+ }
+ data = ins->oprs[c-030].offset;
+ out (offset, segment, &data, OUT_ADDRESS+2,
+ ins->oprs[c-030].segment, ins->oprs[c-030].wrt);
+ offset += 2;
+ break;
+
+ case 034: case 035: case 036:
+ data = ins->oprs[c-034].offset;
+ size = ((ins->oprs[c-034].addr_size ?
+ ins->oprs[c-034].addr_size : bits) == 16 ? 2 : 4);
+ if (size==16 && (data < -65536L || data > 65535L))
+ errfunc (ERR_WARNING, "word value exceeds bounds");
+ out (offset, segment, &data, OUT_ADDRESS+size,
+ ins->oprs[c-034].segment, ins->oprs[c-034].wrt);
offset += size;
- }
- break;
- default: /* can't do it by 'case' statements */
- if (c>=0100 && c<=0277) { /* it's an EA */
- ea ea_data;
- int rfield;
- unsigned char *p;
- long s;
-
- if (c<=0177) /* pick rfield from operand b */
- rfield = regval (&ins->oprs[c&7]);
- else /* rfield is constant */
- rfield = c & 7;
- if (!process_ea (&ins->oprs[(c>>3)&7], &ea_data, bits, rfield,
- ins->forw_ref))
- errfunc (ERR_NONFATAL, "invalid effective address");
+ break;
+
+ case 037:
+ if (ins->oprs[0].segment == NO_SEG)
+ errfunc (ERR_NONFATAL, "value referenced by FAR is not"
+ " relocatable");
+ data = 0L;
+ out (offset, segment, &data, OUT_ADDRESS+2,
+ outfmt->segbase(1+ins->oprs[0].segment),
+ ins->oprs[0].wrt);
+ offset += 2;
+ break;
- p = bytes;
- *p++ = ea_data.modrm;
- if (ea_data.sib_present)
- *p++ = ea_data.sib;
- /*
- * the cast in the next line is to placate MS C...
- */
- out (offset, segment, bytes, OUT_RAWDATA+(long)(p-bytes),
- NO_SEG, NO_SEG);
- s = p-bytes;
+ case 040: case 041: case 042:
+ data = ins->oprs[c-040].offset;
+ out (offset, segment, &data, OUT_ADDRESS+4,
+ ins->oprs[c-040].segment, ins->oprs[c-040].wrt);
+ offset += 4;
+ break;
+
+ case 050: case 051: case 052:
+ if (ins->oprs[c-050].segment != segment)
+ errfunc (ERR_NONFATAL, "short relative jump outside segment");
+ data = ins->oprs[c-050].offset - insn_end;
+ if (data > 127 || data < -128)
+ errfunc (ERR_NONFATAL, "short jump is out of range");
+ bytes[0] = data;
+ out (offset, segment, bytes, OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ break;
- switch (ea_data.bytes) {
- case 0:
- break;
- case 1:
- if (ins->oprs[(c>>3)&7].segment != NO_SEG) {
- data = ins->oprs[(c>>3)&7].offset;
- out (offset, segment, &data, OUT_ADDRESS+1,
- ins->oprs[(c>>3)&7].segment,
- ins->oprs[(c>>3)&7].wrt);
- } else {
- *bytes = ins->oprs[(c>>3)&7].offset;
- out (offset, segment, bytes, OUT_RAWDATA+1,
- NO_SEG, NO_SEG);
- }
- s++;
- break;
- case 2:
- case 4:
- data = ins->oprs[(c>>3)&7].offset;
+ case 060: case 061: case 062:
+ if (ins->oprs[c-060].segment != segment) {
+ data = ins->oprs[c-060].offset;
+ out (offset, segment, &data, OUT_REL2ADR+insn_end-offset,
+ ins->oprs[c-060].segment, ins->oprs[c-060].wrt);
+ } else {
+ data = ins->oprs[c-060].offset - insn_end;
out (offset, segment, &data,
- OUT_ADDRESS+ea_data.bytes,
- ins->oprs[(c>>3)&7].segment, ins->oprs[(c>>3)&7].wrt);
- s += ea_data.bytes;
- break;
+ OUT_ADDRESS+2, NO_SEG, NO_SEG);
}
- offset += s;
- } else
- errfunc (ERR_PANIC, "internal instruction table corrupt"
+ offset += 2;
+ break;
+
+ case 064: case 065: case 066:
+ size = ((ins->oprs[c-064].addr_size ?
+ ins->oprs[c-064].addr_size : bits) == 16 ? 2 : 4);
+ if (ins->oprs[c-064].segment != segment) {
+ data = ins->oprs[c-064].offset;
+ size = (bits == 16 ? OUT_REL2ADR : OUT_REL4ADR);
+ out (offset, segment, &data, size+insn_end-offset,
+ ins->oprs[c-064].segment, ins->oprs[c-064].wrt);
+ size = (bits == 16 ? 2 : 4);
+ } else {
+ data = ins->oprs[c-064].offset - insn_end;
+ out (offset, segment, &data,
+ OUT_ADDRESS+size, NO_SEG, NO_SEG);
+ }
+ offset += size;
+ break;
+
+ case 070: case 071: case 072:
+ if (ins->oprs[c-070].segment != segment) {
+ data = ins->oprs[c-070].offset;
+ out (offset, segment, &data, OUT_REL4ADR+insn_end-offset,
+ ins->oprs[c-070].segment, ins->oprs[c-070].wrt);
+ } else {
+ data = ins->oprs[c-070].offset - insn_end;
+ out (offset, segment, &data,
+ OUT_ADDRESS+4, NO_SEG, NO_SEG);
+ }
+ offset += 4;
+ break;
+
+ case 0300: case 0301: case 0302:
+ if (chsize (&ins->oprs[c-0300], bits)) {
+ *bytes = 0x67;
+ out (offset, segment, bytes,
+ OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ } else
+ offset += 0;
+ break;
+
+ case 0310:
+ if (bits==32) {
+ *bytes = 0x67;
+ out (offset, segment, bytes,
+ OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ } else
+ offset += 0;
+ break;
+
+ case 0311:
+ if (bits==16) {
+ *bytes = 0x67;
+ out (offset, segment, bytes,
+ OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ } else
+ offset += 0;
+ break;
+
+ case 0312:
+ break;
+
+ case 0320:
+ if (bits==32) {
+ *bytes = 0x66;
+ out (offset, segment, bytes,
+ OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ } else
+ offset += 0;
+ break;
+
+ case 0321:
+ if (bits==16) {
+ *bytes = 0x66;
+ out (offset, segment, bytes,
+ OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ } else
+ offset += 0;
+ break;
+
+ case 0322:
+ break;
+
+ case 0330:
+ *bytes = *codes++ + condval[ins->condition];
+ out (offset, segment, bytes,
+ OUT_RAWDATA+1, NO_SEG, NO_SEG);
+ offset += 1;
+ break;
+
+ case 0340: case 0341: case 0342:
+ if (ins->oprs[0].segment != NO_SEG)
+ errfunc (ERR_PANIC, "non-constant BSS size in pass two");
+ else {
+ long size = ins->oprs[0].offset << (c-0340);
+ if (size > 0)
+ out (offset, segment, NULL,
+ OUT_RESERVE+size, NO_SEG, NO_SEG);
+ offset += size;
+ }
+ break;
+
+ default: /* can't do it by 'case' statements */
+ if (c>=0100 && c<=0277) { /* it's an EA */
+ ea ea_data;
+ int rfield;
+ unsigned char *p;
+ long s;
+
+ if (c<=0177) /* pick rfield from operand b */
+ rfield = regval (&ins->oprs[c&7]);
+ else /* rfield is constant */
+ rfield = c & 7;
+
+ if (!process_ea (&ins->oprs[(c>>3)&7], &ea_data, bits, rfield,
+ ins->forw_ref))
+ {
+ errfunc (ERR_NONFATAL, "invalid effective address");
+ }
+
+ p = bytes;
+ *p++ = ea_data.modrm;
+ if (ea_data.sib_present)
+ *p++ = ea_data.sib;
+
+ s = p-bytes;
+ out (offset, segment, bytes, OUT_RAWDATA + s,
+ NO_SEG, NO_SEG);
+
+ switch (ea_data.bytes) {
+ case 0:
+ break;
+ case 1:
+ if (ins->oprs[(c>>3)&7].segment != NO_SEG) {
+ data = ins->oprs[(c>>3)&7].offset;
+ out (offset, segment, &data, OUT_ADDRESS+1,
+ ins->oprs[(c>>3)&7].segment,
+ ins->oprs[(c>>3)&7].wrt);
+ } else {
+ *bytes = ins->oprs[(c>>3)&7].offset;
+ out (offset, segment, bytes, OUT_RAWDATA+1,
+ NO_SEG, NO_SEG);
+ }
+ s++;
+ break;
+ case 2:
+ case 4:
+ data = ins->oprs[(c>>3)&7].offset;
+ out (offset, segment, &data,
+ OUT_ADDRESS+ea_data.bytes,
+ ins->oprs[(c>>3)&7].segment, ins->oprs[(c>>3)&7].wrt);
+ s += ea_data.bytes;
+ break;
+ }
+ offset += s;
+ } else
+ errfunc (ERR_PANIC, "internal instruction table corrupt"
": instruction code 0x%02X given", c);
- }
+ }
}
-static int regval (operand *o) {
+static int regval (operand *o)
+{
switch (o->basereg) {
case R_EAX: case R_AX: case R_AL: case R_ES: case R_CR0: case R_DR0:
case R_ST0: case R_MM0:
}
}
-static int matches (struct itemplate *itemp, insn *instruction) {
+static int matches (struct itemplate *itemp, insn *instruction)
+{
int i, size, oprs, ret;
ret = 100;
for (i=0; i<itemp->operands; i++)
if (itemp->opd[i] & ~instruction->oprs[i].type ||
((itemp->opd[i] & SIZE_MASK) &&
- ((itemp->opd[i] ^ instruction->oprs[i].type) & SIZE_MASK))) {
+ ((itemp->opd[i] ^ instruction->oprs[i].type) & SIZE_MASK)))
+ {
if ((itemp->opd[i] & ~instruction->oprs[i].type & NON_SIZE) ||
(instruction->oprs[i].type & SIZE_MASK))
return 0;
}
static ea *process_ea (operand *input, ea *output, int addrbits, int rfield,
- int forw_ref) {
+ int forw_ref)
+{
if (!(REGISTER & ~input->type)) { /* it's a single register */
static int regs[] = {
R_MM0, R_EAX, R_AX, R_AL, R_MM1, R_ECX, R_CX, R_CL,
output->sib_present = FALSE;/* no SIB necessary */
output->bytes = 0; /* no offset necessary either */
output->modrm = 0xC0 | (rfield << 3) | (i/4);
- } else
+ }
+ else
return NULL;
} else { /* it's a memory reference */
if (input->basereg==-1 && (input->indexreg==-1 || input->scale==0)) {
output->sib_present = FALSE;
output->bytes = (addrbits==32 ? 4 : 2);
output->modrm = (addrbits==32 ? 5 : 6) | (rfield << 3);
- } else { /* it's an indirection */
+ }
+ else { /* it's an indirection */
int i=input->indexreg, b=input->basereg, s=input->scale;
long o=input->offset, seg=input->segment;
int hb=input->hintbase, ht=input->hinttype;
(o>=-128 && o<=127 && seg==NO_SEG && !forw_ref &&
!(input->eaflags & EAF_WORDOFFS))) {
mod = 1;
- } else
+ }
+ else
mod = 2;
output->sib_present = FALSE;
output->bytes = (b==-1 || mod==2 ? 4 : mod);
output->modrm = (mod<<6) | (rfield<<3) | rm;
- } else { /* we need a SIB */
+ }
+ else { /* we need a SIB */
int mod, scale, index, base;
switch (b) {
output->modrm = (mod<<6) | (rfield<<3) | 4;
output->sib = (scale<<6) | (index<<3) | base;
}
- } else { /* it's 16-bit */
+ }
+ else { /* it's 16-bit */
int mod, rm;
/* check all registers are BX, BP, SI or DI */
return output;
}
-static int chsize (operand *input, int addrbits) {
+static int chsize (operand *input, int addrbits)
+{
if (!(MEMORY & ~input->type)) {
int i=input->indexreg, b=input->basereg;
return (addrbits==16);
else
return (addrbits==32);
- } else
+ }
+ else
return 0;
}
#define SEG_NODISP 64
#define SEG_SIGNED 128
-static int whichreg(long regflags, int regval) {
+static int whichreg(long regflags, int regval)
+{
static int reg32[] = {
R_EAX, R_ECX, R_EDX, R_EBX, R_ESP, R_EBP, R_ESI, R_EDI };
static int reg16[] = {
return 0;
}
-static char *whichcond(int condval) {
+static char *whichcond(int condval)
+{
static int conds[] = {
C_O, C_NO, C_C, C_NC, C_Z, C_NZ, C_NA, C_A,
C_S, C_NS, C_PE, C_PO, C_L, C_NL, C_NG, C_G
* Process an effective address (ModRM) specification.
*/
static unsigned char *do_ea (unsigned char *data, int modrm, int asize,
- int segsize, operand *op) {
+ int segsize, operand *op)
+{
int mod, rm, scale, index, base;
mod = (modrm >> 6) & 03;
* stream in data. Return the number of bytes matched if so.
*/
static int matches (unsigned char *r, unsigned char *data, int asize,
- int osize, int segsize, insn *ins) {
- unsigned char *origdata = data;
- int a_used = FALSE, o_used = FALSE;
+ int osize, int segsize, insn *ins)
+{
+ unsigned char * origdata = data;
+ int a_used = FALSE, o_used = FALSE;
- while (*r) {
+ while (*r)
+ {
int c = *r++;
if (c >= 01 && c <= 03) {
while (c--)
}
long disasm (unsigned char *data, char *output, int segsize, long offset,
- int autosync) {
+ int autosync)
+{
struct itemplate **p;
int length = 0;
char *segover;
works = TRUE;
for (p = itable[*data]; *p; p++)
if ( (length = matches((unsigned char *)((*p)->code), data,
- asize, osize, segsize, &ins)) ) {
+ asize, osize, segsize, &ins)) )
+ {
works = TRUE;
/*
* Final check to make sure the types of r/m match up.
((((*p)->opd[i] & (REGISTER | FPUREG)) ||
(ins.oprs[i].segment & SEG_RMREG)) &&
!whichreg ((*p)->opd[i], ins.oprs[i].basereg)))
-
+ {
works = FALSE;
+ /*
+ * FIXME: can we do a break here?
+ */
+ }
+
if (works)
break;
}
+
if (!length || !works)
return 0; /* no instruction was matched */
colon = FALSE;
if (((*p)->opd[i] & (REGISTER | FPUREG)) ||
- (ins.oprs[i].segment & SEG_RMREG)) {
+ (ins.oprs[i].segment & SEG_RMREG))
+ {
ins.oprs[i].basereg = whichreg ((*p)->opd[i],
ins.oprs[i].basereg);
+ if ( (*p)->opd[i] & TO )
+ slen += sprintf(output+slen, "to ");
slen += sprintf(output+slen, "%s",
reg_names[ins.oprs[i].basereg-EXPR_REG_START]);
} else if (!(UNITY & ~(*p)->opd[i])) {
return length;
}
-long eatbyte (unsigned char *data, char *output) {
+long eatbyte (unsigned char *data, char *output)
+{
sprintf(output, "db 0x%02X", *data);
return 1;
}
#include "nasm.h"
#include "nasmlib.h"
#include "eval.h"
+#include "labels.h"
-static expr **tempexprs = NULL;
-static int ntempexprs, tempexprs_size = 0;
#define TEMPEXPRS_DELTA 128
-
-static expr *tempexpr;
-static int ntempexpr, tempexpr_size;
#define TEMPEXPR_DELTA 8
-static scanner scan;
+static scanner scan; /* Address of scanner routine */
+static efunc error; /* Address of error reporting routine */
+static lfunc labelfunc; /* Address of label routine */
+
+static struct ofmt *outfmt; /* Structure of addresses of output routines */
+
+static expr **tempexprs = NULL;
+static int ntempexprs;
+static int tempexprs_size = 0;
+
+static expr *tempexpr;
+static int ntempexpr;
+static int tempexpr_size;
+
+static struct tokenval *tokval; /* The current token */
+static int i; /* The t_type of tokval */
+
static void *scpriv;
-static struct tokenval *tokval;
-static efunc error;
-static int i;
-static int seg, ofs;
-static char *label = NULL, special_empty_string[] = "";
-static lfunc labelfunc;
-static struct ofmt *outfmt;
-static int *forward;
+static loc_t *location; /* Pointer to current line's segment,offset */
+static int *opflags;
static struct eval_hints *hint;
/*
+ * Unimportant cleanup is done to avoid confusing people who are trying
+ * to debug real memory leaks
+ */
+void eval_cleanup(void)
+{
+ while (ntempexprs)
+ nasm_free (tempexprs[--ntempexprs]);
+ nasm_free (tempexprs);
+}
+
+/*
* Construct a temporary expression.
*/
-static void begintemp(void) {
+static void begintemp(void)
+{
tempexpr = NULL;
tempexpr_size = ntempexpr = 0;
}
-static void addtotemp(long type, long value) {
+static void addtotemp(long type, long value)
+{
while (ntempexpr >= tempexpr_size) {
tempexpr_size += TEMPEXPR_DELTA;
tempexpr = nasm_realloc(tempexpr,
tempexpr[ntempexpr++].value = value;
}
-static expr *finishtemp(void) {
+static expr *finishtemp(void)
+{
addtotemp (0L, 0L); /* terminate */
while (ntempexprs >= tempexprs_size) {
tempexprs_size += TEMPEXPRS_DELTA;
* absolute segment types: we preserve them during addition _only_
* if one of the segments is a truly pure scalar.
*/
-static expr *add_vectors(expr *p, expr *q) {
+static expr *add_vectors(expr *p, expr *q)
+{
int preserve;
preserve = is_really_simple(p) || is_really_simple(q);
while (p->type && q->type &&
p->type < EXPR_SEGBASE+SEG_ABS &&
- q->type < EXPR_SEGBASE+SEG_ABS) {
+ q->type < EXPR_SEGBASE+SEG_ABS)
+ {
int lasttype;
if (p->type > q->type) {
addtotemp(p->type, p->value);
lasttype = p++->type;
} else { /* *p and *q have same type */
- addtotemp(p->type, p->value + q->value);
+ long sum = p->value + q->value;
+ if (sum)
+ addtotemp(p->type, sum);
lasttype = p->type;
p++, q++;
}
}
}
while (p->type &&
- (preserve || p->type < EXPR_SEGBASE+SEG_ABS)) {
+ (preserve || p->type < EXPR_SEGBASE+SEG_ABS))
+ {
addtotemp(p->type, p->value);
p++;
}
while (q->type &&
- (preserve || q->type < EXPR_SEGBASE+SEG_ABS)) {
+ (preserve || q->type < EXPR_SEGBASE+SEG_ABS))
+ {
addtotemp(q->type, q->value);
q++;
}
* multiplied. This allows [eax*1+ebx] to hint EBX rather than EAX
* as the base register.
*/
-static expr *scalar_mult(expr *vect, long scalar, int affect_hints) {
+static expr *scalar_mult(expr *vect, long scalar, int affect_hints)
+{
expr *p = vect;
while (p->type && p->type < EXPR_SEGBASE+SEG_ABS) {
return vect;
}
-static expr *scalarvect (long scalar) {
+static expr *scalarvect (long scalar)
+{
begintemp();
addtotemp(EXPR_SIMPLE, scalar);
return finishtemp();
}
-static expr *unknown_expr (void) {
+static expr *unknown_expr (void)
+{
begintemp();
addtotemp(EXPR_UNKNOWN, 1L);
return finishtemp();
* value. Return NULL, as usual, if an error occurs. Report the
* error too.
*/
-static expr *segment_part (expr *e) {
+static expr *segment_part (expr *e)
+{
long seg;
if (is_unknown(e))
static expr *(*bexpr)(int);
-static expr *rexp0(int critical) {
+static expr *rexp0(int critical)
+{
expr *e, *f;
e = rexp1(critical);
if (!e)
return NULL;
- while (i == TOKEN_DBL_OR) {
+
+ while (i == TOKEN_DBL_OR)
+ {
i = scan(scpriv, tokval);
f = rexp1(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
- error(ERR_NONFATAL, "`|' operator may only be applied to"
- " scalar values");
- }
+ !(is_simple(f) || is_just_unknown(f)))
+ {
+ error(ERR_NONFATAL, "`|' operator may only be applied to"
+ " scalar values");
+ }
+
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
return e;
}
-static expr *rexp1(int critical) {
+static expr *rexp1(int critical)
+{
expr *e, *f;
e = rexp2(critical);
if (!e)
return NULL;
- while (i == TOKEN_DBL_XOR) {
+
+ while (i == TOKEN_DBL_XOR)
+ {
i = scan(scpriv, tokval);
f = rexp2(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
+ !(is_simple(f) || is_just_unknown(f)))
+ {
error(ERR_NONFATAL, "`^' operator may only be applied to"
" scalar values");
}
+
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
return e;
}
-static expr *rexp2(int critical) {
+static expr *rexp2(int critical)
+{
expr *e, *f;
e = rexp3(critical);
if (!e)
return NULL;
- while (i == TOKEN_DBL_AND) {
+ while (i == TOKEN_DBL_AND)
+ {
i = scan(scpriv, tokval);
f = rexp3(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
+ !(is_simple(f) || is_just_unknown(f)))
+ {
error(ERR_NONFATAL, "`&' operator may only be applied to"
" scalar values");
}
return e;
}
-static expr *rexp3(int critical) {
+static expr *rexp3(int critical)
+{
expr *e, *f;
long v;
e = expr0(critical);
if (!e)
return NULL;
+
while (i == TOKEN_EQ || i == TOKEN_LT || i == TOKEN_GT ||
- i == TOKEN_NE || i == TOKEN_LE || i == TOKEN_GE) {
+ i == TOKEN_NE || i == TOKEN_LE || i == TOKEN_GE)
+ {
int j = i;
i = scan(scpriv, tokval);
f = expr0(critical);
if (!f)
return NULL;
+
e = add_vectors (e, scalar_mult(f, -1L, FALSE));
- switch (j) {
+
+ switch (j)
+ {
case TOKEN_EQ: case TOKEN_NE:
if (is_unknown(e))
v = -1; /* means unknown */
}
break;
}
+
if (v == -1)
e = unknown_expr();
else
return e;
}
-static expr *expr0(int critical) {
+static expr *expr0(int critical)
+{
expr *e, *f;
e = expr1(critical);
if (!e)
return NULL;
- while (i == '|') {
+
+ while (i == '|')
+ {
i = scan(scpriv, tokval);
f = expr1(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
- error(ERR_NONFATAL, "`|' operator may only be applied to"
- " scalar values");
- }
+ !(is_simple(f) || is_just_unknown(f)))
+ {
+ error(ERR_NONFATAL, "`|' operator may only be applied to"
+ " scalar values");
+ }
if (is_just_unknown(e) || is_just_unknown(f))
e = unknown_expr();
else
return e;
}
-static expr *expr1(int critical) {
+static expr *expr1(int critical)
+{
expr *e, *f;
e = expr2(critical);
if (!e)
return NULL;
+
while (i == '^') {
i = scan(scpriv, tokval);
f = expr2(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
+ !(is_simple(f) || is_just_unknown(f)))
+ {
error(ERR_NONFATAL, "`^' operator may only be applied to"
" scalar values");
}
return e;
}
-static expr *expr2(int critical) {
+static expr *expr2(int critical)
+{
expr *e, *f;
e = expr3(critical);
if (!e)
return NULL;
+
while (i == '&') {
i = scan(scpriv, tokval);
f = expr3(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
+ !(is_simple(f) || is_just_unknown(f)))
+ {
error(ERR_NONFATAL, "`&' operator may only be applied to"
" scalar values");
}
return e;
}
-static expr *expr3(int critical) {
+static expr *expr3(int critical)
+{
expr *e, *f;
e = expr4(critical);
if (!e)
return NULL;
- while (i == TOKEN_SHL || i == TOKEN_SHR) {
+
+ while (i == TOKEN_SHL || i == TOKEN_SHR)
+ {
int j = i;
i = scan(scpriv, tokval);
f = expr4(critical);
if (!f)
return NULL;
if (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f))) {
+ !(is_simple(f) || is_just_unknown(f)))
+ {
error(ERR_NONFATAL, "shift operator may only be applied to"
" scalar values");
} else if (is_just_unknown(e) || is_just_unknown(f)) {
return e;
}
-static expr *expr4(int critical) {
+static expr *expr4(int critical)
+{
expr *e, *f;
e = expr5(critical);
if (!e)
return NULL;
- while (i == '+' || i == '-') {
+ while (i == '+' || i == '-')
+ {
int j = i;
i = scan(scpriv, tokval);
f = expr5(critical);
return e;
}
-static expr *expr5(int critical) {
+static expr *expr5(int critical)
+{
expr *e, *f;
e = expr6(critical);
if (!e)
return NULL;
while (i == '*' || i == '/' || i == '%' ||
- i == TOKEN_SDIV || i == TOKEN_SMOD) {
+ i == TOKEN_SDIV || i == TOKEN_SMOD)
+ {
int j = i;
i = scan(scpriv, tokval);
f = expr6(critical);
if (!f)
return NULL;
if (j != '*' && (!(is_simple(e) || is_just_unknown(e)) ||
- !(is_simple(f) || is_just_unknown(f)))) {
+ !(is_simple(f) || is_just_unknown(f))))
+ {
error(ERR_NONFATAL, "division operator may only be applied to"
" scalar values");
return NULL;
return e;
}
-static expr *expr6(int critical) {
+static expr *expr6(int critical)
+{
long type;
expr *e;
long label_seg, label_ofs;
}
i = scan(scpriv, tokval);
return e;
- } else if (i == TOKEN_NUM || i == TOKEN_REG || i == TOKEN_ID ||
- i == TOKEN_HERE || i == TOKEN_BASE) {
+ }
+ else if (i == TOKEN_NUM || i == TOKEN_REG || i == TOKEN_ID ||
+ i == TOKEN_HERE || i == TOKEN_BASE)
+ {
begintemp();
switch (i) {
case TOKEN_NUM:
case TOKEN_HERE:
case TOKEN_BASE:
/*
- * If "label" begins with "%", this indicates that no
+ * If !location->known, this indicates that no
* symbol, Here or Base references are valid because we
* are in preprocess-only mode.
*/
- if (*label == '%') {
+ if (!location->known) {
error(ERR_NONFATAL,
"%s not supported in preprocess-only mode",
(i == TOKEN_ID ? "symbol references" :
*/
type = EXPR_SIMPLE; /* might get overridden by UNKNOWN */
if (i == TOKEN_BASE) {
- label_seg = seg;
+ label_seg = location->segment;
label_ofs = 0;
- } else if (i == TOKEN_HERE || !strcmp(tokval->t_charptr, label)) {
- label_seg = seg;
- label_ofs = ofs;
+ } else if (i == TOKEN_HERE) {
+ label_seg = location->segment;
+ label_ofs = location->offset;
} else if (!labelfunc(tokval->t_charptr,&label_seg,&label_ofs)) {
if (critical == 2) {
error (ERR_NONFATAL, "symbol `%s' undefined",
tokval->t_charptr);
return NULL;
} else {
- if (forward)
- *forward = TRUE;
+ if (opflags)
+ *opflags |= 1;
type = EXPR_UNKNOWN;
label_seg = NO_SEG;
label_ofs = 1;
}
}
addtotemp(type, label_ofs);
- if (label_seg!=NO_SEG)
+ if (label_seg!=NO_SEG) {
addtotemp(EXPR_SEGBASE + label_seg, 1L);
+ if (opflags && is_extern (tokval->t_charptr))
+ *opflags |= OPFLAG_EXTERN;
+ }
break;
}
i = scan(scpriv, tokval);
}
}
-void eval_global_info (struct ofmt *output, lfunc lookup_label) {
+void eval_global_info (struct ofmt *output, lfunc lookup_label, loc_t *locp)
+{
outfmt = output;
labelfunc = lookup_label;
-}
-
-void eval_info (char *labelname, long segment, long offset) {
- if (label != special_empty_string)
- nasm_free (label);
- if (labelname)
- label = nasm_strdup(labelname);
- else {
- label = special_empty_string;
- seg = segment;
- ofs = offset;
- }
+ location = locp;
}
expr *evaluate (scanner sc, void *scprivate, struct tokenval *tv,
int *fwref, int critical, efunc report_error,
- struct eval_hints *hints) {
+ struct eval_hints *hints)
+{
expr *e;
expr *f = NULL;
scpriv = scprivate;
tokval = tv;
error = report_error;
- forward = fwref;
+ opflags = fwref;
if (tokval->t_type == TOKEN_INVALID)
i = scan(scpriv, tokval);
value = reloc_seg(f);
if (value == NO_SEG)
value = reloc_value(f) | SEG_ABS;
- else if (!(value & SEG_ABS) && !(value % 2) && critical) {
+ else if (!(value & SEG_ABS) && !(value % 2) && critical)
+ {
error(ERR_NONFATAL, "invalid right-hand operand to WRT");
return NULL;
}
* providing segment-base details, and what function can be used to
* look labels up.
*/
-void eval_global_info (struct ofmt *output, lfunc lookup_label);
-
-/*
- * Called to set the information the evaluator needs: the value of
- * $ is set from `segment' and `offset' if `labelname' is NULL, and
- * otherwise the name of the current line's label is set from
- * `labelname' instead.
- */
-void eval_info (char *labelname, long segment, long offset);
+void eval_global_info (struct ofmt *output, lfunc lookup_label, loc_t *locp);
/*
* The evaluator itself.
int *fwref, int critical, efunc report_error,
struct eval_hints *hints);
+void eval_cleanup(void);
+
#endif
* => we only have to worry about _one_ bit shift to the left
*/
-static int multiply(unsigned short *to, unsigned short *from) {
+static int multiply(unsigned short *to, unsigned short *from)
+{
unsigned long temp[MANT_WORDS*2];
- int i, j;
+ int i, j;
for (i=0; i<MANT_WORDS*2; i++)
temp[i] = 0;
}
static void flconvert(char *string, unsigned short *mant, long *exponent,
- efunc error) {
- char digits[MANT_DIGITS], *p, *q, *r;
- unsigned short mult[MANT_WORDS], *m, bit;
- long tenpwr, twopwr;
- int extratwos, started, seendot;
+ efunc error)
+{
+ char digits[MANT_DIGITS];
+ char *p, *q, *r;
+ unsigned short mult[MANT_WORDS], bit;
+ unsigned short * m;
+ long tenpwr, twopwr;
+ int extratwos, started, seendot;
p = digits;
tenpwr = 0;
/*
* Shift a mantissa to the right by i (i < 16) bits.
*/
-static void shr(unsigned short *mant, int i) {
+static void shr(unsigned short *mant, int i)
+{
unsigned short n = 0, m;
- int j;
+ int j;
for (j=0; j<MANT_WORDS; j++) {
m = (mant[j] << (16-i)) & 0xFFFF;
/*
* Round a mantissa off after i words.
*/
-static int round(unsigned short *mant, int i) {
+static int round(unsigned short *mant, int i)
+{
if (mant[i] & 0x8000) {
do {
++mant[--i];
#define put(a,b) ( (*(a)=(b)), ((a)[1]=(b)>>8) )
static int to_double(char *str, long sign, unsigned char *result,
- efunc error) {
+ efunc error)
+{
unsigned short mant[MANT_WORDS];
long exponent;
}
static int to_float(char *str, long sign, unsigned char *result,
- efunc error) {
+ efunc error)
+{
unsigned short mant[MANT_WORDS];
long exponent;
}
static int to_ldoub(char *str, long sign, unsigned char *result,
- efunc error) {
+ efunc error)
+{
unsigned short mant[MANT_WORDS];
long exponent;
}
int float_const (char *number, long sign, unsigned char *result, int bytes,
- efunc error) {
+ efunc error)
+{
if (bytes == 4)
return to_float (number, sign, result, error);
else if (bytes == 8)
BTS rm16,imm \320\300\2\x0F\xBA\205\25 386
BTS rm32,imm \321\300\2\x0F\xBA\205\25 386
CALL imm \322\1\xE8\64 8086
+CALL imm|near \322\1\xE8\64 8086
CALL imm|far \322\1\x9A\34\37 8086,ND
CALL imm:imm \322\1\x9A\35\30 8086
CALL imm16:imm \320\1\x9A\31\30 8086
FDIVR fpu0,fpureg \1\xD8\11\xF8 8086,FPU
FDIVRP fpureg \1\xDE\10\xF0 8086,FPU
FDIVRP fpureg,fpu0 \1\xDE\10\xF0 8086,FPU
+FEMMS void \2\x0F\x0E PENT,MMX,FPU
FENI void \3\x9B\xDB\xE0 8086,FPU
FFREE fpureg \1\xDD\10\xC0 8086,FPU
FIADD mem32 \300\1\xDA\200 8086,FPU
JECXZ imm \321\1\xE3\50 386
JMP imm|short \1\xEB\50 8086
JMP imm \322\1\xE9\64 8086
+JMP imm|near \322\1\xE9\64 8086
JMP imm|far \322\1\xEA\34\37 8086,ND
JMP imm:imm \322\1\xEA\35\30 8086
JMP imm16:imm \320\1\xEA\31\30 8086
OR mem,imm8 \300\1\x80\201\21 8086,SM
OR mem,imm16 \320\300\1\x81\201\31 8086,SM
OR mem,imm32 \321\300\1\x81\201\41 386,SM
-OUT imm,reg_al \1\xE6\24 8086
-OUT imm,reg_ax \320\1\xE7\24 8086
-OUT imm,reg_eax \321\1\xE7\24 386
+OUT imm,reg_al \1\xE6\24 8086,SB
+OUT imm,reg_ax \320\1\xE7\24 8086,SB
+OUT imm,reg_eax \321\1\xE7\24 386,SB
OUT reg_dx,reg_al \1\xEE 8086
OUT reg_dx,reg_ax \320\1\xEF 8086
OUT reg_dx,reg_eax \321\1\xEF 386
PANDN mmxreg,mmxreg \2\x0F\xDF\110 PENT,MMX
PAVEB mmxreg,mem \301\2\x0F\x50\110 PENT,MMX,SM,CYRIX
PAVEB mmxreg,mmxreg \2\x0F\x50\110 PENT,MMX,CYRIX
+PAVGUSB mmxreg,mem \301\2\x0F\x0F\110\01\xBF PENT,MMX,SM,FPU
+PAVGUSB mmxreg,mmxreg \2\x0F\x0F\110\01\xBF PENT,MMX,FPU
PCMPEQB mmxreg,mem \301\2\x0F\x74\110 PENT,MMX,SM
PCMPEQB mmxreg,mmxreg \2\x0F\x74\110 PENT,MMX
PCMPEQD mmxreg,mem \301\2\x0F\x76\110 PENT,MMX,SM
PCMPGTW mmxreg,mem \301\2\x0F\x65\110 PENT,MMX,SM
PCMPGTW mmxreg,mmxreg \2\x0F\x65\110 PENT,MMX
PDISTIB mmxreg,mem \301\2\x0F\x54\110 PENT,MMX,SM,CYRIX
+PF2ID mmxreg,mem \301\2\x0F\x0F\110\01\x1D PENT,MMX,SM,FPU
+PF2ID mmxreg,mmxreg \2\x0F\x0F\110\01\x1D PENT,MMX,FPU
+PFACC mmxreg,mem \301\2\x0F\x0F\110\01\xAE PENT,MMX,SM,FPU
+PFACC mmxreg,mmxreg \2\x0F\x0F\110\01\xAE PENT,MMX,FPU
+PFADD mmxreg,mem \301\2\x0F\x0F\110\01\x9E PENT,MMX,SM,FPU
+PFADD mmxreg,mmxreg \2\x0F\x0F\110\01\x9E PENT,MMX,FPU
+PFCMPEQ mmxreg,mem \301\2\x0F\x0F\110\01\xB0 PENT,MMX,SM,FPU
+PFCMPEQ mmxreg,mmxreg \2\x0F\x0F\110\01\xB0 PENT,MMX,FPU
+PFCMPGE mmxreg,mem \301\2\x0F\x0F\110\01\x90 PENT,MMX,SM,FPU
+PFCMPGE mmxreg,mmxreg \2\x0F\x0F\110\01\x90 PENT,MMX,FPU
+PFCMPGT mmxreg,mem \301\2\x0F\x0F\110\01\xA0 PENT,MMX,SM,FPU
+PFCMPGT mmxreg,mmxreg \2\x0F\x0F\110\01\xA0 PENT,MMX,FPU
+PFMAX mmxreg,mem \301\2\x0F\x0F\110\01\xA4 PENT,MMX,SM,FPU
+PFMAX mmxreg,mmxreg \2\x0F\x0F\110\01\xA4 PENT,MMX,FPU
+PFMIN mmxreg,mem \301\2\x0F\x0F\110\01\x94 PENT,MMX,SM,FPU
+PFMIN mmxreg,mmxreg \2\x0F\x0F\110\01\x94 PENT,MMX,FPU
+PFMUL mmxreg,mem \301\2\x0F\x0F\110\01\xB4 PENT,MMX,SM,FPU
+PFMUL mmxreg,mmxreg \2\x0F\x0F\110\01\xB4 PENT,MMX,FPU
+PFRCP mmxreg,mem \301\2\x0F\x0F\110\01\x96 PENT,MMX,SM,FPU
+PFRCP mmxreg,mmxreg \2\x0F\x0F\110\01\x96 PENT,MMX,FPU
+PFRCPIT1 mmxreg,mem \301\2\x0F\x0F\110\01\xA6 PENT,MMX,SM,FPU
+PFRCPIT1 mmxreg,mmxreg \2\x0F\x0F\110\01\xA6 PENT,MMX,FPU
+PFRCPIT2 mmxreg,mem \301\2\x0F\x0F\110\01\xB6 PENT,MMX,SM,FPU
+PFRCPIT2 mmxreg,mmxreg \2\x0F\x0F\110\01\xB6 PENT,MMX,FPU
+PFRSQIT1 mmxreg,mem \301\2\x0F\x0F\110\01\xA7 PENT,MMX,SM,FPU
+PFRSQIT1 mmxreg,mmxreg \2\x0F\x0F\110\01\xA7 PENT,MMX,FPU
+PFRSQRT mmxreg,mem \301\2\x0F\x0F\110\01\x97 PENT,MMX,SM,FPU
+PFRSQRT mmxreg,mmxreg \2\x0F\x0F\110\01\x97 PENT,MMX,FPU
+PFSUB mmxreg,mem \301\2\x0F\x0F\110\01\x9A PENT,MMX,SM,FPU
+PFSUB mmxreg,mmxreg \2\x0F\x0F\110\01\x9A PENT,MMX,FPU
+PFSUBR mmxreg,mem \301\2\x0F\x0F\110\01\xAA PENT,MMX,SM,FPU
+PFSUBR mmxreg,mmxreg \2\x0F\x0F\110\01\xAA PENT,MMX,FPU
+PI2FD mmxreg,mem \301\2\x0F\x0F\110\01\x0D PENT,MMX,SM,FPU
+PI2FD mmxreg,mmxreg \2\x0F\x0F\110\01\x0D PENT,MMX,FPU
PMACHRIW mmxreg,mem \301\2\x0F\x5E\110 PENT,MMX,SM,CYRIX
PMADDWD mmxreg,mem \301\2\x0F\xF5\110 PENT,MMX,SM
PMADDWD mmxreg,mmxreg \2\x0F\xF5\110 PENT,MMX
PMAGW mmxreg,mem \301\2\x0F\x52\110 PENT,MMX,SM,CYRIX
PMAGW mmxreg,mmxreg \2\x0F\x52\110 PENT,MMX,CYRIX
-PMULHRW mmxreg,mem \301\2\x0F\x59\110 PENT,MMX,SM,CYRIX
-PMULHRW mmxreg,mmxreg \2\x0F\x59\110 PENT,MMX,CYRIX
PMULHRIW mmxreg,mem \301\2\x0F\x5D\110 PENT,MMX,SM,CYRIX
PMULHRIW mmxreg,mmxreg \2\x0F\x5D\110 PENT,MMX,CYRIX
+PMULHRWA mmxreg,mem \301\2\x0F\x0F\110\1\xB7 PENT,MMX,SM,FPU
+PMULHRWA mmxreg,mmxreg \2\x0F\x0F\110\1\xB7 PENT,MMX,FPU
+PMULHRWC mmxreg,mem \301\2\x0F\x59\110 PENT,MMX,SM,CYRIX
+PMULHRWC mmxreg,mmxreg \2\x0F\x59\110 PENT,MMX,CYRIX
PMULHW mmxreg,mem \301\2\x0F\xE5\110 PENT,MMX,SM
PMULHW mmxreg,mmxreg \2\x0F\xE5\110 PENT,MMX
PMULLW mmxreg,mem \301\2\x0F\xD5\110 PENT,MMX,SM
POPFW void \320\1\x9D 186
POR mmxreg,mem \301\2\x0F\xEB\110 PENT,MMX,SM
POR mmxreg,mmxreg \2\x0F\xEB\110 PENT,MMX
+PREFETCH mem \2\x0F\x0D\200 PENT,MMX,SM,FPU
+PREFETCHW mem \2\x0F\x0D\201 PENT,MMX,SM,FPU
PSLLD mmxreg,mem \301\2\x0F\xF2\110 PENT,MMX,SM
PSLLD mmxreg,mmxreg \2\x0F\xF2\110 PENT,MMX
PSLLD mmxreg,imm \2\x0F\x72\206\25 PENT,MMX
PXOR mmxreg,mmxreg \2\x0F\xEF\110 PENT,MMX
RCL rm8,unity \300\1\xD0\202 8086
RCL rm8,reg_cl \300\1\xD2\202 8086
-RCL rm8,imm \300\1\xC0\202\25 286,SB
+RCL rm8,imm \300\1\xC0\202\25 186,SB
RCL rm16,unity \320\300\1\xD1\202 8086
RCL rm16,reg_cl \320\300\1\xD3\202 8086
-RCL rm16,imm \320\300\1\xC1\202\25 286,SB
+RCL rm16,imm \320\300\1\xC1\202\25 186,SB
RCL rm32,unity \321\300\1\xD1\202 386
RCL rm32,reg_cl \321\300\1\xD3\202 386
RCL rm32,imm \321\300\1\xC1\202\25 386,SB
RCR rm8,unity \300\1\xD0\203 8086
RCR rm8,reg_cl \300\1\xD2\203 8086
-RCR rm8,imm \300\1\xC0\203\25 286,SB
+RCR rm8,imm \300\1\xC0\203\25 186,SB
RCR rm16,unity \320\300\1\xD1\203 8086
RCR rm16,reg_cl \320\300\1\xD3\203 8086
-RCR rm16,imm \320\300\1\xC1\203\25 286,SB
+RCR rm16,imm \320\300\1\xC1\203\25 186,SB
RCR rm32,unity \321\300\1\xD1\203 386
RCR rm32,reg_cl \321\300\1\xD3\203 386
RCR rm32,imm \321\300\1\xC1\203\25 386,SB
RETN imm \1\xC2\30 8086
ROL rm8,unity \300\1\xD0\200 8086
ROL rm8,reg_cl \300\1\xD2\200 8086
-ROL rm8,imm \300\1\xC0\200\25 286,SB
+ROL rm8,imm \300\1\xC0\200\25 186,SB
ROL rm16,unity \320\300\1\xD1\200 8086
ROL rm16,reg_cl \320\300\1\xD3\200 8086
-ROL rm16,imm \320\300\1\xC1\200\25 286,SB
+ROL rm16,imm \320\300\1\xC1\200\25 186,SB
ROL rm32,unity \321\300\1\xD1\200 386
ROL rm32,reg_cl \321\300\1\xD3\200 386
ROL rm32,imm \321\300\1\xC1\200\25 386,SB
ROR rm8,unity \300\1\xD0\201 8086
ROR rm8,reg_cl \300\1\xD2\201 8086
-ROR rm8,imm \300\1\xC0\201\25 286,SB
+ROR rm8,imm \300\1\xC0\201\25 186,SB
ROR rm16,unity \320\300\1\xD1\201 8086
ROR rm16,reg_cl \320\300\1\xD3\201 8086
-ROR rm16,imm \320\300\1\xC1\201\25 286,SB
+ROR rm16,imm \320\300\1\xC1\201\25 186,SB
ROR rm32,unity \321\300\1\xD1\201 386
ROR rm32,reg_cl \321\300\1\xD3\201 386
ROR rm32,imm \321\300\1\xC1\201\25 386,SB
SAHF void \1\x9E 8086
SAL rm8,unity \300\1\xD0\204 8086,ND
SAL rm8,reg_cl \300\1\xD2\204 8086,ND
-SAL rm8,imm \300\1\xC0\204\25 286,ND,SB
+SAL rm8,imm \300\1\xC0\204\25 186,ND,SB
SAL rm16,unity \320\300\1\xD1\204 8086,ND
SAL rm16,reg_cl \320\300\1\xD3\204 8086,ND
-SAL rm16,imm \320\300\1\xC1\204\25 286,ND,SB
+SAL rm16,imm \320\300\1\xC1\204\25 186,ND,SB
SAL rm32,unity \321\300\1\xD1\204 386,ND
SAL rm32,reg_cl \321\300\1\xD3\204 386,ND
SAL rm32,imm \321\300\1\xC1\204\25 386,ND,SB
SALC void \1\xD6 8086,UNDOC
SAR rm8,unity \300\1\xD0\207 8086
SAR rm8,reg_cl \300\1\xD2\207 8086
-SAR rm8,imm \300\1\xC0\207\25 286,SB
+SAR rm8,imm \300\1\xC0\207\25 186,SB
SAR rm16,unity \320\300\1\xD1\207 8086
SAR rm16,reg_cl \320\300\1\xD3\207 8086
-SAR rm16,imm \320\300\1\xC1\207\25 286,SB
+SAR rm16,imm \320\300\1\xC1\207\25 186,SB
SAR rm32,unity \321\300\1\xD1\207 386
SAR rm32,reg_cl \321\300\1\xD3\207 386
SAR rm32,imm \321\300\1\xC1\207\25 386,SB
SGDT mem \300\2\x0F\x01\200 286,PRIV
SHL rm8,unity \300\1\xD0\204 8086
SHL rm8,reg_cl \300\1\xD2\204 8086
-SHL rm8,imm \300\1\xC0\204\25 286,SB
+SHL rm8,imm \300\1\xC0\204\25 186,SB
SHL rm16,unity \320\300\1\xD1\204 8086
SHL rm16,reg_cl \320\300\1\xD3\204 8086
-SHL rm16,imm \320\300\1\xC1\204\25 286,SB
+SHL rm16,imm \320\300\1\xC1\204\25 186,SB
SHL rm32,unity \321\300\1\xD1\204 386
SHL rm32,reg_cl \321\300\1\xD3\204 386
SHL rm32,imm \321\300\1\xC1\204\25 386,SB
SHLD reg32,reg32,reg_cl \300\321\2\x0F\xA5\101 386
SHR rm8,unity \300\1\xD0\205 8086
SHR rm8,reg_cl \300\1\xD2\205 8086
-SHR rm8,imm \300\1\xC0\205\25 286,SB
+SHR rm8,imm \300\1\xC0\205\25 186,SB
SHR rm16,unity \320\300\1\xD1\205 8086
SHR rm16,reg_cl \320\300\1\xD3\205 8086
-SHR rm16,imm \320\300\1\xC1\205\25 286,SB
+SHR rm16,imm \320\300\1\xC1\205\25 186,SB
SHR rm32,unity \321\300\1\xD1\205 386
SHR rm32,reg_cl \321\300\1\xD3\205 386
SHR rm32,imm \321\300\1\xC1\205\25 386,SB
TEST reg16,reg16 \320\300\1\x85\101 8086
TEST mem,reg32 \321\300\1\x85\101 386,SM
TEST reg32,reg32 \321\300\1\x85\101 386
+TEST reg8,mem \301\1\x84\110 8086,SM
+TEST reg16,mem \320\301\1\x85\110 8086,SM
+TEST reg32,mem \321\301\1\x85\110 386,SM
TEST reg_al,imm \1\xA8\21 8086,SM
TEST reg_ax,imm \320\1\xA9\31 8086,SM
TEST reg_eax,imm \321\1\xA9\41 386,SM
struct {
long segment, offset;
char *label, *special;
- int is_global;
+ int is_global, is_norm;
} defn;
struct {
long movingon, dummy;
* given label name. Creates a new one, if it isn't found, and if
* `create' is TRUE.
*/
-static union label *find_label (char *label, int create) {
+static union label *find_label (char *label, int create)
+{
int hash = 0;
char *p, *prev;
int prevlen;
lfree[hash]->defn.special = NULL;
lfree[hash]->defn.is_global = NOT_DEFINED_YET;
return lfree[hash]++;
- } else
+ }
+ else
return NULL;
}
-int lookup_label (char *label, long *segment, long *offset) {
+int lookup_label (char *label, long *segment, long *offset)
+{
union label *lptr;
if (!initialised)
*segment = lptr->defn.segment;
*offset = lptr->defn.offset;
return 1;
- } else
+ }
+ else
return 0;
}
-int is_extern (char *label) {
+int is_extern (char *label)
+{
union label *lptr;
if (!initialised)
return 0;
}
-void define_label_stub (char *label, efunc error) {
+void redefine_label (char *label, long segment, long offset, char *special,
+ int is_norm, int isextrn, struct ofmt *ofmt, efunc error)
+{
union label *lptr;
+ /* This routine possibly ought to check for phase errors. Most assemblers
+ * check for phase errors at this point. I don't know whether phase errors
+ * are even possible, nor whether they are checked somewhere else
+ */
+
+ (void) segment; /* Don't warn that this parameter is unused */
+ (void) offset; /* Don't warn that this parameter is unused */
+ (void) special; /* Don't warn that this parameter is unused */
+ (void) is_norm; /* Don't warn that this parameter is unused */
+ (void) isextrn; /* Don't warn that this parameter is unused */
+ (void) ofmt; /* Don't warn that this parameter is unused */
+
+#ifdef DEBUG
+ if (!strncmp(label, "debugdump", 9))
+ fprintf(stderr, "debug: redefine_label (%s, %ld, %08lx, %s, %d, %d)\n",
+ label, segment, offset, special, is_norm, isextrn);
+#endif
+
if (!islocal(label)) {
lptr = find_label (label, 1);
if (!lptr)
error (ERR_PANIC, "can't find label `%s' on pass two", label);
- if (*label != '.')
+ if (*label != '.' && lptr->defn.is_norm)
prevlabel = lptr->defn.label;
}
}
void define_label (char *label, long segment, long offset, char *special,
- int is_norm, int isextrn, struct ofmt *ofmt, efunc error) {
+ int is_norm, int isextrn, struct ofmt *ofmt, efunc error)
+{
union label *lptr;
+#ifdef DEBUG
+ if (!strncmp(label, "debugdump", 9))
+ fprintf(stderr, "debug: define_label (%s, %ld, %08lx, %s, %d, %d)\n",
+ label, segment, offset, special, is_norm, isextrn);
+#endif
lptr = find_label (label, 1);
if (lptr->defn.is_global & DEFINED_BIT) {
error(ERR_NONFATAL, "symbol `%s' redefined", label);
lptr->defn.segment = segment;
lptr->defn.offset = offset;
+ lptr->defn.is_norm = (label[0] != '.' && is_norm);
ofmt->symdef (lptr->defn.label, segment, offset,
!!(lptr->defn.is_global & GLOBAL_BIT),
special ? special : lptr->defn.special);
+ ofmt->current_dfmt->debug_deflabel (label, segment, offset,
+ !!(lptr->defn.is_global & GLOBAL_BIT),
+ special ? special : lptr->defn.special);
}
void define_common (char *label, long segment, long size, char *special,
- struct ofmt *ofmt, efunc error) {
+ struct ofmt *ofmt, efunc error)
+{
union label *lptr;
lptr = find_label (label, 1);
ofmt->symdef (lptr->defn.label, segment, size, 2,
special ? special : lptr->defn.special);
+ ofmt->current_dfmt->debug_deflabel(lptr->defn.label, segment, size, 2,
+ special ? special : lptr->defn.special);
}
-void declare_as_global (char *label, char *special, efunc error) {
+void declare_as_global (char *label, char *special, efunc error)
+{
union label *lptr;
if (islocal(label)) {
}
}
-int init_labels (void) {
+int init_labels (void)
+{
int i;
for (i=0; i<LABEL_HASHES; i++) {
lfree[i] = ltab[i];
}
- perm_head = perm_tail = (struct permts *) nasm_malloc (sizeof(struct permts));
+ perm_head =
+ perm_tail = (struct permts *) nasm_malloc (sizeof(struct permts));
+
if (!perm_head)
return -1;
return 0;
}
-void cleanup_labels (void) {
+void cleanup_labels (void)
+{
int i;
initialised = FALSE;
}
}
-static void init_block (union label *blk) {
+static void init_block (union label *blk)
+{
int j;
for (j=0; j<LABEL_BLOCK-1; j++)
blk[LABEL_BLOCK-1].admin.next = NULL;
}
-static char *perm_copy (char *string1, char *string2) {
+static char *perm_copy (char *string1, char *string2)
+{
char *p, *q;
int len = strlen(string1)+strlen(string2)+1;
}
p = q = perm_tail->data + perm_tail->usage;
while ( (*q = *string1++) ) q++;
- while ( (*q++ = *string2++) );
+ while ( (*q++ = *string2++) ) ;
perm_tail->usage = q - perm_tail->data;
return p;
}
+
+/*
+ * Notes regarding bug involving redefinition of external segments.
+ *
+ * Up to and including v0.97, the following code didn't work. From 0.97
+ * developers release 2 onwards, it will generate an error.
+ *
+ * EXTERN extlabel
+ * newlabel EQU extlabel + 1
+ *
+ * The results of allowing this code through are that two import records
+ * are generated, one for 'extlabel' and one for 'newlabel'.
+ *
+ * The reason for this is an inadequacy in the defined interface between
+ * the label manager and the output formats. The problem lies in how the
+ * output format driver tells that a label is an external label for which
+ * a label import record must be produced. Most (all except bin?) produce
+ * the record if the segment number of the label is not one of the internal
+ * segments that the output driver is producing.
+ *
+ * A simple fix to this would be to make the output formats keep track of
+ * which symbols they've produced import records for, and make them not
+ * produce import records for segments that are already defined.
+ *
+ * The best way, which is slightly harder but reduces duplication of code
+ * and should therefore make the entire system smaller and more stable is
+ * to change the interface between assembler, define_label(), and
+ * the output module. The changes that are needed are:
+ *
+ * The semantics of the 'isextern' flag passed to define_label() need
+ * examining. This information may or may not tell us what we need to
+ * know (ie should we be generating an import record at this point for this
+ * label). If these aren't the semantics, the semantics should be changed
+ * to this.
+ *
+ * The output module interface needs changing, so that the `isextern' flag
+ * is passed to the module, so that it can be easily tested for.
+ */
int is_extern (char *label);
void define_label (char *label, long segment, long offset, char *special,
int is_norm, int isextrn, struct ofmt *ofmt, efunc error);
+void redefine_label (char *label, long segment, long offset, char *special,
+ int is_norm, int isextrn, struct ofmt *ofmt, efunc error);
void define_common (char *label, long segment, long size, char *special,
struct ofmt *ofmt, efunc error);
-void define_label_stub (char *label, efunc error);
void declare_as_global (char *label, char *special, efunc error);
int init_labels (void);
void cleanup_labels (void);
static FILE *listfp;
-static void list_emit (void) {
+static void list_emit (void)
+{
if (!listlinep && !listdata[0])
return;
+
fprintf(listfp, "%6ld ", ++listlineno);
+
if (listdata[0])
fprintf(listfp, "%08lX %-*s", listoffset, LIST_HEXBIT+1, listdata);
else
fprintf(listfp, "%*s", LIST_HEXBIT+10, "");
+
if (listlevel_e)
fprintf(listfp, "%s<%d>", (listlevel < 10 ? " " : ""), listlevel_e);
else if (listlinep)
fprintf(listfp, " ");
+
if (listlinep)
fprintf(listfp, " %s", listline);
+
fputc('\n', listfp);
listlinep = FALSE;
listdata[0] = '\0';
}
-static void list_init (char *fname, efunc error) {
+static void list_init (char *fname, efunc error)
+{
listfp = fopen (fname, "w");
if (!listfp) {
error (ERR_NONFATAL, "unable to open listing file `%s'", fname);
return;
}
+
*listline = '\0';
listlineno = 0;
listp = TRUE;
mistack->inhibiting = TRUE;
}
-static void list_cleanup (void) {
+static void list_cleanup (void)
+{
if (!listp)
return;
+
while (mistack) {
MacroInhibit *temp = mistack;
mistack = temp->next;
nasm_free (temp);
}
+
list_emit();
fclose (listfp);
}
-static void list_out (long offset, char *str) {
+static void list_out (long offset, char *str)
+{
if (strlen(listdata) + strlen(str) > LIST_HEXBIT) {
strcat(listdata, "-");
list_emit();
strcat(listdata, str);
}
-static void list_output (long offset, void *data, unsigned long type) {
+static void list_output (long offset, void *data, unsigned long type)
+{
long typ, size;
if (!listp || suppress)
typ = type & OUT_TYPMASK;
size = type & OUT_SIZMASK;
- if (typ == OUT_RAWDATA) {
+ if (typ == OUT_RAWDATA)
+ {
unsigned char *p = data;
char q[3];
- while (size--) {
+ while (size--)
+ {
HEX (q, *p);
q[2] = '\0';
list_out (offset++, q);
p++;
}
- } else if (typ == OUT_ADDRESS) {
+ }
+ else if (typ == OUT_ADDRESS)
+ {
unsigned long d = *(long *)data;
char q[11];
unsigned char p[4], *r = p;
- if (size == 4) {
+ if (size == 4)
+ {
q[0] = '['; q[9] = ']'; q[10] = '\0';
WRITELONG (r, d);
HEX (q+1, p[0]);
HEX (q+5, p[2]);
HEX (q+7, p[3]);
list_out (offset, q);
- } else {
+ }
+ else {
q[0] = '['; q[5] = ']'; q[6] = '\0';
WRITESHORT (r, d);
HEX (q+1, p[0]);
HEX (q+3, p[1]);
list_out (offset, q);
}
- } else if (typ == OUT_REL2ADR) {
+ }
+ else if (typ == OUT_REL2ADR)
+ {
unsigned long d = *(long *)data;
char q[11];
unsigned char p[4], *r = p;
HEX (q+1, p[0]);
HEX (q+3, p[1]);
list_out (offset, q);
- } else if (typ == OUT_REL4ADR) {
+ }
+ else if (typ == OUT_REL4ADR)
+ {
unsigned long d = *(long *)data;
char q[11];
unsigned char p[4], *r = p;
HEX (q+5, p[2]);
HEX (q+7, p[3]);
list_out (offset, q);
- } else if (typ == OUT_RESERVE) {
+ }
+ else if (typ == OUT_RESERVE)
+ {
char q[20];
sprintf(q, "<res %08lX>", size);
list_out (offset, q);
}
}
-static void list_line (int type, char *line) {
+static void list_line (int type, char *line)
+{
if (!listp)
return;
- if (mistack && mistack->inhibiting) {
+
+ if (mistack && mistack->inhibiting)
+ {
if (type == LIST_MACRO)
return;
else { /* pop the m i stack */
listlevel_e = listlevel;
}
-static void list_uplevel (int type) {
+static void list_uplevel (int type)
+{
if (!listp)
return;
- if (type == LIST_INCBIN || type == LIST_TIMES) {
+ if (type == LIST_INCBIN || type == LIST_TIMES)
+ {
suppress |= (type == LIST_INCBIN ? 1 : 2);
list_out (listoffset, type == LIST_INCBIN ? "<incbin>" : "<rept>");
return;
}
+
listlevel++;
- if (mistack && mistack->inhibiting && type == LIST_INCLUDE) {
+
+ if (mistack && mistack->inhibiting && type == LIST_INCLUDE)
+ {
MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
temp->next = mistack;
temp->level = listlevel;
temp->inhibiting = FALSE;
mistack = temp;
- } else if (type == LIST_MACRO_NOLIST) {
+ }
+ else if (type == LIST_MACRO_NOLIST)
+ {
MacroInhibit *temp = nasm_malloc(sizeof(MacroInhibit));
temp->next = mistack;
temp->level = listlevel;
}
}
-static void list_downlevel (int type) {
+static void list_downlevel (int type)
+{
if (!listp)
return;
- if (type == LIST_INCBIN || type == LIST_TIMES) {
+
+ if (type == LIST_INCBIN || type == LIST_TIMES)
+ {
suppress &= ~(type == LIST_INCBIN ? 1 : 2);
return;
}
+
listlevel--;
- while (mistack && mistack->level > listlevel) {
+ while (mistack && mistack->level > listlevel)
+ {
MacroInhibit *temp = mistack;
mistack = temp->next;
nasm_free (temp);
"fcmovbe", "fcmove", "fcmovnb", "fcmovnbe", "fcmovne",
"fcmovnu", "fcmovu", "fcom", "fcomi", "fcomip", "fcomp",
"fcompp", "fcos", "fdecstp", "fdisi", "fdiv", "fdivp", "fdivr",
- "fdivrp", "feni", "ffree", "fiadd", "ficom", "ficomp", "fidiv",
+ "fdivrp",
+ "femms",
+ "feni", "ffree", "fiadd", "ficom", "ficomp", "fidiv",
"fidivr", "fild", "fimul", "fincstp", "finit", "fist", "fistp",
"fisub", "fisubr", "fld", "fld1", "fldcw", "fldenv", "fldl2e",
"fldl2t", "fldlg2", "fldln2", "fldpi", "fldz", "fmul", "fmulp",
"fucomi", "fucomip", "fucomp", "fucompp", "fxam", "fxch",
"fxtract", "fyl2x", "fyl2xp1", "hlt", "ibts", "icebp", "idiv",
"imul", "in", "inc", "incbin", "insb", "insd", "insw", "int",
- "int1", "int01", "int3", "into", "invd", "invlpg", "iret",
+ "int01", "int1", "int3", "into", "invd", "invlpg", "iret",
"iretd", "iretw", "jcxz", "jecxz", "jmp", "lahf", "lar", "lds",
"lea", "leave", "les", "lfs", "lgdt", "lgs", "lidt", "lldt",
"lmsw", "loadall", "loadall286", "lodsb", "lodsd", "lodsw",
"movsx", "movzx", "mul", "neg", "nop", "not", "or", "out",
"outsb", "outsd", "outsw", "packssdw", "packsswb", "packuswb",
"paddb", "paddd", "paddsb", "paddsiw", "paddsw", "paddusb",
- "paddusw", "paddw", "pand", "pandn", "paveb", "pcmpeqb",
+ "paddusw", "paddw", "pand", "pandn", "paveb",
+ "pavgusb", "pcmpeqb",
"pcmpeqd", "pcmpeqw", "pcmpgtb", "pcmpgtd", "pcmpgtw",
- "pdistib", "pmachriw", "pmaddwd", "pmagw", "pmulhrw",
- "pmulhriw", "pmulhw", "pmullw", "pmvgezb", "pmvlzb", "pmvnzb",
+ "pdistib",
+ "pf2id", "pfacc", "pfadd", "pfcmpeq", "pfcmpge", "pfcmpgt",
+ "pfmax", "pfmin", "pfmul", "pfrcp", "pfrcpit1", "pfrcpit2",
+ "pfrsqit1", "pfrsqrt", "pfsub", "pfsubr", "pi2fd",
+ "pmachriw", "pmaddwd", "pmagw", "pmulhriw", "pmulhrwa", "pmulhrwc",
+ "pmulhw", "pmullw", "pmvgezb", "pmvlzb", "pmvnzb",
"pmvzb", "pop", "popa", "popad", "popaw", "popf", "popfd",
- "popfw", "por", "pslld", "psllq", "psllw", "psrad", "psraw",
+ "popfw", "por",
+ "prefetch", "prefetchw", "pslld", "psllq", "psllw", "psrad", "psraw",
"psrld", "psrlq", "psrlw", "psubb", "psubd", "psubsb",
"psubsiw", "psubsw", "psubusb", "psubusw", "psubw", "punpckhbw",
"punpckhdq", "punpckhwd", "punpcklbw", "punpckldq", "punpcklwd",
#include "outform.h"
#include "listing.h"
+struct forwrefinfo { /* info held on forward refs. */
+ int lineno;
+ int operand;
+};
+
static void report_error (int, char *, ...);
static void parse_cmdline (int, char **);
static void assemble_file (char *);
static void register_output_formats(void);
static void usage(void);
-static char *obuf;
+static int using_debug_info;
+
static char inname[FILENAME_MAX];
static char outname[FILENAME_MAX];
static char listname[FILENAME_MAX];
-static int lineno; /* for error reporting */
-static int lineinc; /* set by [LINE] or [ONELINE] */
static int globallineno; /* for forward-reference tracking */
static int pass;
static struct ofmt *ofmt = NULL;
static FILE *ofile = NULL;
static int sb = 16; /* by default */
-static int use_stdout = FALSE; /* by default, errors to stderr */
+static loc_t location;
+int in_abs_seg; /* Flag we are in ABSOLUTE seg */
+static long abs_seg;
-static long current_seg, abs_seg;
static struct RAA *offsets;
static long abs_offset;
static struct SAA *forwrefs; /* keep track of forward references */
-static int forwline;
+static struct forwrefinfo *forwref;
static Preproc *preproc;
static int preprocess_only;
/* used by error function to report location */
-static char currentfile[FILENAME_MAX];
/*
* Which of the suppressible warnings are suppressed. Entry zero
* doesn't do anything. Initial defaults are given here.
*/
static char suppressed[1+ERR_WARN_MAX] = {
- 0, FALSE, TRUE, FALSE
+ 0, TRUE, TRUE, FALSE
};
/*
/*
* get/set current offset...
*/
-#define get_curr_ofs (current_seg==NO_SEG?abs_offset:\
- raa_read(offsets,current_seg))
-#define set_curr_ofs(x) (current_seg==NO_SEG?(void)(abs_offset=(x)):\
- (void)(offsets=raa_write(offsets,current_seg,(x))))
+#define get_curr_ofs (in_abs_seg?abs_offset:\
+ raa_read(offsets,location.segment))
+#define set_curr_ofs(x) (in_abs_seg?(void)(abs_offset=(x)):\
+ (void)(offsets=raa_write(offsets,location.segment,(x))))
static int want_usage;
static int terminate_after_phase;
-int main(int argc, char **argv) {
+static void nasm_fputs(char *line, FILE *ofile)
+{
+ if (ofile) {
+ fputs(line, ofile);
+ fputc('\n', ofile);
+ } else
+ puts(line);
+}
+
+int main(int argc, char **argv)
+{
want_usage = terminate_after_phase = FALSE;
nasm_set_malloc_error (report_error);
offsets = raa_init();
- forwrefs = saa_init ((long)sizeof(int));
+ forwrefs = saa_init ((long)sizeof(struct forwrefinfo));
preproc = &nasmpp;
preprocess_only = FALSE;
parse_cmdline(argc, argv);
- if (terminate_after_phase) {
+ if (terminate_after_phase)
+ {
if (want_usage)
usage();
return 1;
if (ofmt->stdmac)
pp_extra_stdmac (ofmt->stdmac);
- eval_global_info (ofmt, lookup_label);
+ parser_global_info (ofmt, &location);
+ eval_global_info (ofmt, lookup_label, &location);
- if (preprocess_only) {
+ if (preprocess_only)
+ {
char *line;
+ char *file_name = NULL;
+ long prior_linnum=0;
+ int lineinc=0;
if (*outname) {
ofile = fopen(outname, "w");
} else
ofile = NULL;
- eval_info ("%", 0L, 0L); /* disallow labels, $ or $$ in exprs */
+ location.known = FALSE;
preproc->reset (inname, 2, report_error, evaluate, &nasmlist);
- strcpy(currentfile,inname);
- lineno = 0;
- lineinc = 1;
while ( (line = preproc->getline()) ) {
- int ln, li;
- char buf[FILENAME_MAX];
-
- lineno += lineinc;
/*
- * We must still check for %line directives, so that we
- * can report errors accurately.
+ * We generate %line directives if needed for later programs
*/
- if (!strncmp(line, "%line", 5) &&
- sscanf(line, "%%line %d+%d %s", &ln, &li, buf) == 3) {
- lineno = ln - li;
- lineinc = li;
- strncpy (currentfile, buf, FILENAME_MAX-1);
- currentfile[FILENAME_MAX-1] = '\0';
+ long linnum = prior_linnum += lineinc;
+ int altline = src_get(&linnum, &file_name);
+ if (altline) {
+ if (altline==1 && lineinc==1)
+ nasm_fputs("", ofile);
+ else {
+ lineinc = (altline != -1 || lineinc!=1);
+ fprintf(ofile ? ofile : stdout, "%%line %ld+%d %s\n",
+ linnum, lineinc, file_name);
+ }
+ prior_linnum = linnum;
}
- if (ofile) {
- fputs(line, ofile);
- fputc('\n', ofile);
- } else
- puts(line);
+ nasm_fputs(line, ofile);
nasm_free (line);
}
+ nasm_free(file_name);
preproc->cleanup();
if (ofile)
fclose(ofile);
if (ofile && terminate_after_phase)
remove(outname);
- } else {
+ }
+ else /* NOT preprocess only */
+ {
/*
* We must call ofmt->filename _anyway_, even if the user
* has specified their own output file, because some
report_error (ERR_FATAL | ERR_NOFILE,
"unable to open output file `%s'", outname);
}
+
/*
* We must call init_labels() before ofmt->init() since
* some object formats will want to define labels in their
* init routines. (eg OS/2 defines the FLAT group)
*/
init_labels ();
+
ofmt->init (ofile, report_error, define_label, evaluate);
+
assemble_file (inname);
+
if (!terminate_after_phase) {
- ofmt->cleanup ();
+ ofmt->cleanup (using_debug_info);
cleanup_labels ();
}
- /*
- * We had an fclose on the output file here, but we
- * actually do that in all the object file drivers as well,
- * so we're leaving out the one here.
- * fclose (ofile);
- */
- if (terminate_after_phase) {
+ else {
+
+ /*
+ * We had an fclose on the output file here, but we
+ * actually do that in all the object file drivers as well,
+ * so we're leaving out the one here.
+ * fclose (ofile);
+ */
+
remove(outname);
if (listname[0])
remove(listname);
if (want_usage)
usage();
+
raa_free (offsets);
saa_free (forwrefs);
+ eval_cleanup ();
+ nasmlib_cleanup ();
if (terminate_after_phase)
return 1;
return 0;
}
-static int process_arg (char *p, char *q) {
+
+/*
+ * Get a parameter for a command line option.
+ * First arg must be in the form of e.g. -f...
+ */
+static char *get_param (char *p, char *q, int *advance)
+{
+ *advance = 0;
+ if (p[2]) /* the parameter's in the option */
+ {
+ p += 2;
+ while (isspace(*p))
+ p++;
+ return p;
+ }
+ if (q && q[0])
+ {
+ *advance = 1;
+ return q;
+ }
+ report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
+ "option `-%c' requires an argument",
+ p[1]);
+ return NULL;
+}
+
+int stopoptions = 0;
+static int process_arg (char *p, char *q)
+{
char *param;
- int i;
- int advance = 0;
+ int i, advance = 0;
if (!p || !p[0])
return 0;
- if (p[0]=='-') {
+ if (p[0]=='-' && ! stopoptions)
+ {
switch (p[1]) {
- case 's':
- use_stdout = TRUE;
- break;
+ case '-': /* -- => stop processing options */
+ stopoptions = 1;
+ break;
+ case 's': /* silently ignored for compatibility */
+ break;
case 'o': /* these parameters take values */
case 'f':
case 'p':
case 'd':
case 'i':
case 'l':
- if (p[2]) /* the parameter's in the option */
- param = p+2;
- else if (!q) {
- report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
- "option `-%c' requires an argument",
- p[1]);
+ case 'F':
+ if ( !(param = get_param (p, q, &advance)) )
break;
- } else
- advance = 1, param = q;
if (p[1]=='o') { /* output file */
strcpy (outname, param);
} else if (p[1]=='f') { /* output format */
ofmt = ofmt_find(param);
if (!ofmt) {
report_error (ERR_FATAL | ERR_NOFILE | ERR_USAGE,
- "unrecognised output format `%s'",
+ "unrecognised output format `%s' - "
+ "use -hf for a list",
param);
}
+ else
+ ofmt->current_dfmt = ofmt->debug_formats[0];
} else if (p[1]=='p') { /* pre-include */
pp_pre_include (param);
} else if (p[1]=='d') { /* pre-define */
pp_include_path (param);
} else if (p[1]=='l') { /* listing file */
strcpy (listname, param);
- }
+ } else if (p[1] == 'F') { /* specify debug format */
+ ofmt->current_dfmt = dfmt_find(ofmt, param);
+ if (!ofmt->current_dfmt) {
+ report_error (ERR_FATAL | ERR_NOFILE | ERR_USAGE,
+ "unrecognized debug format `%s' for"
+ " output format `%s'",
+ param, ofmt->shortname);
+ }
+ }
+ break;
+ case 'g':
+ using_debug_info = TRUE;
break;
case 'h':
- fprintf(use_stdout ? stdout : stderr,
- "usage: nasm [-o outfile] [-f format] [-l listfile]"
- " [options...] filename\n");
- fprintf(use_stdout ? stdout : stderr,
- " or nasm -r for version info\n\n");
- fprintf(use_stdout ? stdout : stderr,
- " -e means preprocess only; "
- "-a means don't preprocess\n");
- fprintf(use_stdout ? stdout : stderr,
- " -s means send errors to stdout not stderr\n");
- fprintf(use_stdout ? stdout : stderr,
- " -i<path> adds a pathname to the include file"
- " path\n -p<file> pre-includes a file;"
- " -d<macro>[=<value] pre-defines a macro\n");
- fprintf(use_stdout ? stdout : stderr,
- " -w+foo enables warnings about foo; "
- "-w-foo disables them\n where foo can be:\n");
+ printf("usage: nasm [-@ response file] [-o outfile] [-f format] "
+ "[-l listfile]\n"
+ " [options...] [--] filename\n");
+ printf(" or nasm -r for version info\n\n");
+ printf(" -e preprocess only (writes output to "
+ "stdout by default)\n"
+ " -a don't preprocess\n\n");
+ printf(" -g enable debug info\n"
+ " -F format select a debugging format\n\n");
+ printf(" -i<path> adds a pathname to the include file path\n"
+ " -p<file> pre-includes a file\n"
+ " -d<macro>[=<value>] pre-defines a macro\n");
+ printf(" -w+foo enables warnings about foo; "
+ "-w-foo disables them\n where foo can be:\n");
for (i=1; i<=ERR_WARN_MAX; i++)
- fprintf(use_stdout ? stdout : stderr,
- " %-16s%s (default %s)\n",
- suppressed_names[i], suppressed_what[i],
- suppressed[i] ? "off" : "on");
- fprintf(use_stdout ? stdout : stderr,
- "\nvalid output formats for -f are"
- " (`*' denotes default):\n");
- ofmt_list(ofmt, use_stdout ? stdout : stderr);
+ printf(" %-16s%s (default %s)\n",
+ suppressed_names[i], suppressed_what[i],
+ suppressed[i] ? "off" : "on");
+ printf ("\nresponse files should contain command line parameters"
+ ", one per line.\n");
+ if (p[2] == 'f') {
+ printf("\nvalid output formats for -f are"
+ " (`*' denotes default):\n");
+ ofmt_list(ofmt, stdout);
+ }
+ else {
+ printf ("\nFor a list of valid output formats, use -hf.\n");
+ printf ("For a list of debug formats, use -f <form> -y.\n");
+ }
exit (0); /* never need usage message here */
break;
+ case 'y':
+ printf("\nvalid debug formats for '%s' output format are"
+ " ('*' denotes default):\n",
+ ofmt->shortname);
+ dfmt_list(ofmt, stdout);
+ exit(0);
+ break;
case 'r':
- fprintf(use_stdout ? stdout : stderr,
- "NASM version %s\n", NASM_VER);
+ printf("NASM version %s\n", NASM_VER);
+#ifdef DEBUG
+ printf("Compiled with -DDEBUG on " __DATE__ "\n");
+#endif
exit (0); /* never need usage message here */
break;
case 'e': /* preprocess only */
}
break;
default:
- report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
+ if (!ofmt->setinfo(GI_SWITCH,&p))
+ report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"unrecognised option `-%c'",
p[1]);
break;
}
- } else {
+ }
+ else
+ {
if (*inname) {
report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
"more than one input file specified");
return advance;
}
-static void parse_cmdline(int argc, char **argv) {
- char *envreal, *envcopy, *p, *q, *arg, *prevarg;
+#define ARG_BUF_DELTA 128
+
+static void process_respfile (FILE *rfile)
+{
+ char *buffer, *p, *q, *prevarg;
+ int bufsize, prevargsize;
+
+ bufsize = prevargsize = ARG_BUF_DELTA;
+ buffer = nasm_malloc(ARG_BUF_DELTA);
+ prevarg = nasm_malloc(ARG_BUF_DELTA);
+ prevarg[0] = '\0';
+
+ while (1) { /* Loop to handle all lines in file */
+
+ p = buffer;
+ while (1) { /* Loop to handle long lines */
+ q = fgets(p, bufsize-(p-buffer), rfile);
+ if (!q)
+ break;
+ p += strlen(p);
+ if (p > buffer && p[-1] == '\n')
+ break;
+ if (p-buffer > bufsize-10) {
+ int offset;
+ offset = p - buffer;
+ bufsize += ARG_BUF_DELTA;
+ buffer = nasm_realloc(buffer, bufsize);
+ p = buffer + offset;
+ }
+ }
+
+ if (!q && p == buffer) {
+ if (prevarg[0])
+ process_arg (prevarg, NULL);
+ nasm_free (buffer);
+ nasm_free (prevarg);
+ return;
+ }
+
+ /*
+ * Play safe: remove CRs, LFs and any spurious ^Zs, if any of
+ * them are present at the end of the line.
+ */
+ *(p = &buffer[strcspn(buffer, "\r\n\032")]) = '\0';
+
+ while (p > buffer && isspace(p[-1]))
+ *--p = '\0';
+
+ p = buffer;
+ while (isspace(*p))
+ p++;
+
+ if (process_arg (prevarg, p))
+ *p = '\0';
+
+ if (strlen(p) > prevargsize-10) {
+ prevargsize += ARG_BUF_DELTA;
+ prevarg = nasm_realloc(prevarg, prevargsize);
+ }
+ strcpy (prevarg, p);
+ }
+}
+
+static void parse_cmdline(int argc, char **argv)
+{
+ FILE *rfile;
+ char *envreal, *envcopy=NULL, *p, *q, *arg, *prevarg;
char separator = ' ';
*inname = *outname = *listname = '\0';
if (process_arg (prevarg, arg))
arg = NULL;
}
+ if (arg)
+ process_arg (arg, NULL);
nasm_free (envcopy);
}
- if (arg)
- process_arg (arg, NULL);
/*
* Now process the actual command line.
*/
- while (--argc) {
+ while (--argc)
+ {
int i;
argv++;
- i = process_arg (argv[0], argc > 1 ? argv[1] : NULL);
+ if (!stopoptions && argv[0][0] == '-' && argv[0][1] == '@') {
+ if ((p = get_param (argv[0], argc > 1 ? argv[1] : NULL, &i)))
+ if ((rfile = fopen(p, "r"))) {
+ process_respfile (rfile);
+ fclose(rfile);
+ } else
+ report_error (ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
+ "unable to open response file `%s'", p);
+ } else
+ i = process_arg (argv[0], argc > 1 ? argv[1] : NULL);
argv += i, argc -= i;
}
"no input file specified");
}
-static void assemble_file (char *fname) {
- char *value, *p, *q, *special, *line;
- insn output_ins;
- int i, rn_error, validid;
- long seg, offs;
+static void assemble_file (char *fname)
+{
+ char * value, * p, * q, * special, * line, debugid[80];
+ insn output_ins;
+ int i, rn_error, validid;
+ long seg, offs;
struct tokenval tokval;
- expr *e;
+ expr * e;
- /* pass one */
+ /*
+ * pass one
+ */
pass = 1;
- current_seg = ofmt->section(NULL, pass, &sb);
+ in_abs_seg = FALSE;
+ location.segment = ofmt->section(NULL, pass, &sb);
preproc->reset(fname, 1, report_error, evaluate, &nasmlist);
- strcpy(currentfile,fname);
- lineno = 0;
- lineinc = 1;
globallineno = 0;
- offs = get_curr_ofs;
- eval_info (NULL, current_seg, offs); /* set $ */
- while ( (line = preproc->getline()) ) {
- lineno += lineinc;
- globallineno++;
+ location.known = TRUE;
+ location.offset = offs = get_curr_ofs;
- if (line[0] == '%') {
- int ln, li;
- char buf[FILENAME_MAX];
-
- /*
- * This will be a line number directive. They come
- * straight from the preprocessor, so we'll subject
- * them to only minimal error checking.
- */
- if (strncmp(line, "%line", 5)) {
- if (preproc == &no_pp)
- report_error (ERR_WARNING, "unknown `%%' directive in "
- " preprocessed source");
- } else if (sscanf(line, "%%line %d+%d %s", &ln, &li, buf) != 3) {
- report_error (ERR_WARNING, "bogus line number directive in"
- " preprocessed source");
- } else {
- lineno = ln - li;
- lineinc = li;
- strncpy (currentfile, buf, FILENAME_MAX-1);
- currentfile[FILENAME_MAX-1] = '\0';
- }
- continue;
- }
+ while ( (line = preproc->getline()) )
+ {
+ globallineno++;
/* here we parse our directives; this is not handled by the 'real'
* parser. */
- if ( (i = getkw (line, &value)) ) {
+ if ( (i = getkw (line, &value)) )
+ {
switch (i) {
case 1: /* [SEGMENT n] */
seg = ofmt->section (value, pass, &sb);
"segment name `%s' not recognised",
value);
} else {
- current_seg = seg;
+ in_abs_seg = FALSE;
+ location.segment = seg;
}
break;
case 2: /* [EXTERN label:special] */
" COMMON declaration");
break;
case 6: /* [ABSOLUTE address] */
- current_seg = NO_SEG;
stdscan_reset();
stdscan_bufptr = value;
tokval.t_type = TOKEN_INVALID;
}
} else
abs_offset = 0x100;/* don't go near zero in case of / */
+ in_abs_seg = TRUE;
+ location.segment = abs_seg;
+ break;
+ case 7:
+ p = value;
+ validid = TRUE;
+ if (!isidstart(*p))
+ validid = FALSE;
+ while (*p && !isspace(*p)) {
+ if (!isidchar(*p))
+ validid = FALSE;
+ p++;
+ }
+ if (!validid) {
+ report_error (ERR_NONFATAL,
+ "identifier expected after DEBUG");
+ break;
+ }
+ while (*p && isspace(*p)) p++;
break;
default:
if (!ofmt->directive (line+1, value, 1))
line+1);
break;
}
- } else {
+ }
+ else /* it isn't a directive */
+ {
parse_line (1, line, &output_ins,
- report_error, evaluate, eval_info);
- if (output_ins.forw_ref)
- *(int *)saa_wstruct(forwrefs) = globallineno;
-
- /*
- * Hack to prevent phase error in the code
- * rol ax,x
- * x equ 1
- *
- * We rule that the presence of a forward reference
- * cancels out the UNITY property of the number 1. This
- * isn't _strictly_ necessary in pass one, since the
- * problem occurs in pass two, but for the sake of
- * having the passes as near to identical as we can
- * manage, we do it like this.
- */
- if (output_ins.forw_ref) {
- int i;
- for (i=0; i<output_ins.operands; i++)
- output_ins.oprs[i].type &= ~ONENESS;
+ report_error, evaluate, define_label);
+
+ if (output_ins.forw_ref)
+ {
+ for(i = 0; i < output_ins.operands; i++)
+ {
+ if (output_ins.oprs[i].opflags & OPFLAG_FORWARD)
+ {
+ struct forwrefinfo *fwinf =
+ (struct forwrefinfo *)saa_wstruct(forwrefs);
+ fwinf->lineno = globallineno;
+ fwinf->operand = i;
+ }
+ }
}
- if (output_ins.opcode == I_EQU) {
+ if (output_ins.opcode == I_EQU)
+ {
/*
* Special `..' EQUs get processed in pass two,
* except `..@' macro-processor EQUs which are done
if (!output_ins.label)
report_error (ERR_NONFATAL,
"EQU not preceded by label");
+
+ /*
+ * EQU cannot be used to declare a label relative to
+ * an external symbol.
+ */
+ else if ((output_ins.oprs[0].opflags & OPFLAG_EXTERN)
+ || (output_ins.operands > 1
+ && (output_ins.oprs[1].opflags & OPFLAG_EXTERN)))
+ {
+ report_error (ERR_NONFATAL,
+ "EQU used relative to external symbol");
+ }
+
else if (output_ins.label[0] != '.' ||
output_ins.label[1] != '.' ||
- output_ins.label[2] == '@') {
+ output_ins.label[2] == '@')
+ {
if (output_ins.operands == 1 &&
(output_ins.oprs[0].type & IMMEDIATE) &&
- output_ins.oprs[0].wrt == NO_SEG) {
+ output_ins.oprs[0].wrt == NO_SEG)
+ {
define_label (output_ins.label,
output_ins.oprs[0].segment,
output_ins.oprs[0].offset,
NULL, FALSE, FALSE, ofmt, report_error);
- } else if (output_ins.operands == 2 &&
+ }
+ else if (output_ins.operands == 2 &&
(output_ins.oprs[0].type & IMMEDIATE) &&
(output_ins.oprs[0].type & COLON) &&
output_ins.oprs[0].segment == NO_SEG &&
output_ins.oprs[0].wrt == NO_SEG &&
(output_ins.oprs[1].type & IMMEDIATE) &&
output_ins.oprs[1].segment == NO_SEG &&
- output_ins.oprs[1].wrt == NO_SEG) {
+ output_ins.oprs[1].wrt == NO_SEG)
+ {
define_label (output_ins.label,
output_ins.oprs[0].offset | SEG_ABS,
output_ins.oprs[1].offset,
NULL, FALSE, FALSE, ofmt, report_error);
- } else
+ }
+ else
report_error(ERR_NONFATAL, "bad syntax for EQU");
}
- } else {
- if (output_ins.label)
- define_label (output_ins.label,
- current_seg==NO_SEG ? abs_seg : current_seg,
- offs, NULL, TRUE, FALSE, ofmt, report_error);
- offs += insn_size (current_seg, offs, sb,
+ }
+ else /* instruction isn't an EQU */
+ {
+ long l = insn_size (location.segment, offs, sb,
&output_ins, report_error);
- set_curr_ofs (offs);
+ if (using_debug_info && output_ins.opcode != -1) {
+ /* this is done here so we can do debug type info */
+ long typeinfo = TYS_ELEMENTS(output_ins.operands);
+ switch (output_ins.opcode) {
+ case I_RESB:
+ typeinfo = TYS_ELEMENTS(output_ins.oprs[0].offset) | TY_BYTE;
+ break;
+ case I_RESW:
+ typeinfo = TYS_ELEMENTS(output_ins.oprs[0].offset) | TY_WORD;
+ break;
+ case I_RESD:
+ typeinfo = TYS_ELEMENTS(output_ins.oprs[0].offset) | TY_DWORD;
+ break;
+ case I_RESQ:
+ typeinfo = TYS_ELEMENTS(output_ins.oprs[0].offset) | TY_QWORD;
+ break;
+ case I_REST:
+ typeinfo = TYS_ELEMENTS(output_ins.oprs[0].offset) | TY_TBYTE;
+ break;
+ case I_DB:
+ typeinfo |= TY_BYTE;
+ break;
+ case I_DW:
+ typeinfo |= TY_WORD;
+ break;
+ case I_DD:
+ if (output_ins.eops_float)
+ typeinfo |= TY_FLOAT;
+ else
+ typeinfo |= TY_DWORD;
+ break;
+ case I_DQ:
+ typeinfo |= TY_QWORD;
+ break;
+ case I_DT:
+ typeinfo |= TY_TBYTE;
+ break;
+ default:
+ typeinfo = TY_LABEL;
+ }
+ ofmt->current_dfmt->debug_typevalue(typeinfo);
+ }
+ if (l != -1) {
+ offs += l;
+ set_curr_ofs (offs);
+ }
+ /*
+ * else l == -1 => invalid instruction, which will be
+ * flagged as an error on pass 2
+ */
}
cleanup_insn (&output_ins);
}
nasm_free (line);
- offs = get_curr_ofs;
- eval_info (NULL, current_seg, offs); /* set $ */
+ location.offset = offs = get_curr_ofs;
}
+
preproc->cleanup();
if (terminate_after_phase) {
exit (1);
}
- /* pass two */
+ /*
+ * pass two
+ */
+
pass = 2;
saa_rewind (forwrefs);
if (*listname)
nasmlist.init(listname, report_error);
- {
- int *p = saa_rstruct (forwrefs);
- if (p)
- forwline = *p;
- else
- forwline = -1;
- }
- current_seg = ofmt->section(NULL, pass, &sb);
+ forwref = saa_rstruct (forwrefs);
+ in_abs_seg = FALSE;
+ location.segment = ofmt->section(NULL, pass, &sb);
raa_free (offsets);
offsets = raa_init();
preproc->reset(fname, 2, report_error, evaluate, &nasmlist);
- strcpy(currentfile,fname);
- lineno = 0;
- lineinc = 1;
globallineno = 0;
- offs = get_curr_ofs;
- eval_info (NULL, current_seg, offs); /* set $ */
- while ( (line = preproc->getline()) ) {
- lineno += lineinc;
- globallineno++;
-
- if (line[0] == '%') {
- int ln, li;
- char buf[FILENAME_MAX];
+ location.offset = offs = get_curr_ofs;
- /*
- * This will be a line number directive. They come
- * straight from the preprocessor, so we'll subject
- * them to only minimal error checking.
- */
- if (!strncmp(line, "%line", 5) &&
- sscanf(line, "%%line %d+%d %s", &ln, &li, buf) == 3) {
- lineno = ln - li;
- lineinc = li;
- strncpy (currentfile, buf, FILENAME_MAX-1);
- currentfile[FILENAME_MAX-1] = '\0';
- }
- continue;
- }
+ while ( (line = preproc->getline()) )
+ {
+ globallineno++;
/* here we parse our directives; this is not handled by
* the 'real' parser. */
report_error (ERR_PANIC,
"invalid segment name on pass two");
} else
- current_seg = seg;
+ in_abs_seg = FALSE;
+ location.segment = seg;
break;
case 2: /* [EXTERN label] */
q = value;
}
break;
case 6: /* [ABSOLUTE addr] */
- current_seg = NO_SEG;
stdscan_reset();
stdscan_bufptr = value;
tokval.t_type = TOKEN_INVALID;
} else
report_error (ERR_PANIC, "invalid ABSOLUTE address "
"in pass two");
+ in_abs_seg = TRUE;
+ location.segment = abs_seg;
+ break;
+ case 7:
+ p = value;
+ q = debugid;
+ validid = TRUE;
+ if (!isidstart(*p))
+ validid = FALSE;
+ while (*p && !isspace(*p)) {
+ if (!isidchar(*p))
+ validid = FALSE;
+ *q++ = *p++;
+ }
+ *q++ = 0;
+ if (!validid) {
+ report_error (ERR_PANIC,
+ "identifier expected after DEBUG in pass 2");
+ break;
+ }
+ while (*p && isspace(*p))
+ p++;
+ ofmt->current_dfmt->debug_directive (debugid, p);
break;
default:
if (!ofmt->directive (line+1, value, 2))
report_error (ERR_PANIC, "invalid directive on pass two");
break;
}
- } else {
+ }
+ else /* not a directive */
+ {
parse_line (2, line, &output_ins,
- report_error, evaluate, eval_info);
- if (globallineno == forwline) {
- int *p = saa_rstruct (forwrefs);
- if (p)
- forwline = *p;
- else
- forwline = -1;
+ report_error, evaluate, redefine_label);
+ if (forwref != NULL && globallineno == forwref->lineno) {
output_ins.forw_ref = TRUE;
+ do {
+ output_ins.oprs[forwref->operand].opflags|= OPFLAG_FORWARD;
+ forwref = saa_rstruct (forwrefs);
+ } while (forwref != NULL && forwref->lineno == globallineno);
} else
output_ins.forw_ref = FALSE;
* Hack to prevent phase error in the code
* rol ax,x
* x equ 1
+ *
+ * If the second operand is a forward reference,
+ * the UNITY property of the number 1 in that
+ * operand is cancelled. Otherwise the above
+ * sequence will cause a phase error.
+ *
+ * This hack means that the above code will
+ * generate 286+ code.
+ *
+ * The forward reference will mean that the
+ * operand will not have the UNITY property on
+ * the first pass, so the pass behaviours will
+ * be consistent.
*/
- if (output_ins.forw_ref) {
- int i;
- for (i=0; i<output_ins.operands; i++)
- output_ins.oprs[i].type &= ~ONENESS;
+
+ if (output_ins.forw_ref &&
+ output_ins.operands >= 2 &&
+ (output_ins.oprs[1].opflags & OPFLAG_FORWARD))
+ {
+ output_ins.oprs[1].type &= ~ONENESS;
}
- obuf = line;
- if (output_ins.label)
- define_label_stub (output_ins.label, report_error);
- if (output_ins.opcode == I_EQU) {
+ if (output_ins.opcode == I_EQU)
+ {
/*
* Special `..' EQUs get processed here, except
* `..@' macro processor EQUs which are done above.
*/
if (output_ins.label[0] == '.' &&
output_ins.label[1] == '.' &&
- output_ins.label[2] != '@') {
+ output_ins.label[2] != '@')
+ {
if (output_ins.operands == 1 &&
(output_ins.oprs[0].type & IMMEDIATE)) {
define_label (output_ins.label,
output_ins.oprs[0].segment,
output_ins.oprs[0].offset,
NULL, FALSE, FALSE, ofmt, report_error);
- } else if (output_ins.operands == 2 &&
+ }
+ else if (output_ins.operands == 2 &&
(output_ins.oprs[0].type & IMMEDIATE) &&
(output_ins.oprs[0].type & COLON) &&
output_ins.oprs[0].segment == NO_SEG &&
(output_ins.oprs[1].type & IMMEDIATE) &&
- output_ins.oprs[1].segment == NO_SEG) {
+ output_ins.oprs[1].segment == NO_SEG)
+ {
define_label (output_ins.label,
output_ins.oprs[0].offset | SEG_ABS,
output_ins.oprs[1].offset,
NULL, FALSE, FALSE, ofmt, report_error);
- } else
+ }
+ else
report_error(ERR_NONFATAL, "bad syntax for EQU");
}
}
- offs += assemble (current_seg, offs, sb,
+ offs += assemble (location.segment, offs, sb,
&output_ins, ofmt, report_error, &nasmlist);
cleanup_insn (&output_ins);
set_curr_ofs (offs);
}
+
nasm_free (line);
- offs = get_curr_ofs;
- eval_info (NULL, current_seg, offs); /* set $ */
+ location.offset = offs = get_curr_ofs;
}
+
preproc->cleanup();
nasmlist.cleanup();
}
-static int getkw (char *buf, char **value) {
+static int getkw (char *buf, char **value)
+{
char *p, *q;
if (*buf!='[')
return 0;
+
p = buf;
+
while (*p && *p != ']') p++;
+
if (!*p)
return 0;
+
q = p++;
+
while (*p && *p != ';') {
if (!isspace(*p))
return 0;
return 5;
if (!strcmp(p, "absolute"))
return 6;
+ if (!strcmp(p, "debug"))
+ return 7;
return -1;
}
-static void report_error (int severity, char *fmt, ...) {
+static void report_error (int severity, char *fmt, ...)
+{
va_list ap;
/*
return;
if (severity & ERR_NOFILE)
- fputs ("nasm: ", use_stdout ? stdout : stderr);
- else
- fprintf (use_stdout ? stdout : stderr, "%s:%d: ", currentfile,
- lineno + (severity & ERR_OFFBY1 ? lineinc : 0));
+ fputs ("nasm: ", stdout);
+ else {
+ char * currentfile = NULL;
+ long lineno = 0;
+ src_get (&lineno, ¤tfile);
+ fprintf (stdout, "%s:%ld: ", currentfile, lineno);
+ nasm_free (currentfile);
+ }
if ( (severity & ERR_MASK) == ERR_WARNING)
- fputs ("warning: ", use_stdout ? stdout : stderr);
+ fputs ("warning: ", stdout);
else if ( (severity & ERR_MASK) == ERR_PANIC)
- fputs ("panic: ", use_stdout ? stdout : stderr);
+ fputs ("panic: ", stdout);
va_start (ap, fmt);
- vfprintf (use_stdout ? stdout : stderr, fmt, ap);
- fputc ('\n', use_stdout ? stdout : stderr);
+ vfprintf (stdout, fmt, ap);
+ fputc ('\n', stdout);
if (severity & ERR_USAGE)
want_usage = TRUE;
}
}
-static void usage(void) {
- fputs("type `nasm -h' for help\n", use_stdout ? stdout : stderr);
+static void usage(void)
+{
+ fputs("type `nasm -h' for help\n", stdout);
}
-static void register_output_formats(void) {
- /* Flat-form binary format */
-#ifdef OF_BIN
- extern struct ofmt of_bin;
-#endif
- /* Unix formats: a.out, COFF, ELF */
-#ifdef OF_AOUT
- extern struct ofmt of_aout;
-#endif
-#ifdef OF_AOUTB
- extern struct ofmt of_aoutb;
-#endif
-#ifdef OF_COFF
- extern struct ofmt of_coff;
-#endif
-#ifdef OF_ELF
- extern struct ofmt of_elf;
-#endif
- /* Linux strange format: as86 */
-#ifdef OF_AS86
- extern struct ofmt of_as86;
-#endif
- /* DOS and DOS-ish formats: OBJ, OS/2, Win32 */
-#ifdef OF_OBJ
- extern struct ofmt of_obj;
-#endif
-#ifdef OF_WIN32
- extern struct ofmt of_win32;
-#endif
-#ifdef OF_RDF
- extern struct ofmt of_rdf;
-#endif
-#ifdef OF_DBG /* debug format must be included specifically */
- extern struct ofmt of_dbg;
-#endif
-
-#ifdef OF_BIN
- ofmt_register (&of_bin);
-#endif
-#ifdef OF_AOUT
- ofmt_register (&of_aout);
-#endif
-#ifdef OF_AOUTB
- ofmt_register (&of_aoutb);
-#endif
-#ifdef OF_COFF
- ofmt_register (&of_coff);
-#endif
-#ifdef OF_ELF
- ofmt_register (&of_elf);
-#endif
-#ifdef OF_AS86
- ofmt_register (&of_as86);
-#endif
-#ifdef OF_OBJ
- ofmt_register (&of_obj);
-#endif
-#ifdef OF_WIN32
- ofmt_register (&of_win32);
-#endif
-#ifdef OF_RDF
- ofmt_register (&of_rdf);
-#endif
-#ifdef OF_DBG
- ofmt_register (&of_dbg);
-#endif
- /*
- * set the default format
- */
- ofmt = &OF_DEFAULT;
+static void register_output_formats(void)
+{
+ ofmt = ofmt_register (report_error);
}
#define BUF_DELTA 512
static FILE *no_pp_fp;
static efunc no_pp_err;
static ListGen *no_pp_list;
+static long no_pp_lineinc;
static void no_pp_reset (char *file, int pass, efunc error, evalfunc eval,
- ListGen *listgen) {
+ ListGen *listgen)
+{
+ src_set_fname(nasm_strdup(file));
+ src_set_linnum(0);
+ no_pp_lineinc = 1;
no_pp_err = error;
no_pp_fp = fopen(file, "r");
if (!no_pp_fp)
(void) eval; /* placate compilers */
}
-static char *no_pp_getline (void) {
+static char *no_pp_getline (void)
+{
char *buffer, *p, *q;
int bufsize;
bufsize = BUF_DELTA;
buffer = nasm_malloc(BUF_DELTA);
- p = buffer;
- while (1) {
- q = fgets(p, bufsize-(p-buffer), no_pp_fp);
- if (!q)
- break;
- p += strlen(p);
- if (p > buffer && p[-1] == '\n')
- break;
- if (p-buffer > bufsize-10) {
- bufsize += BUF_DELTA;
- buffer = nasm_realloc(buffer, bufsize);
- }
- }
+ src_set_linnum(src_get_linnum() + no_pp_lineinc);
- if (!q && p == buffer) {
- nasm_free (buffer);
- return NULL;
- }
+ while (1) { /* Loop to handle %line */
- /*
- * Play safe: remove CRs as well as LFs, if any of either are
- * present at the end of the line.
- */
- while (p > buffer && (p[-1] == '\n' || p[-1] == '\r'))
- *--p = '\0';
+ p = buffer;
+ while (1) { /* Loop to handle long lines */
+ q = fgets(p, bufsize-(p-buffer), no_pp_fp);
+ if (!q)
+ break;
+ p += strlen(p);
+ if (p > buffer && p[-1] == '\n')
+ break;
+ if (p-buffer > bufsize-10) {
+ int offset;
+ offset = p - buffer;
+ bufsize += BUF_DELTA;
+ buffer = nasm_realloc(buffer, bufsize);
+ p = buffer + offset;
+ }
+ }
- /*
- * Handle spurious ^Z, which may be inserted into source files
- * by some file transfer utilities.
- */
- buffer[strcspn(buffer, "\032")] = '\0';
+ if (!q && p == buffer) {
+ nasm_free (buffer);
+ return NULL;
+ }
+
+ /*
+ * Play safe: remove CRs, LFs and any spurious ^Zs, if any of
+ * them are present at the end of the line.
+ */
+ buffer[strcspn(buffer, "\r\n\032")] = '\0';
+
+ if (!strncmp(buffer, "%line", 5)) {
+ long ln;
+ int li;
+ char *nm = nasm_malloc(strlen(buffer));
+ if (sscanf(buffer+5, "%ld+%d %s", &ln, &li, nm) == 3) {
+ nasm_free( src_set_fname(nm) );
+ src_set_linnum(ln);
+ no_pp_lineinc = li;
+ continue;
+ }
+ nasm_free(nm);
+ }
+ break;
+ }
no_pp_list->line (LIST_READ, buffer);
return buffer;
}
-static void no_pp_cleanup (void) {
+static void no_pp_cleanup (void)
+{
fclose(no_pp_fp);
}
#define NASM_NASM_H
#define NASM_MAJOR_VER 0
-#define NASM_MINOR_VER 97
-#define NASM_VER "0.97"
+#define NASM_MINOR_VER 98
+#define NASM_VER "0.98 pre-release 3"
#ifndef NULL
#define NULL 0
#define ERR_MASK 0x0F /* mask off the above codes */
#define ERR_NOFILE 0x10 /* don't give source file name/line */
#define ERR_USAGE 0x20 /* print a usage message */
-#define ERR_OFFBY1 0x40 /* report error as being on the line
- * we're just _about_ to read, not
- * the one we've just read */
#define ERR_PASS1 0x80 /* only print this error on pass one */
/*
TOKEN_FLOAT /* floating-point constant */
};
+typedef struct {
+ long segment;
+ long offset;
+ int known;
+} loc_t;
+
/*
* Expression-evaluator datatype. Expressions, within the
* evaluator, are stored as an array of these beasts, terminated by
struct eval_hints *hints);
/*
- * There's also an auxiliary routine through which the evaluator
- * needs to hear about the value of $ and the label (if any)
- * defined on the current line.
- */
-typedef void (*evalinfofunc) (char *labelname, long segment, long offset);
-
-/*
* Special values for expr->type. ASSUMPTION MADE HERE: the number
* of distinct register names (i.e. possible "type" fields for an
* expr structure) does not exceed 124 (EXPR_REG_START through
* ----------------------------------------------------------------
*/
-/* isidstart matches any character that may start an identifier, and isidchar
+/*
+ * isidstart matches any character that may start an identifier, and isidchar
* matches any character that may appear at places other than the start of an
* identifier. E.g. a period may only appear at the start of an identifier
* (for local labels), whereas a number may appear anywhere *but* at the
- * start. */
+ * start.
+ */
#define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
|| (c)=='@' )
I_FCMOVBE, I_FCMOVE, I_FCMOVNB, I_FCMOVNBE, I_FCMOVNE,
I_FCMOVNU, I_FCMOVU, I_FCOM, I_FCOMI, I_FCOMIP, I_FCOMP,
I_FCOMPP, I_FCOS, I_FDECSTP, I_FDISI, I_FDIV, I_FDIVP, I_FDIVR,
- I_FDIVRP, I_FENI, I_FFREE, I_FIADD, I_FICOM, I_FICOMP, I_FIDIV,
+ I_FDIVRP,
+ I_FEMMS,
+ I_FENI, I_FFREE, I_FIADD, I_FICOM, I_FICOMP, I_FIDIV,
I_FIDIVR, I_FILD, I_FIMUL, I_FINCSTP, I_FINIT, I_FIST, I_FISTP,
I_FISUB, I_FISUBR, I_FLD, I_FLD1, I_FLDCW, I_FLDENV, I_FLDL2E,
I_FLDL2T, I_FLDLG2, I_FLDLN2, I_FLDPI, I_FLDZ, I_FMUL, I_FMULP,
I_FUCOMI, I_FUCOMIP, I_FUCOMP, I_FUCOMPP, I_FXAM, I_FXCH,
I_FXTRACT, I_FYL2X, I_FYL2XP1, I_HLT, I_IBTS, I_ICEBP, I_IDIV,
I_IMUL, I_IN, I_INC, I_INCBIN, I_INSB, I_INSD, I_INSW, I_INT,
- I_INT1, I_INT01, I_INT3, I_INTO, I_INVD, I_INVLPG, I_IRET,
+ I_INT01, I_INT1, I_INT3, I_INTO, I_INVD, I_INVLPG, I_IRET,
I_IRETD, I_IRETW, I_JCXZ, I_JECXZ, I_JMP, I_LAHF, I_LAR, I_LDS,
I_LEA, I_LEAVE, I_LES, I_LFS, I_LGDT, I_LGS, I_LIDT, I_LLDT,
I_LMSW, I_LOADALL, I_LOADALL286, I_LODSB, I_LODSD, I_LODSW,
I_MOVSX, I_MOVZX, I_MUL, I_NEG, I_NOP, I_NOT, I_OR, I_OUT,
I_OUTSB, I_OUTSD, I_OUTSW, I_PACKSSDW, I_PACKSSWB, I_PACKUSWB,
I_PADDB, I_PADDD, I_PADDSB, I_PADDSIW, I_PADDSW, I_PADDUSB,
- I_PADDUSW, I_PADDW, I_PAND, I_PANDN, I_PAVEB, I_PCMPEQB,
+ I_PADDUSW, I_PADDW, I_PAND, I_PANDN, I_PAVEB,
+ I_PAVGUSB, I_PCMPEQB,
I_PCMPEQD, I_PCMPEQW, I_PCMPGTB, I_PCMPGTD, I_PCMPGTW,
- I_PDISTIB, I_PMACHRIW, I_PMADDWD, I_PMAGW, I_PMULHRW,
- I_PMULHRIW, I_PMULHW, I_PMULLW, I_PMVGEZB, I_PMVLZB, I_PMVNZB,
+ I_PDISTIB,
+ I_PF2ID, I_PFACC, I_PFADD, I_PFCMPEQ, I_PFCMPGE, I_PFCMPGT,
+ I_PFMAX, I_PFMIN, I_PFMUL, I_PFRCP, I_PFRCPIT1, I_PFRCPIT2,
+ I_PFRSQIT1, I_PFRSQRT, I_PFSUB, I_PFSUBR, I_PI2FD,
+ I_PMACHRIW, I_PMADDWD, I_PMAGW, I_PMULHRIW, I_PMULHRWA,
+ I_PMULHRWC, I_PMULHW, I_PMULLW, I_PMVGEZB, I_PMVLZB, I_PMVNZB,
I_PMVZB, I_POP, I_POPA, I_POPAD, I_POPAW, I_POPF, I_POPFD,
- I_POPFW, I_POR, I_PSLLD, I_PSLLQ, I_PSLLW, I_PSRAD, I_PSRAW,
+ I_POPFW, I_POR, I_PREFETCH, I_PREFETCHW,
+ I_PSLLD, I_PSLLQ, I_PSLLW, I_PSRAD, I_PSRAW,
I_PSRLD, I_PSRLQ, I_PSRLW, I_PSUBB, I_PSUBD, I_PSUBSB,
I_PSUBSIW, I_PSUBSW, I_PSUBUSB, I_PSUBUSW, I_PSUBW, I_PUNPCKHBW,
I_PUNPCKHDQ, I_PUNPCKHWD, I_PUNPCKLBW, I_PUNPCKLDQ, I_PUNPCKLWD,
I_XOR, I_CMOVcc, I_Jcc, I_SETcc
};
+#define MAX_KEYWORD 9 /* max length of any instruction, register name etc. */
+
enum { /* condition code names */
C_A, C_AE, C_B, C_BE, C_C, C_E, C_G, C_GE, C_L, C_LE, C_NA, C_NAE,
C_NB, C_NBE, C_NC, C_NE, C_NG, C_NGE, C_NL, C_NLE, C_NO, C_NP,
long offset; /* any immediate number */
long wrt; /* segment base it's relative to */
int eaflags; /* special EA flags */
+ int opflags; /* see OPFLAG_* defines below */
} operand;
+#define OPFLAG_FORWARD 1 /* operand is a forward reference */
+#define OPFLAG_EXTERN 2 /* operand is an external reference */
+
typedef struct extop { /* extended operand */
struct extop *next; /* linked list */
long type; /* defined above */
int nprefix; /* number of entries in above */
int opcode; /* the opcode - not just the string */
int condition; /* the condition code, if Jcc/SETcc */
- int operands; /* how many operands? 0-3 */
+ int operands; /* how many operands? 0-3
+ * (more if db et al) */
operand oprs[3]; /* the operands, defined as above */
extop *eops; /* extended operands */
+ int eops_float; /* true if DD and floating */
long times; /* repeat count (TIMES prefix) */
int forw_ref; /* is there a forward reference? */
} insn;
+enum geninfo { GI_SWITCH };
/*
* ------------------------------------------------------------
* The data structure defining an output format driver, and the
char *shortname;
/*
+ * this is reserved for out module specific help.
+ * It is set to NULL in all the out modules but is not implemented
+ * in the main program
+ */
+ char *helpstring;
+
+ /*
+ * this is a pointer to the first element of the debug information
+ */
+ struct dfmt **debug_formats;
+
+ /*
+ * and a pointer to the element that is being used
+ * note: this is set to the default at compile time and changed if the
+ * -F option is selected. If developing a set of new debug formats for
+ * an output format, be sure to set this to whatever default you want
+ *
+ */
+ struct dfmt *current_dfmt;
+
+ /*
* This, if non-NULL, is a NULL-terminated list of `char *'s
* pointing to extra standard macros supplied by the object
* format (e.g. a sensible initial default value of __SECT__,
void (*init) (FILE *fp, efunc error, ldfunc ldef, evalfunc eval);
/*
+ * This procedure is called to pass generic information to the
+ * object file. The first parameter gives the information type
+ * (currently only command line switches)
+ * and the second parameter gives the value. This function returns
+ * 1 if recognized, 0 if unrecognized
+ */
+ int (*setinfo)(enum geninfo type, char **string);
+
+ /*
* This procedure is called by assemble() to write actual
* generated code or data to the object file. Typically it
* doesn't have to actually _write_ it, just store it for
* One thing the cleanup routine should always do is to close
* the output file pointer.
*/
- void (*cleanup) (void);
+ void (*cleanup) (int debuginfo);
};
/*
#define OUT_SIZMASK 0x0FFFFFFFUL
/*
+ * ------------------------------------------------------------
+ * The data structure defining a debug format driver, and the
+ * interfaces to the functions therein.
+ * ------------------------------------------------------------
+ */
+
+struct dfmt {
+
+ /*
+ * This is a short (one-liner) description of the type of
+ * output generated by the driver.
+ */
+ char *fullname;
+
+ /*
+ * This is a single keyword used to select the driver.
+ */
+ char *shortname;
+
+
+ /*
+ * init - called initially to set up local pointer to object format,
+ * void pointer to implementation defined data, file pointer (which
+ * probably won't be used, but who knows?), and error function.
+ */
+ void (*init) (struct ofmt * of, void * id, FILE * fp, efunc error);
+
+ /*
+ * linenum - called any time there is output with a change of
+ * line number or file.
+ */
+ void (*linenum) (const char * filename, long linenumber, long segto);
+
+ /*
+ * debug_deflabel - called whenever a label is defined. Parameters
+ * are the same as to 'symdef()' in the output format. This function
+ * would be called before the output format version.
+ */
+
+ void (*debug_deflabel) (char * name, long segment, long offset,
+ int is_global, char * special);
+ /*
+ * debug_directive - called whenever a DEBUG directive other than 'LINE'
+ * is encountered. 'directive' contains the first parameter to the
+ * DEBUG directive, and params contains the rest. For example,
+ * 'DEBUG VAR _somevar:int' would translate to a call to this
+ * function with 'directive' equal to "VAR" and 'params' equal to
+ * "_somevar:int".
+ */
+ void (*debug_directive) (const char * directive, const char * params);
+
+ /*
+ * typevalue - called whenever the assembler wishes to register a type
+ * for the last defined label. This routine MUST detect if a type was
+ * already registered and not re-register it.
+ */
+ void (*debug_typevalue) (long type);
+
+ /*
+ * debug_output - called whenever output is required
+ * 'type' is the type of info required, and this is format-specific
+ */
+ void (*debug_output) (int type, void *param);
+
+ /*
+ * cleanup - called after processing of file is complete
+ */
+ void (*cleanup) (void);
+
+};
+/*
+ * The type definition macros
+ * for debugging
+ *
+ * low 3 bits: reserved
+ * next 5 bits: type
+ * next 24 bits: number of elements for arrays (0 for labels)
+ */
+
+#define TY_UNKNOWN 0x00
+#define TY_LABEL 0x08
+#define TY_BYTE 0x10
+#define TY_WORD 0x18
+#define TY_DWORD 0x20
+#define TY_FLOAT 0x28
+#define TY_QWORD 0x30
+#define TY_TBYTE 0x38
+#define TY_COMMON 0xE0
+#define TY_SEG 0xE8
+#define TY_EXTERN 0xF0
+#define TY_EQU 0xF8
+
+#define TYM_TYPE(x) ((x) & 0xF8)
+#define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
+
+#define TYS_ELEMENTS(x) ((x) << 8)
+/*
* -----
* Other
* -----
static FILE *logfp;
#endif
-void nasm_set_malloc_error (efunc error) {
+void nasm_set_malloc_error (efunc error)
+{
nasm_malloc_error = error;
#ifdef LOGALLOC
logfp = fopen ("malloc.log", "w");
return p;
}
-int nasm_stricmp (char *s1, char *s2) {
+int nasm_stricmp (const char *s1, const char *s2)
+{
while (*s1 && toupper(*s1) == toupper(*s2))
s1++, s2++;
if (!*s1 && !*s2)
return 1;
}
-int nasm_strnicmp (char *s1, char *s2, int n) {
+int nasm_strnicmp (const char *s1, const char *s2, int n)
+{
while (n > 0 && *s1 && toupper(*s1) == toupper(*s2))
s1++, s2++, n--;
if ((!*s1 && !*s2) || n==0)
#define lib_isnumchar(c) ( isalnum(c) || (c) == '$')
#define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
-long readnum (char *str, int *error) {
+long readnum (char *str, int *error)
+{
char *r = str, *q;
long radix;
unsigned long result, checklimit;
+ int digit, last;
int warn = FALSE;
+ int sign = 1;
*error = FALSE;
while (isspace(*r)) r++; /* find start of number */
+
+ /*
+ * If the number came from make_tok_num (as a result of an %assign), it
+ * might have a '-' built into it (rather than in a preceeding token).
+ */
+ if (*r == '-')
+ {
+ r++;
+ sign = -1;
+ }
+
q = r;
while (lib_isnumchar(*q)) q++; /* find end of number */
*/
checklimit = 0x80000000UL / (radix>>1);
+ /*
+ * Calculate the highest allowable value for the last digit
+ * of a 32 bit constant... in radix 10, it is 6, otherwise it is 0
+ */
+ last = (radix == 10 ? 6 : 0);
+
result = 0;
while (*r && r < q) {
- if (*r<'0' || (*r>'9' && *r<'A') || numvalue(*r)>=radix) {
+ if (*r<'0' || (*r>'9' && *r<'A') || (digit = numvalue(*r)) >= radix)
+ {
*error = TRUE;
return 0;
}
- if (result >= checklimit)
+ if (result > checklimit ||
+ (result == checklimit && digit >= last))
+ {
warn = TRUE;
- result = radix * result + numvalue(*r);
+ }
+
+ result = radix * result + digit;
r++;
}
"numeric constant %s does not fit in 32 bits",
str);
- return result;
+ return result*sign;
+}
+
+long readstrnum (char *str, int length, int *warn)
+{
+ long charconst = 0;
+ int i;
+
+ *warn = FALSE;
+
+ str += length;
+ for (i=0; i<length; i++) {
+ if (charconst & 0xff000000UL) {
+ *warn = TRUE;
+ }
+ charconst = (charconst<<8) + (unsigned char) *--str;
+ }
+ return charconst;
}
static long next_seg;
-void seg_init(void) {
+void seg_init(void)
+{
next_seg = 0;
}
-long seg_alloc(void) {
+long seg_alloc(void)
+{
return (next_seg += 2) - 2;
}
-void fwriteshort (int data, FILE *fp) {
+void fwriteshort (int data, FILE *fp)
+{
fputc ((int) (data & 255), fp);
fputc ((int) ((data >> 8) & 255), fp);
}
-void fwritelong (long data, FILE *fp) {
+void fwritelong (long data, FILE *fp)
+{
fputc ((int) (data & 255), fp);
fputc ((int) ((data >> 8) & 255), fp);
fputc ((int) ((data >> 16) & 255), fp);
}
void standard_extension (char *inname, char *outname, char *extension,
- efunc error) {
+ efunc error)
+{
char *p, *q;
if (*outname) /* file name already exists, */
strcpy(p, extension);
}
-#define RAA_BLKSIZE 4096 /* this many longs allocated at once */
-#define RAA_LAYERSIZE 1024 /* this many _pointers_ allocated */
-
-typedef struct RAA RAA;
-typedef union RAA_UNION RAA_UNION;
-typedef struct RAA_LEAF RAA_LEAF;
-typedef struct RAA_BRANCH RAA_BRANCH;
-
-struct RAA {
- /*
- * Number of layers below this one to get to the real data. 0
- * means this structure is a leaf, holding RAA_BLKSIZE real
- * data items; 1 and above mean it's a branch, holding
- * RAA_LAYERSIZE pointers to the next level branch or leaf
- * structures.
- */
- int layers;
- /*
- * Number of real data items spanned by one position in the
- * `data' array at this level. This number is 1, trivially, for
- * a leaf (level 0): for a level 1 branch it should be
- * RAA_BLKSIZE, and for a level 2 branch it's
- * RAA_LAYERSIZE*RAA_BLKSIZE.
- */
- long stepsize;
- union RAA_UNION {
- struct RAA_LEAF {
- long data[RAA_BLKSIZE];
- } l;
- struct RAA_BRANCH {
- struct RAA *data[RAA_LAYERSIZE];
- } b;
- } u;
-};
-
#define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
#define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
#define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
-static struct RAA *real_raa_init (int layers) {
+static struct RAA *real_raa_init (int layers)
+{
struct RAA *r;
if (layers == 0) {
return r;
}
-struct RAA *raa_init (void) {
+struct RAA *raa_init (void)
+{
return real_raa_init (0);
}
-void raa_free (struct RAA *r) {
+void raa_free (struct RAA *r)
+{
if (r->layers == 0)
nasm_free (r);
else {
}
}
-long raa_read (struct RAA *r, long posn) {
+long raa_read (struct RAA *r, long posn)
+{
if (posn > r->stepsize * LAYERSIZ(r))
return 0L;
while (r->layers > 0) {
return r->u.l.data[posn];
}
-struct RAA *raa_write (struct RAA *r, long posn, long value) {
+struct RAA *raa_write (struct RAA *r, long posn, long value)
+{
struct RAA *result;
if (posn < 0)
#define SAA_MAXLEN 8192
-struct SAA {
- /*
- * members `end' and `elem_len' are only valid in first link in
- * list; `rptr' and `rpos' are used for reading
- */
- struct SAA *next, *end, *rptr;
- long elem_len, length, posn, start, rpos;
- char *data;
-};
-
-struct SAA *saa_init (long elem_len) {
+struct SAA *saa_init (long elem_len)
+{
struct SAA *s;
if (elem_len > SAA_MAXLEN)
return s;
}
-void saa_free (struct SAA *s) {
+void saa_free (struct SAA *s)
+{
struct SAA *t;
while (s) {
}
}
-void *saa_wstruct (struct SAA *s) {
+void *saa_wstruct (struct SAA *s)
+{
void *p;
if (s->end->length - s->end->posn < s->elem_len) {
return p;
}
-void saa_wbytes (struct SAA *s, void *data, long len) {
+void saa_wbytes (struct SAA *s, void *data, long len)
+{
char *d = data;
while (len > 0) {
}
}
-void saa_rewind (struct SAA *s) {
+void saa_rewind (struct SAA *s)
+{
s->rptr = s;
s->rpos = 0L;
}
-void *saa_rstruct (struct SAA *s) {
+void *saa_rstruct (struct SAA *s)
+{
void *p;
if (!s->rptr)
return p;
}
-void *saa_rbytes (struct SAA *s, long *len) {
+void *saa_rbytes (struct SAA *s, long *len)
+{
void *p;
if (!s->rptr)
return p;
}
-void saa_rnbytes (struct SAA *s, void *data, long len) {
+void saa_rnbytes (struct SAA *s, void *data, long len)
+{
char *d = data;
while (len > 0) {
}
}
-void saa_fread (struct SAA *s, long posn, void *data, long len) {
+void saa_fread (struct SAA *s, long posn, void *data, long len)
+{
struct SAA *p;
long pos;
char *cdata = data;
- if (!s->rptr || posn > s->rptr->start + s->rpos)
+ if (!s->rptr || posn < s->rptr->start)
saa_rewind (s);
- while (posn >= s->rptr->start + s->rptr->posn) {
- s->rptr = s->rptr->next;
- if (!s->rptr)
+ p = s->rptr;
+ while (posn >= p->start + p->posn) {
+ p = p->next;
+ if (!p)
return; /* what else can we do?! */
}
- p = s->rptr;
- pos = posn - s->rptr->start;
+ pos = posn - p->start;
while (len) {
- long l = s->rptr->posn - pos;
+ long l = p->posn - pos;
if (l > len)
l = len;
- memcpy (cdata, s->rptr->data+pos, l);
+ memcpy (cdata, p->data+pos, l);
len -= l;
cdata += l;
p = p->next;
return;
pos = 0L;
}
+ s->rptr = p;
}
-void saa_fwrite (struct SAA *s, long posn, void *data, long len) {
+void saa_fwrite (struct SAA *s, long posn, void *data, long len)
+{
struct SAA *p;
long pos;
char *cdata = data;
- if (!s->rptr || posn > s->rptr->start + s->rpos)
+ if (!s->rptr || posn < s->rptr->start)
saa_rewind (s);
- while (posn >= s->rptr->start + s->rptr->posn) {
- s->rptr = s->rptr->next;
- if (!s->rptr)
+ p = s->rptr;
+ while (posn >= p->start + p->posn) {
+ p = p->next;
+ if (!p)
return; /* what else can we do?! */
}
- p = s->rptr;
- pos = posn - s->rptr->start;
+ pos = posn - p->start;
while (len) {
- long l = s->rptr->posn - pos;
+ long l = p->posn - pos;
if (l > len)
l = len;
- memcpy (s->rptr->data+pos, cdata, l);
+ memcpy (p->data+pos, cdata, l);
len -= l;
cdata += l;
p = p->next;
return;
pos = 0L;
}
+ s->rptr = p;
}
-void saa_fpwrite (struct SAA *s, FILE *fp) {
+void saa_fpwrite (struct SAA *s, FILE *fp)
+{
char *data;
long len;
static int stdscan_tempsize = 0, stdscan_templen = 0;
#define STDSCAN_TEMP_DELTA 256
-static void stdscan_pop(void) {
+static void stdscan_pop(void)
+{
nasm_free (stdscan_tempstorage[--stdscan_templen]);
}
-void stdscan_reset(void) {
+void stdscan_reset(void)
+{
while (stdscan_templen > 0)
stdscan_pop();
}
-static char *stdscan_copy(char *p, int len) {
+/*
+ * Unimportant cleanup is done to avoid confusing people who are trying
+ * to debug real memory leaks
+ */
+void nasmlib_cleanup (void)
+{
+ stdscan_reset();
+ nasm_free (stdscan_tempstorage);
+}
+
+static char *stdscan_copy(char *p, int len)
+{
char *text;
text = nasm_malloc(len+1);
}
char *stdscan_bufptr = NULL;
-int stdscan (void *private_data, struct tokenval *tv) {
- char ourcopy[256], *r, *s;
+int stdscan (void *private_data, struct tokenval *tv)
+{
+ char ourcopy[MAX_KEYWORD+1], *r, *s;
+
+ (void) private_data; /* Don't warn that this parameter is unused */
while (isspace(*stdscan_bufptr)) stdscan_bufptr++;
if (!*stdscan_bufptr)
while (isidchar(*stdscan_bufptr)) stdscan_bufptr++;
tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r);
+ if (is_sym || stdscan_bufptr-r > MAX_KEYWORD)
+ return tv->t_type = TOKEN_ID;/* bypass all other checks */
+
for (s=tv->t_charptr, r=ourcopy; *s; s++)
*r++ = tolower (*s);
*r = '\0';
- if (is_sym)
- return tv->t_type = TOKEN_ID;/* bypass all other checks */
/* right, so we have an identifier sitting in temp storage. now,
* is it actually a register or instruction name, or what? */
if ((tv->t_integer=bsi(ourcopy, reg_names,
* a floating point constant
*/
stdscan_bufptr++;
- while (isnumchar(*stdscan_bufptr)) {
+ while (isnumchar(*stdscan_bufptr) ||
+ ((stdscan_bufptr[-1] == 'e' || stdscan_bufptr[-1] == 'E')
+ && (*stdscan_bufptr == '-' || *stdscan_bufptr == '+')) )
+ {
stdscan_bufptr++;
}
tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r);
} else if (*stdscan_bufptr == '\'' ||
*stdscan_bufptr == '"') {/* a char constant */
char quote = *stdscan_bufptr++, *r;
+ int rn_warn;
r = tv->t_charptr = stdscan_bufptr;
while (*stdscan_bufptr && *stdscan_bufptr != quote) stdscan_bufptr++;
tv->t_inttwo = stdscan_bufptr - r; /* store full version */
if (!*stdscan_bufptr)
return tv->t_type = TOKEN_ERRNUM; /* unmatched quotes */
- tv->t_integer = 0;
- r = stdscan_bufptr++; /* skip over final quote */
- while (quote != *--r) {
- tv->t_integer = (tv->t_integer<<8) + (unsigned char) *r;
- }
+ stdscan_bufptr++; /* skip over final quote */
+ tv->t_integer = readstrnum(r, tv->t_inttwo, &rn_warn);
+ /* FIXME: rn_warn is not checked! */
return tv->t_type = TOKEN_NUM;
} else if (*stdscan_bufptr == ';') { /* a comment has happened - stay */
return tv->t_type = 0;
* Return TRUE if the argument is a simple scalar. (Or a far-
* absolute, which counts.)
*/
-int is_simple (expr *vect) {
+int is_simple (expr *vect)
+{
while (vect->type && !vect->value)
vect++;
if (!vect->type)
* Return TRUE if the argument is a simple scalar, _NOT_ a far-
* absolute.
*/
-int is_really_simple (expr *vect) {
+int is_really_simple (expr *vect)
+{
while (vect->type && !vect->value)
vect++;
if (!vect->type)
* Return TRUE if the argument is relocatable (i.e. a simple
* scalar, plus at most one segment-base, plus possibly a WRT).
*/
-int is_reloc (expr *vect) {
+int is_reloc (expr *vect)
+{
while (vect->type && !vect->value) /* skip initial value-0 terms */
vect++;
if (!vect->type) /* trivially return TRUE if nothing */
/*
* Return TRUE if the argument contains an `unknown' part.
*/
-int is_unknown(expr *vect) {
+int is_unknown(expr *vect)
+{
while (vect->type && vect->type < EXPR_UNKNOWN)
vect++;
return (vect->type == EXPR_UNKNOWN);
* Return TRUE if the argument contains nothing but an `unknown'
* part.
*/
-int is_just_unknown(expr *vect) {
+int is_just_unknown(expr *vect)
+{
while (vect->type && !vect->value)
vect++;
return (vect->type == EXPR_UNKNOWN);
* Return the scalar part of a relocatable vector. (Including
* simple scalar vectors - those qualify as relocatable.)
*/
-long reloc_value (expr *vect) {
+long reloc_value (expr *vect)
+{
while (vect->type && !vect->value)
vect++;
if (!vect->type) return 0;
* Return the segment number of a relocatable vector, or NO_SEG for
* simple scalars.
*/
-long reloc_seg (expr *vect) {
+long reloc_seg (expr *vect)
+{
while (vect->type && (vect->type == EXPR_WRT || !vect->value))
vect++;
if (vect->type == EXPR_SIMPLE) {
* Return the WRT segment number of a relocatable vector, or NO_SEG
* if no WRT part is present.
*/
-long reloc_wrt (expr *vect) {
+long reloc_wrt (expr *vect)
+{
while (vect->type && vect->type < EXPR_WRT)
vect++;
if (vect->type == EXPR_WRT) {
/*
* Binary search.
*/
-int bsi (char *string, char **array, int size) {
+int bsi (char *string, char **array, int size)
+{
int i = -1, j = size; /* always, i < index < j */
while (j-i >= 2) {
int k = (i+j)/2;
}
return -1; /* we haven't got it :( */
}
+
+static char *file_name = NULL;
+static long line_number = 0;
+
+char *src_set_fname(char *newname)
+{
+ char *oldname = file_name;
+ file_name = newname;
+ return oldname;
+}
+
+long src_set_linnum(long newline)
+{
+ long oldline = line_number;
+ line_number = newline;
+ return oldline;
+}
+
+long src_get_linnum(void)
+{
+ return line_number;
+}
+
+int src_get(long *xline, char **xname)
+{
+ if (!file_name || !*xname || strcmp(*xname, file_name))
+ {
+ nasm_free(*xname);
+ *xname = file_name ? nasm_strdup(file_name) : NULL;
+ *xline = line_number;
+ return -2;
+ }
+ if (*xline != line_number)
+ {
+ long tmp = line_number - *xline;
+ *xline = line_number;
+ return tmp;
+ }
+ return 0;
+}
+
+void nasm_quote(char **str)
+{
+ int ln=strlen(*str);
+ char q=(*str)[0];
+ char *p;
+ if (ln>1 && (*str)[ln-1]==q && (q=='"' || q=='\''))
+ return;
+ q = '"';
+ if (strchr(*str,q))
+ q = '\'';
+ p = nasm_malloc(ln+3);
+ strcpy(p+1, *str);
+ nasm_free(*str);
+ p[ln+1] = p[0] = q;
+ p[ln+2] = 0;
+ *str = p;
+}
+
+char *nasm_strcat(char *one, char *two)
+{
+ char *rslt;
+ int l1=strlen(one);
+ rslt = nasm_malloc(l1+strlen(two)+1);
+ strcpy(rslt, one);
+ strcpy(rslt+l1, two);
+ return rslt;
+}
+
+void null_debug_routine()
+{
+}
+struct dfmt null_debug_form = {
+ "Null debug format",
+ "null",
+ null_debug_routine,
+ null_debug_routine,
+ null_debug_routine,
+ null_debug_routine,
+ null_debug_routine,
+ null_debug_routine,
+ null_debug_routine,
+};
+
+struct dfmt *null_debug_arr[2] = { &null_debug_form, NULL };
-/* nasmlib.c header file for nasmlib.h
+/* nasmlib.h header file for nasmlib.c
*
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
* Julian Hall. All rights reserved. The software is
* ANSI doesn't guarantee the presence of `stricmp' or
* `strcasecmp'.
*/
-int nasm_stricmp (char *, char *);
-int nasm_strnicmp (char *, char *, int);
+int nasm_stricmp (const char *, const char *);
+int nasm_strnicmp (const char *, const char *, int);
/*
* Convert a string into a number, using NASM number rules. Sets
long readnum(char *str, int *error);
/*
+ * Convert a character constant into a number. Sets
+ * `*warn' to TRUE if an overflow occurs, and FALSE otherwise.
+ * str points to and length covers the middle of the string,
+ * without the quotes.
+ */
+long readstrnum(char *str, int length, int *warn);
+
+/*
* seg_init: Initialise the segment-number allocator.
* seg_alloc: allocate a hitherto unused segment number.
*/
* chunk.
*/
-struct RAA;
+#define RAA_BLKSIZE 4096 /* this many longs allocated at once */
+#define RAA_LAYERSIZE 1024 /* this many _pointers_ allocated */
+
+typedef struct RAA RAA;
+typedef union RAA_UNION RAA_UNION;
+typedef struct RAA_LEAF RAA_LEAF;
+typedef struct RAA_BRANCH RAA_BRANCH;
+
+struct RAA {
+ /*
+ * Number of layers below this one to get to the real data. 0
+ * means this structure is a leaf, holding RAA_BLKSIZE real
+ * data items; 1 and above mean it's a branch, holding
+ * RAA_LAYERSIZE pointers to the next level branch or leaf
+ * structures.
+ */
+ int layers;
+ /*
+ * Number of real data items spanned by one position in the
+ * `data' array at this level. This number is 1, trivially, for
+ * a leaf (level 0): for a level 1 branch it should be
+ * RAA_BLKSIZE, and for a level 2 branch it's
+ * RAA_LAYERSIZE*RAA_BLKSIZE.
+ */
+ long stepsize;
+ union RAA_UNION {
+ struct RAA_LEAF {
+ long data[RAA_BLKSIZE];
+ } l;
+ struct RAA_BRANCH {
+ struct RAA *data[RAA_LAYERSIZE];
+ } b;
+ } u;
+};
+
struct RAA *raa_init (void);
void raa_free (struct RAA *);
* of a given size.
*/
-struct SAA;
+struct SAA {
+ /*
+ * members `end' and `elem_len' are only valid in first link in
+ * list; `rptr' and `rpos' are used for reading
+ */
+ struct SAA *next, *end, *rptr;
+ long elem_len, length, posn, start, rpos;
+ char *data;
+};
struct SAA *saa_init (long elem_len); /* 1 == byte */
void saa_free (struct SAA *);
*/
int bsi (char *string, char **array, int size);
+
+char *src_set_fname(char *newname);
+long src_set_linnum(long newline);
+long src_get_linnum(void);
+/*
+ * src_get may be used if you simply want to know the source file and line.
+ * It is also used if you maintain private status about the source location
+ * It return 0 if the information was the same as the last time you
+ * checked, -1 if the name changed and (new-old) if just the line changed.
+ */
+int src_get(long *xline, char **xname);
+
+void nasm_quote(char **str);
+char *nasm_strcat(char *one, char *two);
+void nasmlib_cleanup(void);
+
+void null_debug_routine();
+extern struct dfmt null_debug_form;
+extern struct dfmt *null_debug_arr[2];
#endif
static void output_ins (unsigned long, unsigned char *, int, char *);
static void skip (unsigned long dist, FILE *fp);
-int main(int argc, char **argv) {
+int main(int argc, char **argv)
+{
unsigned char buffer[INSN_MAX * 2], *p, *q;
char outbuf[256];
char *pname = *argv;
while (--argc) {
char *v, *vv, *p = *++argv;
- if (*p == '-') {
+ if (*p == '-' && p[1]) {
p++;
while (*p) switch (tolower(*p)) {
case 'a': /* auto or intelligent sync */
return 0;
}
- fp = fopen(filename, "rb");
- if (!fp) {
- fprintf(stderr, "%s: unable to open `%s': %s\n",
- pname, filename, strerror(errno));
- return 1;
- }
+ if (strcmp(filename, "-")) {
+ fp = fopen(filename, "rb");
+ if (!fp) {
+ fprintf(stderr, "%s: unable to open `%s': %s\n",
+ pname, filename, strerror(errno));
+ return 1;
+ }
+ } else
+ fp = stdin;
+
if (initskip > 0)
skip (initskip, fp);
unsigned long to_read = buffer+sizeof(buffer)-p;
if (to_read > nextsync-offset-(p-q))
to_read = nextsync-offset-(p-q);
- lenread = fread (p, 1, to_read, fp);
- if (lenread == 0)
- eof = TRUE; /* help along systems with bad feof */
+ if (to_read) {
+ lenread = fread (p, 1, to_read, fp);
+ if (lenread == 0)
+ eof = TRUE; /* help along systems with bad feof */
+ } else
+ lenread = 0;
p += lenread;
if (offset == nextsync) {
if (synclen) {
q = buffer;
}
} while (lenread > 0 || !(eof || feof(fp)));
- fclose (fp);
+
+ if (fp != stdin)
+ fclose (fp);
+
return 0;
}
static void output_ins (unsigned long offset, unsigned char *data,
- int datalen, char *insn) {
+ int datalen, char *insn)
+{
int bytes;
printf("%08lX ", offset);
* Skip a certain amount of data in a file, either by seeking if
* possible, or if that fails then by reading and discarding.
*/
-static void skip (unsigned long dist, FILE *fp) {
+static void skip (unsigned long dist, FILE *fp)
+{
char buffer[256]; /* should fit on most stacks :-) */
/*
static long aout_got_sect, aout_plt_sect;
static long aout_sym_sect;
-static void aoutg_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void aoutg_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
aoutfp = fp;
error = errfunc;
evaluate = eval;
#ifdef OF_AOUT
-static void aout_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void aout_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
bsd = FALSE;
aoutg_init (fp, errfunc, ldef, eval);
extern struct ofmt of_aoutb;
-static void aoutb_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void aoutb_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
bsd = TRUE;
aoutg_init (fp, errfunc, ldef, eval);
#endif
-static void aout_cleanup(void) {
+static void aout_cleanup(int debuginfo)
+{
struct Reloc *r;
+ (void) debuginfo;
+
aout_pad_sections();
aout_fixup_relocs(&stext);
aout_fixup_relocs(&sdata);
saa_free (strs);
}
-static long aout_section_names (char *name, int pass, int *bits) {
+static long aout_section_names (char *name, int pass, int *bits)
+{
/*
* Default to 32 bits.
*/
}
static void aout_deflabel (char *name, long segment, long offset,
- int is_global, char *special) {
+ int is_global, char *special)
+{
int pos = strslen+4;
struct Symbol *sym;
int special_used = FALSE;
}
static void aout_add_reloc (struct Section *sect, long segment,
- int reltype, int bytes) {
+ int reltype, int bytes)
+{
struct Reloc *r;
r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
*/
static long aout_add_gsym_reloc (struct Section *sect,
long segment, long offset,
- int type, int bytes, int exact) {
+ int type, int bytes, int exact)
+{
struct Symbol *sym, *sm, *shead;
struct Reloc *r;
* offset from the `asym' symbol rather than the section.
*/
static long aout_add_gotoff_reloc (struct Section *sect, long segment,
- long offset, int bytes) {
+ long offset, int bytes)
+{
struct Reloc *r;
struct Symbol *asym;
}
static void aout_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
struct Section *s;
long realbytes = type & OUT_SIZMASK;
long addr;
}
}
-static void aout_pad_sections(void) {
+static void aout_pad_sections(void)
+{
static unsigned char pad[] = { 0x90, 0x90, 0x90, 0x90 };
/*
* Pad each of the text and data sections with NOPs until their
* the relocation table, _after_ the final size of each section is
* known, and fix up the relocations pointed to.
*/
-static void aout_fixup_relocs(struct Section *sect) {
+static void aout_fixup_relocs(struct Section *sect)
+{
struct Reloc *r;
saa_rewind (sect->data);
}
}
-static void aout_write(void) {
+static void aout_write(void)
+{
/*
* Emit the a.out header.
*/
saa_fpwrite (strs, aoutfp);
}
-static void aout_write_relocs (struct Reloc *r) {
+static void aout_write_relocs (struct Reloc *r)
+{
while (r) {
unsigned long word2;
}
}
-static void aout_write_syms (void) {
+static void aout_write_syms (void)
+{
int i;
saa_rewind (syms);
}
static void aout_sect_write (struct Section *sect,
- unsigned char *data, unsigned long len) {
+ unsigned char *data, unsigned long len)
+{
saa_wbytes (sect->data, data, len);
sect->len += len;
}
-static long aout_segbase (long segment) {
+static long aout_segbase (long segment)
+{
return segment;
}
-static int aout_directive (char *directive, char *value, int pass) {
+static int aout_directive (char *directive, char *value, int pass)
+{
return 0;
}
-static void aout_filename (char *inname, char *outname, efunc error) {
+static void aout_filename (char *inname, char *outname, efunc error)
+{
standard_extension (inname, outname, ".o", error);
}
static char *aout_stdmac[] = {
"%define __SECT__ [section .text]",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
NULL
};
+static int aout_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
#endif /* OF_AOUT || OF_AOUTB */
#ifdef OF_AOUT
struct ofmt of_aout = {
"Linux a.out object files",
"aout",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
aout_stdmac,
aout_init,
+ aout_set_info,
aout_out,
aout_deflabel,
aout_section_names,
struct ofmt of_aoutb = {
"NetBSD/FreeBSD a.out object files",
"aoutb",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
aout_stdmac,
aoutb_init,
+ aout_set_info,
aout_out,
aout_deflabel,
aout_section_names,
static int as86_add_string (char *name);
static void as86_sect_write(struct Section *, unsigned char *, unsigned long);
-static void as86_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void as86_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
as86fp = fp;
error = errfunc;
(void) ldef; /* placate optimisers */
as86_add_string (as86_module);
}
-static void as86_cleanup(void) {
+static void as86_cleanup(int debuginfo)
+{
struct Piece *p;
+ (void) debuginfo;
+
as86_write();
fclose (as86fp);
saa_free (stext.data);
saa_free (strs);
}
-static long as86_section_names (char *name, int pass, int *bits) {
+static long as86_section_names (char *name, int pass, int *bits)
+{
/*
* Default is 16 bits.
*/
return NO_SEG;
}
-static int as86_add_string (char *name) {
+static int as86_add_string (char *name)
+{
int pos = strslen;
int length = strlen(name);
}
static void as86_deflabel (char *name, long segment, long offset,
- int is_global, char *special) {
+ int is_global, char *special)
+{
struct Symbol *sym;
if (special)
}
static void as86_add_piece (struct Section *sect, int type, long offset,
- long segment, long bytes, int relative) {
+ long segment, long bytes, int relative)
+{
struct Piece *p;
sect->len += bytes;
}
static void as86_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
struct Section *s;
long realbytes = type & OUT_SIZMASK;
long offset;
}
}
-static void as86_write(void) {
+static void as86_write(void)
+{
int i;
long symlen, seglen, segsize;
fputc (0, as86fp); /* termination */
}
-static void as86_set_rsize (int size) {
+static void as86_set_rsize (int size)
+{
if (as86_reloc_size != size) {
switch (as86_reloc_size = size) {
case 1: fputc (0x01, as86fp); break;
}
}
-static void as86_write_section (struct Section *sect, int index) {
+static void as86_write_section (struct Section *sect, int index)
+{
struct Piece *p;
unsigned long s;
long length;
}
static void as86_sect_write (struct Section *sect,
- unsigned char *data, unsigned long len) {
+ unsigned char *data, unsigned long len)
+{
saa_wbytes (sect->data, data, len);
sect->datalen += len;
}
-static long as86_segbase (long segment) {
+static long as86_segbase (long segment)
+{
return segment;
}
-static int as86_directive (char *directive, char *value, int pass) {
+static int as86_directive (char *directive, char *value, int pass)
+{
return 0;
}
-static void as86_filename (char *inname, char *outname, efunc error) {
+static void as86_filename (char *inname, char *outname, efunc error)
+{
char *p;
if ( (p = strrchr (inname, '.')) != NULL) {
static char *as86_stdmac[] = {
"%define __SECT__ [section .text]",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
NULL
};
+static int as86_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
+void as86_linenumber (char *name, long segment, long offset, int is_main,
+ int lineno)
+{
+}
struct ofmt of_as86 = {
"Linux as86 (bin86 version 0.3) object files",
"as86",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
as86_stdmac,
as86_init,
+ as86_set_info,
as86_out,
- as86_deflabel,
+ as86_deflabel,
as86_section_names,
as86_segbase,
as86_directive,
static long start_point;
static void add_reloc (struct Section *s, long bytes, long secref,
- long secrel) {
+ long secrel)
+{
struct Reloc *r;
r = *reloctail = nasm_malloc(sizeof(struct Reloc));
r->target = s;
}
-static void bin_init (FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void bin_init (FILE *afp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
fp = afp;
+ (void) eval; /* Don't warn that this parameter is unused */
+
error = errfunc;
(void) ldef; /* placate optimisers */
data_align = bss_align = 4;
}
-static void bin_cleanup (void) {
+static void bin_cleanup (int debuginfo)
+{
struct Reloc *r;
long datapos, datagap, bsspos;
+ (void) debuginfo;
+
datapos = start_point + textsect.length;
datapos = (datapos + data_align-1) & ~(data_align-1);
datagap = datapos - (start_point + textsect.length);
saa_rewind (textsect.contents);
saa_rewind (datasect.contents);
- for (r = relocs; r; r = r->next) {
+ for (r = relocs; r; r = r->next)
+ {
unsigned char *p, *q, mydata[4];
long l;
}
static void bin_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
unsigned char *p, mydata[4];
struct Section *s;
long realbytes;
s->length += type;
} else
bsslen += type;
- } else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
- (type & OUT_TYPMASK) == OUT_REL4ADR) {
+ }
+ else if ((type & OUT_TYPMASK) == OUT_REL2ADR ||
+ (type & OUT_TYPMASK) == OUT_REL4ADR)
+ {
realbytes = ((type & OUT_TYPMASK) == OUT_REL4ADR ? 4 : 2);
if (segment != NO_SEG &&
segment != textsect.index &&
}
static void bin_deflabel (char *name, long segment, long offset,
- int is_global, char *special) {
+ 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)
error (ERR_NONFATAL, "binary format does not support any"
}
}
-static long bin_secname (char *name, int pass, int *bits) {
+static long bin_secname (char *name, int pass, int *bits)
+{
int sec_index;
long *sec_align;
char *p;
+ (void) pass; /* Don't warn that this parameter is unused */
+
/*
* Default is 16 bits.
*/
return sec_index;
}
-static long bin_segbase (long segment) {
+static long bin_segbase (long segment)
+{
return segment;
}
-static int bin_directive (char *directive, char *value, int pass) {
+static int bin_directive (char *directive, char *value, int pass)
+{
int rn_error;
+ (void) pass; /* Don't warn that this parameter is unused */
+
if (!strcmp(directive, "org")) {
start_point = readnum (value, &rn_error);
if (rn_error)
return 0;
}
-static void bin_filename (char *inname, char *outname, efunc error) {
+static void bin_filename (char *inname, char *outname, efunc error)
+{
standard_extension (inname, outname, "", error);
}
"%imacro org 1+.nolist",
"[org %1]",
"%endmacro",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
NULL
};
+static int bin_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
struct ofmt of_bin = {
"flat-form binary files (e.g. DOS .COM, .SYS)",
"bin",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
bin_stdmac,
bin_init,
+ bin_set_info,
bin_out,
bin_deflabel,
bin_secname,
static void coff_write_relocs (struct Section *);
static void coff_write_symbols (void);
-static void coff_win32_init(FILE *fp, efunc errfunc,
- ldfunc ldef, evalfunc eval) {
+static void coff_win32_init(FILE *fp, efunc errfunc,
+ ldfunc ldef, evalfunc eval)
+{
win32 = TRUE;
(void) ldef; /* placate optimisers */
coff_gen_init(fp, errfunc);
}
-static void coff_std_init(FILE *fp, efunc errfunc,
- ldfunc ldef, evalfunc eval) {
+static void coff_std_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
win32 = FALSE;
(void) ldef; /* placate optimisers */
coff_gen_init(fp, errfunc);
}
-static void coff_gen_init(FILE *fp, efunc errfunc) {
+static void coff_gen_init(FILE *fp, efunc errfunc)
+{
+
coffp = fp;
error = errfunc;
sects = NULL;
def_seg = seg_alloc();
}
-static void coff_cleanup(void) {
+static void coff_cleanup(int debuginfo)
+{
struct Reloc *r;
int i;
+ (void) debuginfo;
+
coff_write();
fclose (coffp);
for (i=0; i<nsects; i++) {
sects[i]->head = sects[i]->head->next;
nasm_free (r);
}
+ nasm_free (sects[i]);
}
nasm_free (sects);
saa_free (syms);
saa_free (strs);
}
-static int coff_make_section (char *name, unsigned long flags) {
+static int coff_make_section (char *name, unsigned long flags)
+{
struct Section *s;
s = nasm_malloc (sizeof(*s));
return nsects-1;
}
-static long coff_section_names (char *name, int pass, int *bits) {
+static long coff_section_names (char *name, int pass, int *bits)
+{
char *p;
unsigned long flags, align_and = ~0L, align_or = 0L;
int i;
if (strlen(name) > 8) {
error (ERR_WARNING, "COFF section names limited to 8 characters:"
" truncating");
- p[8] = '\0';
+ name[8] = '\0';
}
flags = 0;
}
static void coff_deflabel (char *name, long segment, long offset,
- int is_global, char *special) {
+ int is_global, char *special)
+{
int pos = strslen+4;
struct Symbol *sym;
}
static long coff_add_reloc (struct Section *sect, long segment,
- int relative) {
+ int relative)
+{
struct Reloc *r;
r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
}
static void coff_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
struct Section *s;
long realbytes = type & OUT_SIZMASK;
unsigned char mydata[4], *p;
}
static void coff_sect_write (struct Section *sect,
- unsigned char *data, unsigned long len) {
+ unsigned char *data, unsigned long len)
+{
saa_wbytes (sect->data, data, len);
sect->len += len;
}
-static int coff_directives (char *directive, char *value, int pass) {
+static int coff_directives (char *directive, char *value, int pass)
+{
return 0;
}
-static void coff_write (void) {
+static void coff_write (void)
+{
long pos, sympos, vsize;
int i;
static void coff_section_header (char *name, long vsize,
long datalen, long datapos,
- long relpos, int nrelocs, long flags) {
+ long relpos, int nrelocs, long flags)
+{
char padname[8];
memset (padname, 0, 8);
fwritelong (flags, coffp);
}
-static void coff_write_relocs (struct Section *s) {
+static void coff_write_relocs (struct Section *s)
+{
struct Reloc *r;
for (r = s->head; r; r = r->next) {
}
static void coff_symbol (char *name, long strpos, long value,
- int section, int type, int aux) {
+ int section, int type, int aux)
+{
char padname[8];
if (name) {
fputc (aux, coffp);
}
-static void coff_write_symbols (void) {
+static void coff_write_symbols (void)
+{
char filename[18];
int i;
}
}
-static long coff_segbase (long segment) {
+static long coff_segbase (long segment)
+{
return segment;
}
-static void coff_std_filename (char *inname, char *outname, efunc error) {
+static void coff_std_filename (char *inname, char *outname, efunc error)
+{
strcpy(coff_infile, inname);
standard_extension (inname, outname, ".o", error);
}
-static void coff_win32_filename (char *inname, char *outname, efunc error) {
+static void coff_win32_filename (char *inname, char *outname, efunc error)
+{
strcpy(coff_infile, inname);
standard_extension (inname, outname, ".obj", error);
}
-#endif /* defined(OF_COFF) || defined(OF_WIN32) */
-
static char *coff_stdmac[] = {
"%define __SECT__ [section .text]",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
NULL
};
+static int coff_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
+#endif /* defined(OF_COFF) || defined(OF_WIN32) */
+
#ifdef OF_COFF
struct ofmt of_coff = {
"COFF (i386) object files (e.g. DJGPP for DOS)",
"coff",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
coff_stdmac,
coff_std_init,
+ coff_set_info,
coff_out,
coff_deflabel,
coff_section_names,
struct ofmt of_win32 = {
"Microsoft Win32 (i386) object files",
"win32",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
coff_stdmac,
coff_win32_init,
+ coff_set_info,
coff_out,
coff_deflabel,
coff_section_names,
FILE *dbgf;
efunc dbgef;
+struct ofmt of_dbg;
static void dbg_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
{
+ (void) eval;
+
dbgf = fp;
dbgef = errfunc;
dbgsect = NULL;
(void) ldef;
fprintf(fp,"NASM Output format debug dump\n");
+ of_dbg.current_dfmt->init(&of_dbg,0,fp,errfunc);
+
}
-static void dbg_cleanup(void)
+static void dbg_cleanup(int debuginfo)
{
+ (void) debuginfo;
+ of_dbg.current_dfmt->cleanup();
while (dbgsect) {
struct Section *tmp = dbgsect;
dbgsect = dbgsect->next;
}
static void dbg_deflabel (char *name, long segment, long offset,
- int is_global, char *special) {
+ int is_global, char *special)
+{
fprintf(dbgf,"deflabel %s := %08lx:%08lx %s (%d)%s%s\n",
name, segment, offset,
is_global == 2 ? "common" : is_global ? "global" : "local",
}
static void dbg_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
long realbytes = type & OUT_SIZMASK;
long ldata;
int id;
}
}
-static long dbg_segbase(long segment) {
+static long dbg_segbase(long segment)
+{
return segment;
}
-static int dbg_directive (char *directive, char *value, int pass) {
+static int dbg_directive (char *directive, char *value, int pass)
+{
fprintf(dbgf, "directive [%s] value [%s] (pass %d)\n",
directive, value, pass);
return 1;
}
-static void dbg_filename (char *inname, char *outname, efunc error) {
+static void dbg_filename (char *inname, char *outname, efunc error)
+{
standard_extension (inname, outname, ".dbg", error);
}
+static int dbg_set_info(enum geninfo type, char **val)
+{
+ (void) type;
+ (void) val;
+ return 0;
+}
+char *types[] = {
+ "unknown", "label", "byte","word","dword","float","qword","tbyte"
+};
+void dbgdbg_init(struct ofmt * of, void * id, FILE * fp, efunc error)
+{
+ (void) of;
+ (void) id;
+ (void) fp;
+ (void) error;
+ fprintf(fp," With debug info\n");
+}
+static void dbgdbg_cleanup(void)
+{
+}
+
+static void dbgdbg_linnum (const char *lnfname, long lineno, long segto)
+{
+ fprintf(dbgf,"dbglinenum %s(%ld) := %08lx\n",
+ lnfname,lineno,segto);
+}
+static void dbgdbg_deflabel (char *name, long segment,
+ long offset, int is_global, char *special)
+{
+ fprintf(dbgf,"dbglabel %s := %08lx:%08lx %s (%d)%s%s\n",
+ name,
+ segment, offset,
+ is_global == 2 ? "common" : is_global ? "global" : "local",
+ is_global,
+ special ? ": " : "", special);
+}
+static void dbgdbg_define(const char *type, const char *params)
+{
+ fprintf(dbgf,"dbgdirective [%s] value [%s]\n",type, params);
+}
+static void dbgdbg_output (int output_type, void *param)
+{
+ (void) output_type;
+ (void) param;
+}
+static void dbgdbg_typevalue(long type)
+{
+ fprintf(dbgf,"new type: %s(%lX)\n",
+ types[TYM_TYPE(type) >> 3], TYM_ELEMENTS(type) );
+}
+static struct dfmt debug_debug_form = {
+ "Trace of all info passed to debug stage",
+ "debug",
+ dbgdbg_init,
+ dbgdbg_linnum,
+ dbgdbg_deflabel,
+ dbgdbg_define,
+ dbgdbg_typevalue,
+ dbgdbg_output,
+ dbgdbg_cleanup,
+};
+
+static struct dfmt *debug_debug_arr[3] = {
+ &debug_debug_form,
+ &null_debug_form,
+ NULL
+};
struct ofmt of_dbg = {
"Trace of all info passed to output stage",
"dbg",
NULL,
+ debug_debug_arr,
+ &null_debug_form,
+ NULL,
dbg_init,
+ dbg_set_info,
dbg_out,
dbg_deflabel,
dbg_section_names,
void *data;
long len;
int is_saa;
-} elf_sects[ELF_MAX_SECTIONS];
+} *elf_sects;
static int elf_nsect;
static long elf_foffs;
static long elf_got_sect, elf_plt_sect;
static long elf_sym_sect;
-static void elf_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void elf_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
elffp = fp;
error = errfunc;
evaluate = eval;
def_seg = seg_alloc();
}
-static void elf_cleanup(void) {
+static void elf_cleanup(int debuginfo)
+{
struct Reloc *r;
int i;
+ (void) debuginfo;
+
elf_write();
fclose (elffp);
for (i=0; i<nsects; i++) {
saa_free (strs);
}
-static void add_sectname (char *firsthalf, char *secondhalf) {
+static void add_sectname (char *firsthalf, char *secondhalf)
+{
int len = strlen(firsthalf)+strlen(secondhalf);
while (shstrtablen + len + 1 > shstrtabsize)
shstrtab = nasm_realloc (shstrtab, (shstrtabsize += SHSTR_DELTA));
shstrtablen += len+1;
}
-static int elf_make_section (char *name, int type, int flags, int align) {
+static int elf_make_section (char *name, int type, int flags, int align)
+{
struct Section *s;
s = nasm_malloc (sizeof(*s));
return nsects-1;
}
-static long elf_section_names (char *name, int pass, int *bits) {
+static long elf_section_names (char *name, int pass, int *bits)
+{
char *p;
int flags_and, flags_or, type, align, i;
/*
* Default is 32 bits.
*/
- if (!name)
+ if (!name) {
*bits = 32;
-
- if (!name)
return def_seg;
+ }
p = name;
while (*p && !isspace(*p)) p++;
}
static void elf_deflabel (char *name, long segment, long offset,
- int is_global, char *special) {
+ int is_global, char *special)
+{
int pos = strslen;
struct Symbol *sym;
int special_used = FALSE;
sym->value = (sym->section == SHN_UNDEF ? 0 : offset);
if (sym->type == SYM_GLOBAL) {
+ /*
+ * There's a problem here that needs fixing.
+ * If sym->section == SHN_ABS, then the first line of the
+ * else section causes a core dump, because its a reference
+ * beyond the end of the section array.
+ * This behaviour is exhibited by this code:
+ * GLOBAL crash_nasm
+ * crash_nasm equ 0
+ *
+ * I'm not sure how to procede, because I haven't got the
+ * first clue about how ELF works, so I don't know what to
+ * do with it. Furthermore, I'm not sure what the rest of this
+ * section of code does. Help?
+ *
+ * For now, I'll see if doing absolutely nothing with it will
+ * work...
+ */
if (sym->section == SHN_UNDEF || sym->section == SHN_COMMON)
+ {
bsym = raa_write (bsym, segment, nglobs);
- else {
+ }
+ else if (sym->section != SHN_ABS)
+ {
/*
* This is a global symbol; so we must add it to the linked
* list of global symbols in its section. We'll push it on
}
static void elf_add_reloc (struct Section *sect, long segment,
- int type) {
+ int type)
+{
struct Reloc *r;
r = *sect->tail = nasm_malloc(sizeof(struct Reloc));
*/
static long elf_add_gsym_reloc (struct Section *sect,
long segment, long offset,
- int type, int exact) {
+ int type, int exact)
+{
struct Reloc *r;
struct Section *s;
struct Symbol *sym, *sm;
}
static void elf_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
struct Section *s;
long realbytes = type & OUT_SIZMASK;
long addr;
}
}
-static void elf_write(void) {
+static void elf_write(void)
+{
int nsections, align;
char *p;
int commlen;
align = ((elf_foffs+SEG_ALIGN_1) & ~SEG_ALIGN_1) - elf_foffs;
elf_foffs += align;
elf_nsect = 0;
+ elf_sects = nasm_malloc(sizeof(*elf_sects) * (2 * nsects + 10));
elf_section_header (0, 0, 0, NULL, FALSE, 0L, 0, 0, 0, 0); /* SHN_UNDEF */
p = shstrtab+1;
*/
elf_write_sections();
+ nasm_free (elf_sects);
saa_free (symtab);
}
-static struct SAA *elf_build_symtab (long *len, long *local) {
+static struct SAA *elf_build_symtab (long *len, long *local)
+{
struct SAA *s = saa_init(1L);
struct Symbol *sym;
unsigned char entry[16], *p;
static void elf_section_header (int name, int type, int flags,
void *data, int is_saa, long datalen,
- int link, int info, int align, int eltsize) {
+ int link, int info, int align, int eltsize)
+{
elf_sects[elf_nsect].data = data;
elf_sects[elf_nsect].len = datalen;
elf_sects[elf_nsect].is_saa = is_saa;
fwritelong ((long)eltsize, elffp);
}
-static void elf_write_sections (void) {
+static void elf_write_sections (void)
+{
int i;
for (i = 0; i < elf_nsect; i++)
if (elf_sects[i].data) {
}
static void elf_sect_write (struct Section *sect,
- unsigned char *data, unsigned long len) {
+ unsigned char *data, unsigned long len)
+{
saa_wbytes (sect->data, data, len);
sect->len += len;
}
-static long elf_segbase (long segment) {
+static long elf_segbase (long segment)
+{
return segment;
}
-static int elf_directive (char *directive, char *value, int pass) {
+static int elf_directive (char *directive, char *value, int pass)
+{
return 0;
}
-static void elf_filename (char *inname, char *outname, efunc error) {
+static void elf_filename (char *inname, char *outname, efunc error)
+{
strcpy(elf_module, inname);
standard_extension (inname, outname, ".o", error);
}
static char *elf_stdmac[] = {
"%define __SECT__ [section .text]",
+ "%macro __NASM_CDecl__ 1",
+ "%define $_%1 $%1",
+ "%endmacro",
NULL
};
+static int elf_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
struct ofmt of_elf = {
"ELF32 (i386) object files (e.g. Linux)",
"elf",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
elf_stdmac,
elf_init,
+ elf_set_info,
elf_out,
elf_deflabel,
elf_section_names,
#include <stdio.h>
#include <string.h>
+
+#define BUILD_DRIVERS_ARRAY
#include "outform.h"
-static struct ofmt *drivers[MAX_OUTPUT_FORMATS];
static int ndrivers = 0;
struct ofmt *ofmt_find(char *name) /* find driver */
return NULL;
}
+struct dfmt *dfmt_find(struct ofmt *ofmt, char *name) /* find driver */
+{
+ struct dfmt **dfmt = ofmt->debug_formats;
+ while (*dfmt) {
+ if (!strcmp(name, (*dfmt)->shortname))
+ return (*dfmt);
+ dfmt++;
+ }
+ return NULL;
+}
void ofmt_list(struct ofmt *deffmt, FILE *fp)
{
int i;
for (i=0; i<ndrivers; i++)
- fprintf(fp, " %c %-7s%s\n",
+ fprintf(fp, " %c %-10s%s\n",
drivers[i] == deffmt ? '*' : ' ',
drivers[i]->shortname,
drivers[i]->fullname);
}
+void dfmt_list(struct ofmt *ofmt, FILE *fp)
+{
+ struct dfmt ** drivers = ofmt->debug_formats;
+ while (*drivers) {
+ fprintf(fp, " %c %-10s%s\n",
+ drivers[0] == ofmt->current_dfmt ? '*' : ' ',
+ drivers[0]->shortname,
+ drivers[0]->fullname);
+ drivers++;
+ }
+}
+struct ofmt *ofmt_register (efunc error) {
+ for (ndrivers=0; drivers[ndrivers] != NULL; ndrivers++);
+
+ if (ndrivers==0)
+ {
+ error(ERR_PANIC | ERR_NOFILE,
+ "No output drivers given at compile time");
+ }
-void ofmt_register (struct ofmt *info) {
- drivers[ndrivers++] = info;
+ return (&OF_DEFAULT);
}
* OF_UNIX -- ensure that 'aout', 'aoutb', 'coff', 'elf' are in.
* OF_OTHERS -- ensure that 'bin', 'as86' & 'rdf' are in.
* OF_ALL -- ensure that all formats are included.
+ * note that this doesn't include 'dbg', which is
+ * only really useful if you're doing development
+ * work on NASM. Define OF_DBG if you want this.
*
* OF_DEFAULT=of_name -- ensure that 'name' is the default format.
*
#include "nasm.h"
-#define MAX_OUTPUT_FORMATS 16
-
-struct ofmt *ofmt_find(char *);
-void ofmt_list(struct ofmt *, FILE *);
-void ofmt_register (struct ofmt *);
-
/* -------------- USER MODIFIABLE PART ---------------- */
/*
/* ====configurable info begins here==== */
/* formats configurable:
- * bin,obj,elf,aout,aoutb,coff,win32,as86,rdf */
+ * bin,obj,elf,aout,aoutb,coff,win32,as86,rdf,rdf2 */
/* process options... */
#ifndef OF_AS86
#define OF_AS86
#endif
-#ifndef OF_RDF
-#define OF_RDF
+#ifndef OF_RDF2
+#define OF_RDF2
#endif
#endif /* OF_ALL */
#ifndef OF_RDF
#define OF_RDF
#endif
+#ifndef OF_RDF2
+#define OF_RDF2
+#endif
#endif
/* finally... override any format specifically specifed to be off */
#ifdef OF_NO_RDF
#undef OF_RDF
#endif
+#ifdef OF_NO_RDF2
+#undef OF_RDF
+#endif
#ifndef OF_DEFAULT
#define OF_DEFAULT of_bin
#endif
+#ifdef BUILD_DRIVERS_ARRAY /* only if included from outform.c */
+
+/* pull in the externs for the different formats, then make the *drivers
+ * array based on the above defines */
+
+extern struct ofmt of_bin;
+extern struct ofmt of_aout;
+extern struct ofmt of_aoutb;
+extern struct ofmt of_coff;
+extern struct ofmt of_elf;
+extern struct ofmt of_as86;
+extern struct ofmt of_obj;
+extern struct ofmt of_win32;
+extern struct ofmt of_rdf;
+extern struct ofmt of_rdf2;
+extern struct ofmt of_dbg;
+
+struct ofmt *drivers[]={
+#ifdef OF_BIN
+ &of_bin,
+#endif
+#ifdef OF_AOUT
+ &of_aout,
+#endif
+#ifdef OF_AOUTB
+ &of_aoutb,
+#endif
+#ifdef OF_COFF
+ &of_coff,
+#endif
+#ifdef OF_ELF
+ &of_elf,
+#endif
+#ifdef OF_AS86
+ &of_as86,
+#endif
+#ifdef OF_OBJ
+ &of_obj,
+#endif
+#ifdef OF_WIN32
+ &of_win32,
+#endif
+#ifdef OF_RDF
+ &of_rdf,
+#endif
+#ifdef OF_RDF2
+ &of_rdf2,
+#endif
+#ifdef OF_DBG
+ &of_dbg,
+#endif
+
+ NULL
+};
+
+#endif /* BUILD_DRIVERS_ARRAY */
+
+struct ofmt *ofmt_find(char *);
+struct dfmt *dfmt_find(struct ofmt *, char *);
+void ofmt_list(struct ofmt *, FILE *);
+void dfmt_list(struct ofmt *ofmt, FILE *fp);
+struct ofmt *ofmt_register (efunc error);
+
#endif /* NASM_OUTFORM_H */
--- /dev/null
+/* outform.h header file for binding output format drivers to the
+ * remainder of the code in the Netwide Assembler
+ *
+ * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the licence given in the file "Licence"
+ * distributed in the NASM archive.
+ */
+
+/*
+ * This header file allows configuration of which output formats
+ * get compiled into the NASM binary. You can configure by defining
+ * various preprocessor symbols beginning with "OF_", either on the
+ * compiler command line or at the top of this file.
+ *
+ * OF_ONLY -- only include specified object formats
+ * OF_name -- ensure that output format 'name' is included
+ * OF_NO_name -- remove output format 'name'
+ * OF_DOS -- ensure that 'obj', 'bin' & 'win32' are included.
+ * OF_UNIX -- ensure that 'aout', 'aoutb', 'coff', 'elf' are in.
+ * OF_OTHERS -- ensure that 'bin', 'as86' & 'rdf' are in.
+ * OF_ALL -- ensure that all formats are included.
+ *
+ * OF_DEFAULT=of_name -- ensure that 'name' is the default format.
+ *
+ * eg: -DOF_UNIX -DOF_ELF -DOF_DEFAULT=of_elf would be a suitable config
+ * for an average linux system.
+ *
+ * Default config = -DOF_ALL -DOF_DEFAULT=of_bin
+ *
+ * You probably only want to set these options while compiling 'nasm.c'. */
+
+#ifndef NASM_OUTFORMS_H
+#define NASM_OUTFORMS_H
+
+#include "nasm.h"
+
+/* -------------- USER MODIFIABLE PART ---------------- */
+
+/*
+ * Insert #defines here in accordance with the configuration
+ * instructions above.
+ *
+ * E.g.
+ *
+ * #define OF_ONLY
+ * #define OF_OBJ
+ * #define OF_BIN
+ *
+ * for a 16-bit DOS assembler with no extraneous formats.
+ */
+
+/* ------------ END USER MODIFIABLE PART -------------- */
+
+/* ====configurable info begins here==== */
+/* formats configurable:
+ * bin,obj,elf,aout,aoutb,coff,win32,as86,rdf */
+
+/* process options... */
+
+#ifndef OF_ONLY
+#ifndef OF_ALL
+#define OF_ALL /* default is to have all formats */
+#endif
+#endif
+
+#ifdef OF_ALL /* set all formats on... */
+#ifndef OF_BIN
+#define OF_BIN
+#endif
+#ifndef OF_OBJ
+#define OF_OBJ
+#endif
+#ifndef OF_ELF
+#define OF_ELF
+#endif
+#ifndef OF_COFF
+#define OF_COFF
+#endif
+#ifndef OF_AOUT
+#define OF_AOUT
+#endif
+#ifndef OF_AOUTB
+#define OF_AOUTB
+#endif
+#ifndef OF_WIN32
+#define OF_WIN32
+#endif
+#ifndef OF_AS86
+#define OF_AS86
+#endif
+#ifndef OF_RDF
+#define OF_RDF
+#endif
+#endif /* OF_ALL */
+
+/* turn on groups of formats specified.... */
+#ifdef OF_DOS
+#ifndef OF_OBJ
+#define OF_OBJ
+#endif
+#ifndef OF_BIN
+#define OF_BIN
+#endif
+#ifndef OF_WIN32
+#define OF_WIN32
+#endif
+#endif
+
+#ifdef OF_UNIX
+#ifndef OF_AOUT
+#define OF_AOUT
+#endif
+#ifndef OF_AOUTB
+#define OF_AOUTB
+#endif
+#ifndef OF_COFF
+#define OF_COFF
+#endif
+#ifndef OF_ELF
+#define OF_ELF
+#endif
+#endif
+
+#ifdef OF_OTHERS
+#ifndef OF_BIN
+#define OF_BIN
+#endif
+#ifndef OF_AS86
+#define OF_AS86
+#endif
+#ifndef OF_RDF
+#define OF_RDF
+#endif
+#endif
+
+/* finally... override any format specifically specifed to be off */
+#ifdef OF_NO_BIN
+#undef OF_BIN
+#endif
+#ifdef OF_NO_OBJ
+#undef OF_OBJ
+#endif
+#ifdef OF_NO_ELF
+#undef OF_ELF
+#endif
+#ifdef OF_NO_AOUT
+#undef OF_AOUT
+#endif
+#ifdef OF_NO_AOUTB
+#undef OF_AOUTB
+#endif
+#ifdef OF_NO_COFF
+#undef OF_COFF
+#endif
+#ifdef OF_NO_WIN32
+#undef OF_WIN32
+#endif
+#ifdef OF_NO_AS86
+#undef OF_AS86
+#endif
+#ifdef OF_NO_RDF
+#undef OF_RDF
+#endif
+
+#ifndef OF_DEFAULT
+#define OF_DEFAULT of_bin
+#endif
+
+#ifdef BUILD_DRIVERS_ARRAY /* only if included from outform.c */
+
+/* pull in the externs for the different formats, then make the *drivers
+ * array based on the above defines */
+
+extern struct ofmt of_bin;
+extern struct ofmt of_aout;
+extern struct ofmt of_aoutb;
+extern struct ofmt of_coff;
+extern struct ofmt of_elf;
+extern struct ofmt of_as86;
+extern struct ofmt of_obj;
+extern struct ofmt of_win32;
+extern struct ofmt of_rdf;
+extern struct ofmt of_dbg;
+
+struct ofmt *drivers[]={
+#ifdef OF_BIN
+ &of_bin,
+#endif
+#ifdef OF_AOUT
+ &of_aout,
+#endif
+#ifdef OF_AOUTB
+ &of_aoutb,
+#endif
+#ifdef OF_COFF
+ &of_coff,
+#endif
+#ifdef OF_ELF
+ &of_elf,
+#endif
+#ifdef OF_AS86
+ &of_as86,
+#endif
+#ifdef OF_OBJ
+ &of_obj,
+#endif
+#ifdef OF_WIN32
+ &of_win32,
+#endif
+#ifdef OF_RDF
+ &of_rdf,
+#endif
+#ifdef OF_DBG
+ &of_dbg,
+#endif
+
+ NULL
+};
+
+#endif /* BUILD_DRIVERS_ARRAY */
+
+#endif /* NASM_OUTFORMS_H */
/* outobj.c output routines for the Netwide Assembler to produce
- * Microsoft 16-bit .OBJ object files
+ * .OBJ object files
*
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
* Julian Hall. All rights reserved. The software is
#ifdef OF_OBJ
+/*
+ * outobj.c is divided into two sections. The first section is low level
+ * routines for creating obj records; It has nearly zero NASM specific
+ * code. The second section is high level routines for processing calls and
+ * data structures from the rest of NASM into obj format.
+ *
+ * It should be easy (though not zero work) to lift the first section out for
+ * use as an obj file writer for some other assembler or compiler.
+ */
+
+/*
+ * These routines are built around the ObjRecord data struture. An ObjRecord
+ * holds an object file record that may be under construction or complete.
+ *
+ * A major function of these routines is to support continuation of an obj
+ * record into the next record when the maximum record size is exceeded. The
+ * high level code does not need to worry about where the record breaks occur.
+ * It does need to do some minor extra steps to make the automatic continuation
+ * work. Those steps may be skipped for records where the high level knows no
+ * continuation could be required.
+ *
+ * 1) An ObjRecord is allocated and cleared by obj_new, or an existing ObjRecord
+ * is cleared by obj_clear.
+ *
+ * 2) The caller should fill in .type.
+ *
+ * 3) If the record is continuable and there is processing that must be done at
+ * the start of each record then the caller should fill in .ori with the
+ * address of the record initializer routine.
+ *
+ * 4) If the record is continuable and it should be saved (rather than emitted
+ * immediately) as each record is done, the caller should set .up to be a
+ * pointer to a location in which the caller keeps the master pointer to the
+ * ObjRecord. When the record is continued, the obj_bump routine will then
+ * allocate a new ObjRecord structure and update the master pointer.
+ *
+ * 5) If the .ori field was used then the caller should fill in the .parm with
+ * any data required by the initializer.
+ *
+ * 6) The caller uses the routines: obj_byte, obj_word, obj_rword, obj_dword,
+ * obj_x, obj_index, obj_value and obj_name to fill in the various kinds of
+ * data required for this record.
+ *
+ * 7) If the record is continuable, the caller should call obj_commit at each
+ * point where breaking the record is permitted.
+ *
+ * 8) To write out the record, the caller should call obj_emit2. If the
+ * caller has called obj_commit for all data written then he can get slightly
+ * faster code by calling obj_emit instead of obj_emit2.
+ *
+ * Most of these routines return an ObjRecord pointer. This will be the input
+ * pointer most of the time and will be the new location if the ObjRecord
+ * moved as a result of the call. The caller may ignore the return value in
+ * three cases: It is a "Never Reallocates" routine; or The caller knows
+ * continuation is not possible; or The caller uses the master pointer for the
+ * next operation.
+ */
+
+#define RECORD_MAX 1024 /* maximum size of _any_ record */
+#define OBJ_PARMS 3 /* maximum .parm used by any .ori routine */
+
+#define FIX_08_LOW 0x8000 /* location type for various fixup subrecords */
+#define FIX_16_OFFSET 0x8400
+#define FIX_16_SELECTOR 0x8800
+#define FIX_32_POINTER 0x8C00
+#define FIX_08_HIGH 0x9000
+#define FIX_32_OFFSET 0xA400
+#define FIX_48_POINTER 0xAC00
+
+enum RecordID { /* record ID codes */
+
+ THEADR = 0x80, /* module header */
+ COMENT = 0x88, /* comment record */
+
+ LINNUM = 0x94, /* line number record */
+ LNAMES = 0x96, /* list of names */
+
+ SEGDEF = 0x98, /* segment definition */
+ GRPDEF = 0x9A, /* group definition */
+ EXTDEF = 0x8C, /* external definition */
+ PUBDEF = 0x90, /* public definition */
+ COMDEF = 0xB0, /* common definition */
+
+ LEDATA = 0xA0, /* logical enumerated data */
+ FIXUPP = 0x9C, /* fixups (relocations) */
+
+ MODEND = 0x8A /* module end */
+};
+
+enum ComentID { /* ID codes for comment records */
+
+ dEXTENDED = 0xA1, /* tells that we are using translator-specific extensions */
+ dLINKPASS = 0xA2, /* link pass 2 marker */
+ dTYPEDEF = 0xE3, /* define a type */
+ dSYM = 0xE6, /* symbol debug record */
+ dFILNAME = 0xE8, /* file name record */
+ dCOMPDEF = 0xEA /* compiler type info */
+
+};
+
+typedef struct ObjRecord ObjRecord;
+typedef void ORI(ObjRecord *orp);
+
+struct ObjRecord {
+ ORI *ori; /* Initialization routine */
+ int used; /* Current data size */
+ int committed; /* Data size at last boundary */
+ int x_size; /* (see obj_x) */
+ unsigned int type; /* Record type */
+ ObjRecord *child; /* Associated record below this one */
+ ObjRecord **up; /* Master pointer to this ObjRecord */
+ ObjRecord *back; /* Previous part of this record */
+ unsigned long parm[OBJ_PARMS]; /* Parameters for ori routine */
+ unsigned char buf[RECORD_MAX];
+};
+
+static void obj_fwrite(ObjRecord *orp);
+static void ori_ledata(ObjRecord *orp);
+static void ori_pubdef(ObjRecord *orp);
+static void ori_null(ObjRecord *orp);
+static ObjRecord *obj_commit(ObjRecord *orp);
+static void obj_write_fixup (ObjRecord *orp, int bytes,
+ int segrel, long seg, long wrt);
+
+static int obj_uppercase; /* Flag: all names in uppercase */
+
+/*
+ * Clear an ObjRecord structure. (Never reallocates).
+ * To simplify reuse of ObjRecord's, .type, .ori and .parm are not cleared.
+ */
+static ObjRecord *obj_clear(ObjRecord *orp)
+{
+ orp->used = 0;
+ orp->committed = 0;
+ orp->x_size = 0;
+ orp->child = NULL;
+ orp->up = NULL;
+ orp->back = NULL;
+ return (orp);
+}
+
+/*
+ * Emit an ObjRecord structure. (Never reallocates).
+ * The record is written out preceeded (recursively) by its previous part (if
+ * any) and followed (recursively) by its child (if any).
+ * The previous part and the child are freed. The main ObjRecord is cleared,
+ * not freed.
+ */
+static ObjRecord *obj_emit(ObjRecord *orp)
+{
+ if (orp->back) {
+ obj_emit(orp->back);
+ nasm_free(orp->back);
+ }
+
+ if (orp->committed)
+ obj_fwrite(orp);
+
+ if (orp->child) {
+ obj_emit(orp->child);
+ nasm_free(orp->child);
+ }
+
+ return (obj_clear(orp));
+}
+
+/*
+ * Commit and Emit a record. (Never reallocates).
+ */
+static ObjRecord *obj_emit2(ObjRecord *orp)
+{
+ obj_commit(orp);
+ return (obj_emit(orp));
+}
+
+/*
+ * Allocate and clear a new ObjRecord; Also sets .ori to ori_null
+ */
+static ObjRecord *obj_new(void)
+{
+ ObjRecord *orp;
+
+ orp = obj_clear( nasm_malloc(sizeof(ObjRecord)) );
+ orp->ori = ori_null;
+ return (orp);
+}
+
+/*
+ * Advance to the next record because the existing one is full or its x_size
+ * is incompatible.
+ * Any uncommited data is moved into the next record.
+ */
+static ObjRecord *obj_bump(ObjRecord *orp)
+{
+ ObjRecord *nxt;
+ int used = orp->used;
+ int committed = orp->committed;
+
+ if (orp->up) {
+ *orp->up = nxt = obj_new();
+ nxt->ori = orp->ori;
+ nxt->type = orp->type;
+ nxt->up = orp->up;
+ nxt->back = orp;
+ memcpy( nxt->parm, orp->parm, sizeof(orp->parm));
+ } else
+ nxt = obj_emit(orp);
+
+ used -= committed;
+ if (used) {
+ nxt->committed = 1;
+ nxt->ori (nxt);
+ nxt->committed = nxt->used;
+ memcpy( nxt->buf + nxt->committed, orp->buf + committed, used);
+ nxt->used = nxt->committed + used;
+ }
+
+ return (nxt);
+}
+
+/*
+ * Advance to the next record if necessary to allow the next field to fit.
+ */
+static ObjRecord *obj_check(ObjRecord *orp, int size)
+{
+ if (orp->used + size > RECORD_MAX)
+ orp = obj_bump(orp);
+
+ if (!orp->committed) {
+ orp->committed = 1;
+ orp->ori (orp);
+ orp->committed = orp->used;
+ }
+
+ return (orp);
+}
+
+/*
+ * All data written so far is commited to the current record (won't be moved to
+ * the next record in case of continuation).
+ */
+static ObjRecord *obj_commit(ObjRecord *orp)
+{
+ orp->committed = orp->used;
+ return (orp);
+}
+
+/*
+ * Write a byte
+ */
+static ObjRecord *obj_byte(ObjRecord *orp, unsigned char val)
+{
+ orp = obj_check(orp, 1);
+ orp->buf[orp->used] = val;
+ orp->used++;
+ return (orp);
+}
+
+/*
+ * Write a word
+ */
+static ObjRecord *obj_word(ObjRecord *orp, unsigned int val)
+{
+ orp = obj_check(orp, 2);
+ orp->buf[orp->used] = val;
+ orp->buf[orp->used+1] = val >> 8;
+ orp->used += 2;
+ return (orp);
+}
+
+/*
+ * Write a reversed word
+ */
+static ObjRecord *obj_rword(ObjRecord *orp, unsigned int val)
+{
+ orp = obj_check(orp, 2);
+ orp->buf[orp->used] = val >> 8;
+ orp->buf[orp->used+1] = val;
+ orp->used += 2;
+ return (orp);
+}
+
+/*
+ * Write a dword
+ */
+static ObjRecord *obj_dword(ObjRecord *orp, unsigned long val)
+{
+ orp = obj_check(orp, 4);
+ orp->buf[orp->used] = val;
+ orp->buf[orp->used+1] = val >> 8;
+ orp->buf[orp->used+2] = val >> 16;
+ orp->buf[orp->used+3] = val >> 24;
+ orp->used += 4;
+ return (orp);
+}
+
+/*
+ * All fields of "size x" in one obj record must be the same size (either 16
+ * bits or 32 bits). There is a one bit flag in each record which specifies
+ * which.
+ * This routine is used to force the current record to have the desired
+ * x_size. x_size is normally automatic (using obj_x), so that this
+ * routine should be used outside obj_x, only to provide compatibility with
+ * linkers that have bugs in their processing of the size bit.
+ */
+
+static ObjRecord *obj_force(ObjRecord *orp, int x)
+{
+ if (orp->x_size == (x^48))
+ orp = obj_bump(orp);
+ orp->x_size = x;
+ return (orp);
+}
+
+/*
+ * This routine writes a field of size x. The caller does not need to worry at
+ * all about whether 16-bits or 32-bits are required.
+ */
+static ObjRecord *obj_x(ObjRecord *orp, unsigned long val)
+{
+ if (orp->type & 1)
+ orp->x_size = 32;
+ if (val > 0xFFFF)
+ orp = obj_force(orp, 32);
+ if (orp->x_size == 32)
+ return (obj_dword(orp, val));
+ orp->x_size = 16;
+ return (obj_word(orp, val));
+}
+
+/*
+ * Writes an index
+ */
+static ObjRecord *obj_index(ObjRecord *orp, unsigned int val)
+{
+ if (val < 128)
+ return ( obj_byte(orp, val) );
+ return (obj_word(orp, (val>>8) | (val<<8) | 0x80));
+}
+
+/*
+ * Writes a variable length value
+ */
+static ObjRecord *obj_value(ObjRecord *orp, unsigned long val)
+{
+ if (val <= 128)
+ return ( obj_byte(orp, val) );
+ if (val <= 0xFFFF) {
+ orp = obj_byte(orp, 129);
+ return ( obj_word(orp, val) );
+ }
+ if (val <= 0xFFFFFF)
+ return ( obj_dword(orp, (val<<8) + 132 ) );
+ orp = obj_byte(orp, 136);
+ return ( obj_dword(orp, val) );
+}
+
+/*
+ * Writes a counted string
+ */
+static ObjRecord *obj_name(ObjRecord *orp, char *name)
+{
+ int len = strlen(name);
+ unsigned char *ptr;
+
+ orp = obj_check(orp, len+1);
+ ptr = orp->buf + orp->used;
+ *ptr++ = len;
+ orp->used += len+1;
+ if (obj_uppercase)
+ while (--len >= 0) {
+ *ptr++ = toupper(*name);
+ name++;
+ } else
+ memcpy(ptr, name, len);
+ return (orp);
+}
+
+/*
+ * Initializer for an LEDATA record.
+ * parm[0] = offset
+ * parm[1] = segment index
+ * During the use of a LEDATA ObjRecord, parm[0] is constantly updated to
+ * represent the offset that would be required if the record were split at the
+ * last commit point.
+ * parm[2] is a copy of parm[0] as it was when the current record was initted.
+ */
+static void ori_ledata(ObjRecord *orp)
+{
+ obj_index (orp, orp->parm[1]);
+ orp->parm[2] = orp->parm[0];
+ obj_x (orp, orp->parm[0]);
+}
+
+/*
+ * Initializer for a PUBDEF record.
+ * parm[0] = group index
+ * parm[1] = segment index
+ * parm[2] = frame (only used when both indexes are zero)
+ */
+static void ori_pubdef(ObjRecord *orp)
+{
+ obj_index (orp, orp->parm[0]);
+ obj_index (orp, orp->parm[1]);
+ if ( !(orp->parm[0] | orp->parm[1]) )
+ obj_word (orp, orp->parm[2]);
+}
+
+/*
+ * Initializer for a LINNUM record.
+ * parm[0] = group index
+ * parm[1] = segment index
+ */
+static void ori_linnum(ObjRecord *orp)
+{
+ obj_index (orp, orp->parm[0]);
+ obj_index (orp, orp->parm[1]);
+}
+/*
+ * Initializer for a local vars record.
+ */
+static void ori_local(ObjRecord *orp)
+{
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dSYM);
+}
+
+/*
+ * Null initializer for records that continue without any header info
+ */
+static void ori_null(ObjRecord *orp)
+{
+ (void) orp; /* Do nothing */
+}
+
+/*
+ * This concludes the low level section of outobj.c
+ */
+
static char obj_infile[FILENAME_MAX];
-static int obj_uppercase;
static efunc error;
static evalfunc evaluate;
static FILE *ofp;
static long first_seg;
static int any_segs;
+static int passtwo;
+static int arrindex;
-#define LEDATA_MAX 1024 /* maximum size of LEDATA record */
-#define RECORD_MAX 1024 /* maximum size of _any_ record */
#define GROUP_MAX 256 /* we won't _realistically_ have more
* than this many segs in a group */
#define EXT_BLKSIZ 256 /* block size for externals list */
-static unsigned char record[RECORD_MAX], *recptr;
-
struct Segment; /* need to know these structs exist */
struct Group;
+struct LineNumber {
+ struct LineNumber *next;
+ struct Segment *segment;
+ long offset;
+ long lineno;
+};
+
+static struct FileName {
+ struct FileName *next;
+ char *name;
+ struct LineNumber *lnhead, **lntail;
+ int index;
+} *fnhead, **fntail;
+
+static struct Array {
+ struct Array *next;
+ unsigned size;
+ int basetype;
+} *arrhead, **arrtail;
+
+#define ARRAYBOT 31 /* magic number for first array index */
+
+
static struct Public {
struct Public *next;
char *name;
long offset;
long segment; /* only if it's far-absolute */
-} *fpubhead, **fpubtail;
+ int type; /* only for local debug syms */
+} *fpubhead, **fpubtail, *last_defined;
static struct External {
struct External *next;
long index; /* the NASM segment id */
long obj_index; /* the OBJ-file segment index */
struct Group *grp; /* the group it belongs to */
- long currentpos;
+ unsigned long currentpos;
long align; /* can be SEG_ABS + absolute addr */
enum {
CMB_PRIVATE = 0,
CMB_COMMON = 6
} combine;
long use32; /* is this segment 32-bit? */
- struct Public *pubhead, **pubtail;
+ struct Public *pubhead, **pubtail, *lochead, **loctail;
char *name;
char *segclass, *overlay; /* `class' is a C++ keyword :-) */
+ ObjRecord *orp;
} *seghead, **segtail, *obj_seg_needs_update;
static struct Group {
} segs[GROUP_MAX]; /* ...in this */
} *grphead, **grptail, *obj_grp_needs_update;
-static struct ObjData {
- struct ObjData *next;
- int nonempty;
- struct Segment *seg;
- long startpos;
- int letype, ftype;
- unsigned char ledata[LEDATA_MAX], *lptr;
- unsigned char fixupp[RECORD_MAX], *fptr;
-} *datahead, *datacurr, **datatail;
-
static struct ImpDef {
struct ImpDef *next;
char *extname;
static long obj_entry_seg, obj_entry_ofs;
-enum RecordID { /* record ID codes */
-
- THEADR = 0x80, /* module header */
- COMENT = 0x88, /* comment record */
-
- LNAMES = 0x96, /* list of names */
-
- SEGDEF = 0x98, /* segment definition */
- GRPDEF = 0x9A, /* group definition */
- EXTDEF = 0x8C, /* external definition */
- PUBDEF = 0x90, /* public definition */
- COMDEF = 0xB0, /* common definition */
+struct ofmt of_obj;
- LEDATA = 0xA0, /* logical enumerated data */
- FIXUPP = 0x9C, /* fixups (relocations) */
-
- MODEND = 0x8A /* module end */
-};
-
-extern struct ofmt of_obj;
-
-static long obj_ledata_space(struct Segment *);
-static int obj_fixup_free(struct Segment *);
-static void obj_ledata_new(struct Segment *);
-static void obj_ledata_commit(void);
-static void obj_write_fixup (struct ObjData *, int, int, long, long, long);
static long obj_segment (char *, int, int *);
-static void obj_write_file(void);
-static unsigned char *obj_write_data(unsigned char *, unsigned char *, int);
-static unsigned char *obj_write_byte(unsigned char *, int);
-static unsigned char *obj_write_word(unsigned char *, int);
-static unsigned char *obj_write_dword(unsigned char *, long);
-static unsigned char *obj_write_rword(unsigned char *, int);
-static unsigned char *obj_write_name(unsigned char *, char *);
-static unsigned char *obj_write_index(unsigned char *, int);
-static unsigned char *obj_write_value(unsigned char *, unsigned long);
-static void obj_record(int, unsigned char *, unsigned char *);
+static void obj_write_file(int debuginfo);
static int obj_directive (char *, char *, int);
-static void obj_init (FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) {
+static void obj_init (FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
ofp = fp;
error = errfunc;
evaluate = eval;
segtail = &seghead;
grphead = obj_grp_needs_update = NULL;
grptail = &grphead;
- datahead = datacurr = NULL;
- datatail = &datahead;
obj_entry_seg = NO_SEG;
obj_uppercase = FALSE;
+ passtwo = 0;
+
+ of_obj.current_dfmt->init (&of_obj,NULL,fp,errfunc);
}
-static void obj_cleanup (void) {
- obj_write_file();
+static int obj_set_info(enum geninfo type, char **val)
+{
+ (void) type;
+ (void) val;
+
+ return 0;
+}
+static void obj_cleanup (int debuginfo)
+{
+ obj_write_file(debuginfo);
+ of_obj.current_dfmt->cleanup();
fclose (ofp);
while (seghead) {
struct Segment *segtmp = seghead;
nasm_free (pubtmp->name);
nasm_free (pubtmp);
}
+ nasm_free (segtmp->segclass);
+ nasm_free (segtmp->overlay);
nasm_free (segtmp);
}
while (fpubhead) {
grphead = grphead->next;
nasm_free (grptmp);
}
- while (datahead) {
- struct ObjData *datatmp = datahead;
- datahead = datahead->next;
- nasm_free (datatmp);
- }
}
-static void obj_ext_set_defwrt (struct External *ext, char *id) {
+static void obj_ext_set_defwrt (struct External *ext, char *id)
+{
struct Segment *seg;
struct Group *grp;
}
static void obj_deflabel (char *name, long segment,
- long offset, int is_global, char *special) {
+ long offset, int is_global, char *special)
+{
/*
* We have three cases:
*
error (ERR_PANIC, "strange segment conditions in OBJ driver");
}
- for (seg = seghead; seg; seg = seg->next)
+ for (seg = seghead; seg && is_global; seg = seg->next)
if (seg->index == segment) {
+ struct Public *loc = nasm_malloc (sizeof(*loc));
/*
* Case (ii). Maybe MODPUB someday?
*/
- if (is_global) {
- struct Public *pub;
- pub = *seg->pubtail = nasm_malloc(sizeof(*pub));
- seg->pubtail = &pub->next;
- pub->next = NULL;
- pub->name = nasm_strdup(name);
- pub->offset = offset;
- }
+ *seg->pubtail = loc;
+ seg->pubtail = &loc->next;
+ loc->next = NULL;
+ loc->name = nasm_strdup(name);
+ loc->offset = offset;
+
if (special)
error(ERR_NONFATAL, "OBJ supports no special symbol features"
" for this symbol type");
/*
* Case (iii).
*/
- ext = *exttail = nasm_malloc(sizeof(*ext));
- ext->next = NULL;
- exttail = &ext->next;
- ext->name = name;
- ext->defwrt_type = DEFWRT_NONE;
- if (is_global == 2) {
- ext->commonsize = offset;
- ext->commonelem = 1; /* default FAR */
- } else
- ext->commonsize = 0;
+ if (is_global) {
+ ext = *exttail = nasm_malloc(sizeof(*ext));
+ ext->next = NULL;
+ exttail = &ext->next;
+ ext->name = name;
+ ext->defwrt_type = DEFWRT_NONE;
+ if (is_global == 2) {
+ ext->commonsize = offset;
+ ext->commonelem = 1; /* default FAR */
+ } else
+ ext->commonsize = 0;
+ }
+ else
+ return;
/*
* Now process the special text, if any, to find default-WRT
}
static void obj_out (long segto, void *data, unsigned long type,
- long segment, long wrt) {
+ long segment, long wrt)
+{
long size, realtype;
unsigned char *ucdata;
long ldata;
struct Segment *seg;
+ ObjRecord *orp;
/*
* handle absolute-assembly (structure definitions)
if (!seg)
error (ERR_PANIC, "code directed to nonexistent segment?");
+ orp = seg->orp;
+ orp->parm[0] = seg->currentpos;
+
size = type & OUT_SIZMASK;
realtype = type & OUT_TYPMASK;
if (realtype == OUT_RAWDATA) {
ucdata = data;
while (size > 0) {
- long len = obj_ledata_space(seg);
- if (len == 0) {
- obj_ledata_new(seg);
- len = obj_ledata_space(seg);
- }
+ unsigned int len;
+ orp = obj_check(seg->orp, 1);
+ len = RECORD_MAX - orp->used;
if (len > size)
len = size;
- datacurr->lptr = obj_write_data (datacurr->lptr, ucdata, len);
- datacurr->nonempty = TRUE;
+ memcpy (orp->buf+orp->used, ucdata, len);
+ orp->committed = orp->used += len;
+ orp->parm[0] = seg->currentpos += len;
ucdata += len;
size -= len;
- seg->currentpos += len;
}
- } else if (realtype == OUT_ADDRESS || realtype == OUT_REL2ADR ||
- realtype == OUT_REL4ADR) {
+ }
+ else if (realtype == OUT_ADDRESS || realtype == OUT_REL2ADR ||
+ realtype == OUT_REL4ADR)
+ {
int rsize;
if (segment == NO_SEG && realtype != OUT_ADDRESS)
ldata += (size-4);
size = 4;
}
- if (obj_ledata_space(seg) < 4 || !obj_fixup_free(seg))
- obj_ledata_new(seg);
if (size == 2)
- datacurr->lptr = obj_write_word (datacurr->lptr, ldata);
+ orp = obj_word (orp, ldata);
else
- datacurr->lptr = obj_write_dword (datacurr->lptr, ldata);
- datacurr->nonempty = TRUE;
+ orp = obj_dword (orp, ldata);
rsize = size;
if (segment < SEG_ABS && (segment != NO_SEG && segment % 2) &&
size == 4) {
" dword-size segment base references");
}
if (segment != NO_SEG)
- obj_write_fixup (datacurr, rsize,
- (realtype == OUT_REL2ADR ||
- realtype == OUT_REL4ADR ? 0 : 0x4000),
- segment, wrt,
- (seg->currentpos - datacurr->startpos));
+ obj_write_fixup (orp, rsize,
+ (realtype == OUT_ADDRESS ? 0x4000 : 0),
+ segment, wrt);
seg->currentpos += size;
} else if (realtype == OUT_RESERVE) {
- obj_ledata_commit();
+ if (orp->committed)
+ orp = obj_bump(orp);
seg->currentpos += size;
}
+ obj_commit(orp);
}
-static long obj_ledata_space(struct Segment *segto) {
- if (datacurr && datacurr->seg == segto)
- return datacurr->ledata + LEDATA_MAX - datacurr->lptr;
- else
- return 0;
-}
-
-static int obj_fixup_free(struct Segment *segto) {
- if (datacurr && datacurr->seg == segto)
- return (datacurr->fixupp + RECORD_MAX - datacurr->fptr) > 8;
- else
- return 0;
-}
-
-static void obj_ledata_new(struct Segment *segto) {
- datacurr = *datatail = nasm_malloc(sizeof(*datacurr));
- datacurr->next = NULL;
- datatail = &datacurr->next;
- datacurr->nonempty = FALSE;
- datacurr->lptr = datacurr->ledata;
- datacurr->fptr = datacurr->fixupp;
- datacurr->seg = segto;
- if (segto->use32)
- datacurr->letype = LEDATA+1;
- else
- datacurr->letype = LEDATA;
- datacurr->startpos = segto->currentpos;
- datacurr->ftype = FIXUPP;
-
- datacurr->lptr = obj_write_index (datacurr->lptr, segto->obj_index);
- if (datacurr->letype == LEDATA)
- datacurr->lptr = obj_write_word (datacurr->lptr, segto->currentpos);
- else
- datacurr->lptr = obj_write_dword (datacurr->lptr, segto->currentpos);
-}
-
-static void obj_ledata_commit(void) {
- datacurr = NULL;
-}
-
-static void obj_write_fixup (struct ObjData *data, int bytes,
- int segrel, long seg, long wrt,
- long offset) {
+static void obj_write_fixup (ObjRecord *orp, int bytes,
+ int segrel, long seg, long wrt)
+{
int locat, method;
int base;
long tidx, fidx;
struct Segment *s = NULL;
struct Group *g = NULL;
struct External *e = NULL;
+ ObjRecord *forp;
if (bytes == 1) {
error(ERR_NONFATAL, "`obj' output driver does not support"
return;
}
- locat = 0x8000 | segrel | offset;
+ forp = orp->child;
+ if (forp == NULL) {
+ orp->child = forp = obj_new();
+ forp->up = &(orp->child);
+ forp->type = FIXUPP;
+ }
+
if (seg % 2) {
base = TRUE;
- locat |= 0x800;
+ locat = FIX_16_SELECTOR;
seg--;
if (bytes != 2)
error(ERR_PANIC, "OBJ: 4-byte segment base fixup got"
" through sanity check");
- } else {
+ }
+ else {
base = FALSE;
- if (bytes == 2)
- locat |= 0x400;
- else {
- locat |= 0x2400;
- data->ftype = FIXUPP+1; /* need new-style FIXUPP record */
- }
+ locat = (bytes == 2) ? FIX_16_OFFSET : FIX_32_OFFSET;
+ if (!segrel)
+ /*
+ * There is a bug in tlink that makes it process self relative
+ * fixups incorrectly if the x_size doesn't match the location
+ * size.
+ */
+ forp = obj_force(forp, bytes<<3);
}
- data->fptr = obj_write_rword (data->fptr, locat);
+
+ forp = obj_rword (forp, locat | segrel | (orp->parm[0]-orp->parm[2]));
tidx = fidx = -1, method = 0; /* placate optimisers */
}
}
- data->fptr = obj_write_byte (data->fptr, method);
+ forp = obj_byte (forp, method);
if (fidx != -1)
- data->fptr = obj_write_index (data->fptr, fidx);
- data->fptr = obj_write_index (data->fptr, tidx);
+ forp = obj_index (forp, fidx);
+ forp = obj_index (forp, tidx);
+ obj_commit (forp);
}
-static long obj_segment (char *name, int pass, int *bits) {
+static long obj_segment (char *name, int pass, int *bits)
+{
/*
* We call the label manager here to define a name for the new
* segment, and when our _own_ label-definition stub gets
seg->segclass = seg->overlay = NULL;
seg->pubhead = NULL;
seg->pubtail = &seg->pubhead;
+ seg->lochead = NULL;
+ seg->loctail = &seg->lochead;
+ seg->orp = obj_new();
+ seg->orp->up = &(seg->orp);
+ seg->orp->ori = ori_ledata;
+ seg->orp->type = LEDATA;
+ seg->orp->parm[1] = obj_idx;
/*
* Process the segment attributes.
while (*extp) {
if ((*extp)->defwrt_type == DEFWRT_STRING &&
!strcmp((*extp)->defwrt_ptr.string, seg->name)) {
+ nasm_free((*extp)->defwrt_ptr.string);
(*extp)->defwrt_type = DEFWRT_SEGMENT;
(*extp)->defwrt_ptr.seg = seg;
*extp = (*extp)->next_dws;
}
}
-static int obj_directive (char *directive, char *value, int pass) {
+static int obj_directive (char *directive, char *value, int pass)
+{
if (!strcmp(directive, "group")) {
char *p, *q, *v;
if (pass == 1) {
while (*extp) {
if ((*extp)->defwrt_type == DEFWRT_STRING &&
!strcmp((*extp)->defwrt_ptr.string, grp->name)) {
+ nasm_free((*extp)->defwrt_ptr.string);
(*extp)->defwrt_type = DEFWRT_GROUP;
(*extp)->defwrt_ptr.grp = grp;
*extp = (*extp)->next_dws;
return 0;
}
-static long obj_segbase (long segment) {
+static long obj_segbase (long segment)
+{
struct Segment *seg;
/*
return e->defwrt_ptr.seg->index+1;
else if (e->defwrt_type == DEFWRT_GROUP)
return e->defwrt_ptr.grp->index+1;
- else if (e->defwrt_type == DEFWRT_STRING)
+ else
return NO_SEG; /* can't tell what it is */
}
return segment; /* no special treatment */
}
-static void obj_filename (char *inname, char *outname, efunc error) {
+static void obj_filename (char *inname, char *outname, efunc error)
+{
strcpy(obj_infile, inname);
standard_extension (inname, outname, ".obj", error);
}
-static void obj_write_file (void) {
- struct Segment *seg;
+static void obj_write_file (int debuginfo)
+{
+ struct Segment *seg, *entry_seg_ptr = 0;
+ struct FileName *fn;
+ struct LineNumber *ln;
struct Group *grp;
- struct Public *pub;
+ struct Public *pub, *loc;
struct External *ext;
- struct ObjData *data;
struct ImpDef *imp;
struct ExpDef *export;
static char boast[] = "The Netwide Assembler " NASM_VER;
- int lname_idx, rectype;
+ int lname_idx;
+ ObjRecord *orp;
/*
* Write the THEADR module header.
*/
- recptr = record;
- recptr = obj_write_name (recptr, obj_infile);
- obj_record (THEADR, record, recptr);
+ orp = obj_new();
+ orp->type = THEADR;
+ obj_name (orp, obj_infile);
+ obj_emit2 (orp);
/*
* Write the NASM boast comment.
*/
- recptr = record;
- recptr = obj_write_rword (recptr, 0); /* comment type zero */
- recptr = obj_write_name (recptr, boast);
- obj_record (COMENT, record, recptr);
+ orp->type = COMENT;
+ obj_rword (orp, 0); /* comment type zero */
+ obj_name (orp, boast);
+ obj_emit2 (orp);
+ orp->type = COMENT;
/*
* Write the IMPDEF records, if any.
*/
for (imp = imphead; imp; imp = imp->next) {
- recptr = record;
- recptr = obj_write_rword (recptr, 0xA0); /* comment class A0 */
- recptr = obj_write_byte (recptr, 1); /* subfunction 1: IMPDEF */
+ obj_rword (orp, 0xA0); /* comment class A0 */
+ obj_byte (orp, 1); /* subfunction 1: IMPDEF */
if (imp->impname)
- recptr = obj_write_byte (recptr, 0); /* import by name */
+ obj_byte (orp, 0); /* import by name */
else
- recptr = obj_write_byte (recptr, 1); /* import by ordinal */
- recptr = obj_write_name (recptr, imp->extname);
- recptr = obj_write_name (recptr, imp->libname);
+ obj_byte (orp, 1); /* import by ordinal */
+ obj_name (orp, imp->extname);
+ obj_name (orp, imp->libname);
if (imp->impname)
- recptr = obj_write_name (recptr, imp->impname);
+ obj_name (orp, imp->impname);
else
- recptr = obj_write_word (recptr, imp->impindex);
- obj_record (COMENT, record, recptr);
+ obj_word (orp, imp->impindex);
+ obj_emit2 (orp);
}
/*
* Write the EXPDEF records, if any.
*/
for (export = exphead; export; export = export->next) {
- recptr = record;
- recptr = obj_write_rword (recptr, 0xA0); /* comment class A0 */
- recptr = obj_write_byte (recptr, 2); /* subfunction 1: EXPDEF */
- recptr = obj_write_byte (recptr, export->flags);
- recptr = obj_write_name (recptr, export->extname);
- recptr = obj_write_name (recptr, export->intname);
+ obj_rword (orp, 0xA0); /* comment class A0 */
+ obj_byte (orp, 2); /* subfunction 2: EXPDEF */
+ obj_byte (orp, export->flags);
+ obj_name (orp, export->extname);
+ obj_name (orp, export->intname);
if (export->flags & EXPDEF_FLAG_ORDINAL)
- recptr = obj_write_word (recptr, export->ordinal);
- obj_record (COMENT, record, recptr);
+ obj_word (orp, export->ordinal);
+ obj_emit2 (orp);
+ }
+
+ /* we're using extended OMF if we put in debug info*/
+ if (debuginfo) {
+ orp->type = COMENT;
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dEXTENDED);
+ obj_emit2 (orp);
}
/*
* Write the first LNAMES record, containing LNAME one, which
* is null. Also initialise the LNAME counter.
*/
- recptr = record;
- recptr = obj_write_name (recptr, "");
- obj_record (LNAMES, record, recptr);
- lname_idx = 2;
+ orp->type = LNAMES;
+ obj_byte (orp, 0);
+ lname_idx = 1;
+ /*
+ * Write some LNAMES for the segment names
+ */
+ for (seg = seghead; seg; seg = seg->next) {
+ orp = obj_name (orp, seg->name);
+ if (seg->segclass)
+ orp = obj_name (orp, seg->segclass);
+ if (seg->overlay)
+ orp = obj_name (orp, seg->overlay);
+ obj_commit (orp);
+ }
+ /*
+ * Write some LNAMES for the group names
+ */
+ for (grp = grphead; grp; grp = grp->next) {
+ orp = obj_name (orp, grp->name);
+ obj_commit (orp);
+ }
+ obj_emit (orp);
+
/*
- * Write the SEGDEF records. Each has an associated LNAMES
- * record.
+ * Write the SEGDEF records.
*/
+ orp->type = SEGDEF;
for (seg = seghead; seg; seg = seg->next) {
- int new_segdef; /* do we use the newer record type? */
int acbp;
- int sn, cn, on; /* seg, class, overlay LNAME idx */
-
- if (seg->use32 || seg->currentpos >= 0x10000L)
- new_segdef = TRUE;
- else
- new_segdef = FALSE;
-
- recptr = record;
- recptr = obj_write_name (recptr, seg->name);
- sn = lname_idx++;
- if (seg->segclass) {
- recptr = obj_write_name (recptr, seg->segclass);
- cn = lname_idx++;
- } else
- cn = 1;
- if (seg->overlay) {
- recptr = obj_write_name (recptr, seg->overlay);
- on = lname_idx++;
- } else
- on = 1;
- obj_record (LNAMES, record, recptr);
+ unsigned long seglen = seg->currentpos;
acbp = (seg->combine << 2); /* C field */
- if (seg->currentpos >= 0x10000L && !new_segdef)
- acbp |= 0x02; /* B bit */
-
if (seg->use32)
acbp |= 0x01; /* P bit is Use32 flag */
+ else if (seglen == 0x10000L) {
+ seglen = 0; /* This special case may be needed for old linkers */
+ acbp |= 0x02; /* B bit */
+ }
+
/* A field */
if (seg->align >= SEG_ABS)
- acbp |= 0x00;
+ /* acbp |= 0x00 */;
else if (seg->align >= 4096) {
if (seg->align > 4096)
error(ERR_NONFATAL, "segment `%s' requires more alignment"
} else
acbp |= 0x20;
- recptr = record;
- recptr = obj_write_byte (recptr, acbp);
+ obj_byte (orp, acbp);
if (seg->align & SEG_ABS) {
- recptr = obj_write_word (recptr, seg->align - SEG_ABS);
- recptr = obj_write_byte (recptr, 0);
- }
- if (new_segdef)
- recptr = obj_write_dword (recptr, seg->currentpos);
- else
- recptr = obj_write_word (recptr, seg->currentpos & 0xFFFF);
- recptr = obj_write_index (recptr, sn);
- recptr = obj_write_index (recptr, cn);
- recptr = obj_write_index (recptr, on);
- if (new_segdef)
- obj_record (SEGDEF+1, record, recptr);
- else
- obj_record (SEGDEF, record, recptr);
- }
-
- /*
- * Write some LNAMES for the group names. lname_idx is left
- * alone here - it will catch up when we write the GRPDEFs.
- */
- recptr = record;
- for (grp = grphead; grp; grp = grp->next) {
- if (recptr - record + strlen(grp->name)+2 > 1024) {
- obj_record (LNAMES, record, recptr);
- recptr = record;
+ obj_x (orp, seg->align - SEG_ABS); /* Frame */
+ obj_byte (orp, 0); /* Offset */
}
- recptr = obj_write_name (recptr, grp->name);
+ obj_x (orp, seglen);
+ obj_index (orp, ++lname_idx);
+ obj_index (orp, seg->segclass ? ++lname_idx : 1);
+ obj_index (orp, seg->overlay ? ++lname_idx : 1);
+ obj_emit2 (orp);
}
- if (recptr > record)
- obj_record (LNAMES, record, recptr);
/*
* Write the GRPDEF records.
*/
+ orp->type = GRPDEF;
for (grp = grphead; grp; grp = grp->next) {
int i;
grp->segs[i].name = NULL;
}
}
- recptr = record;
- recptr = obj_write_index (recptr, lname_idx++);
+ obj_index (orp, ++lname_idx);
for (i = 0; i < grp->nindices; i++) {
- recptr = obj_write_byte (recptr, 0xFF);
- recptr = obj_write_index (recptr, grp->segs[i].index);
+ obj_byte (orp, 0xFF);
+ obj_index (orp, grp->segs[i].index);
}
- obj_record (GRPDEF, record, recptr);
+ obj_emit2 (orp);
}
/*
* Write the PUBDEF records: first the ones in the segments,
* then the far-absolutes.
*/
+ orp->type = PUBDEF;
+ orp->ori = ori_pubdef;
for (seg = seghead; seg; seg = seg->next) {
- int any;
-
- recptr = record;
- recptr = obj_write_index (recptr, seg->grp ? seg->grp->obj_index : 0);
- recptr = obj_write_index (recptr, seg->obj_index);
- any = FALSE;
- if (seg->use32)
- rectype = PUBDEF+1;
- else
- rectype = PUBDEF;
+ orp->parm[0] = seg->grp ? seg->grp->obj_index : 0;
+ orp->parm[1] = seg->obj_index;
for (pub = seg->pubhead; pub; pub = pub->next) {
- if (recptr - record + strlen(pub->name) + 7 > 1024) {
- if (any)
- obj_record (rectype, record, recptr);
- recptr = record;
- recptr = obj_write_index (recptr, 0);
- recptr = obj_write_index (recptr, seg->obj_index);
- }
- recptr = obj_write_name (recptr, pub->name);
- if (seg->use32)
- recptr = obj_write_dword (recptr, pub->offset);
- else
- recptr = obj_write_word (recptr, pub->offset);
- recptr = obj_write_index (recptr, 0);
- any = TRUE;
+ orp = obj_name (orp, pub->name);
+ orp = obj_x (orp, pub->offset);
+ orp = obj_byte (orp, 0); /* type index */
+ obj_commit (orp);
}
- if (any)
- obj_record (rectype, record, recptr);
+ obj_emit (orp);
}
+ orp->parm[0] = 0;
+ orp->parm[1] = 0;
for (pub = fpubhead; pub; pub = pub->next) { /* pub-crawl :-) */
- recptr = record;
- recptr = obj_write_index (recptr, 0); /* no group */
- recptr = obj_write_index (recptr, 0); /* no segment either */
- recptr = obj_write_word (recptr, pub->segment);
- recptr = obj_write_name (recptr, pub->name);
- recptr = obj_write_word (recptr, pub->offset);
- recptr = obj_write_index (recptr, 0);
- obj_record (PUBDEF, record, recptr);
+ if (orp->parm[2] != pub->segment) {
+ obj_emit (orp);
+ orp->parm[2] = pub->segment;
+ }
+ orp = obj_name (orp, pub->name);
+ orp = obj_x (orp, pub->offset);
+ orp = obj_byte (orp, 0); /* type index */
+ obj_commit (orp);
}
+ obj_emit (orp);
/*
* Write the EXTDEF and COMDEF records, in order.
*/
- recptr = record;
+ orp->ori = ori_null;
for (ext = exthead; ext; ext = ext->next) {
if (ext->commonsize == 0) {
- /* dj@delorie.com: check for buffer overrun before we overrun it */
- if (recptr - record + strlen(ext->name)+2 > RECORD_MAX) {
- obj_record (EXTDEF, record, recptr);
- recptr = record;
+ if (orp->type != EXTDEF) {
+ obj_emit (orp);
+ orp->type = EXTDEF;
}
- recptr = obj_write_name (recptr, ext->name);
- recptr = obj_write_index (recptr, 0);
+ orp = obj_name (orp, ext->name);
+ orp = obj_index (orp, 0);
} else {
- if (recptr > record)
- obj_record (EXTDEF, record, recptr);
- recptr = record;
- if (ext->commonsize) {
- recptr = obj_write_name (recptr, ext->name);
- recptr = obj_write_index (recptr, 0);
- if (ext->commonelem) {
- recptr = obj_write_byte (recptr, 0x61);/* far communal */
- recptr = obj_write_value (recptr, (ext->commonsize /
- ext->commonelem));
- recptr = obj_write_value (recptr, ext->commonelem);
- } else {
- recptr = obj_write_byte (recptr, 0x62);/* near communal */
- recptr = obj_write_value (recptr, ext->commonsize);
- }
- obj_record (COMDEF, record, recptr);
+ if (orp->type != COMDEF) {
+ obj_emit (orp);
+ orp->type = COMDEF;
+ }
+ orp = obj_name (orp, ext->name);
+ orp = obj_index (orp, 0);
+ if (ext->commonelem) {
+ orp = obj_byte (orp, 0x61);/* far communal */
+ orp = obj_value (orp, (ext->commonsize / ext->commonelem));
+ orp = obj_value (orp, ext->commonelem);
+ } else {
+ orp = obj_byte (orp, 0x62);/* near communal */
+ orp = obj_value (orp, ext->commonsize);
}
- recptr = record;
}
+ obj_commit (orp);
}
- if (recptr > record)
- obj_record (EXTDEF, record, recptr);
+ obj_emit (orp);
/*
* Write a COMENT record stating that the linker's first pass
* MODEND record specifies a start point, in which case,
* according to some variants of the documentation, this COMENT
* should be omitted. So we'll omit it just in case.
+ * But, TASM puts it in all the time so if we are using
+ * TASM debug stuff we are putting it in
*/
- if (obj_entry_seg == NO_SEG) {
- recptr = record;
- recptr = obj_write_rword (recptr, 0x40A2);
- recptr = obj_write_byte (recptr, 1);
- obj_record (COMENT, record, recptr);
- }
+ if (debuginfo || obj_entry_seg == NO_SEG) {
+ orp->type = COMENT;
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dLINKPASS);
+ obj_byte (orp, 1);
+ obj_emit2 (orp);
+ }
/*
- * Write the LEDATA/FIXUPP pairs.
+ * 1) put out the compiler type
+ * 2) Put out the type info. The only type we are using is near label #19
+ */
+ if (debuginfo) {
+ int i;
+ struct Array *arrtmp = arrhead;
+ orp->type = COMENT;
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dCOMPDEF);
+ obj_byte (orp, 4);
+ obj_byte (orp, 0);
+ obj_emit2 (orp);
+
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x18); /* type # for linking */
+ obj_word (orp, 6); /* size of type */
+ obj_byte (orp, 0x2a); /* absolute type for debugging */
+ obj_emit2 (orp);
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x19); /* type # for linking */
+ obj_word (orp, 0); /* size of type */
+ obj_byte (orp, 0x24); /* absolute type for debugging */
+ obj_byte (orp, 0); /* near/far specifier */
+ obj_emit2 (orp);
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x1A); /* type # for linking */
+ obj_word (orp, 0); /* size of type */
+ obj_byte (orp, 0x24); /* absolute type for debugging */
+ obj_byte (orp, 1); /* near/far specifier */
+ obj_emit2 (orp);
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x1b); /* type # for linking */
+ obj_word (orp, 0); /* size of type */
+ obj_byte (orp, 0x23); /* absolute type for debugging */
+ obj_byte (orp, 0);
+ obj_byte (orp, 0);
+ obj_byte (orp, 0);
+ obj_emit2 (orp);
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x1c); /* type # for linking */
+ obj_word (orp, 0); /* size of type */
+ obj_byte (orp, 0x23); /* absolute type for debugging */
+ obj_byte (orp, 0);
+ obj_byte (orp, 4);
+ obj_byte (orp, 0);
+ obj_emit2 (orp);
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x1d); /* type # for linking */
+ obj_word (orp, 0); /* size of type */
+ obj_byte (orp, 0x23); /* absolute type for debugging */
+ obj_byte (orp, 0);
+ obj_byte (orp, 1);
+ obj_byte (orp, 0);
+ obj_emit2 (orp);
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, 0x1e); /* type # for linking */
+ obj_word (orp, 0); /* size of type */
+ obj_byte (orp, 0x23); /* absolute type for debugging */
+ obj_byte (orp, 0);
+ obj_byte (orp, 5);
+ obj_byte (orp, 0);
+ obj_emit2 (orp);
+
+ /* put out the array types */
+ for (i= ARRAYBOT; i < arrindex; i++) {
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dTYPEDEF);
+ obj_word (orp, i ); /* type # for linking */
+ obj_word (orp, arrtmp->size); /* size of type */
+ obj_byte (orp, 0x1A); /* absolute type for debugging (array)*/
+ obj_byte (orp, arrtmp->basetype ); /* base type */
+ obj_emit2 (orp);
+ arrtmp = arrtmp->next ;
+ }
+ }
+ /*
+ * write out line number info with a LINNUM record
+ * switch records when we switch segments, and output the
+ * file in a pseudo-TASM fashion. The record switch is naive; that
+ * is that one file may have many records for the same segment
+ * if there are lots of segment switches
*/
- for (data = datahead; data; data = data->next) {
- if (data->nonempty) {
- obj_record (data->letype, data->ledata, data->lptr);
- if (data->fptr != data->fixupp)
- obj_record (data->ftype, data->fixupp, data->fptr);
+ if (fnhead && debuginfo) {
+ seg = fnhead->lnhead->segment;
+
+ for (fn = fnhead; fn; fn = fn->next) {
+ /* write out current file name */
+ orp->type = COMENT;
+ orp->ori = ori_null;
+ obj_byte (orp, 0x40);
+ obj_byte (orp, dFILNAME);
+ obj_byte( orp,0);
+ obj_name( orp,fn->name);
+ obj_dword(orp, 0);
+ obj_emit2 (orp);
+
+ /* write out line numbers this file */
+
+ orp->type = LINNUM;
+ orp->ori = ori_linnum;
+ for (ln = fn->lnhead; ln; ln = ln->next) {
+ if (seg != ln->segment) {
+ /* if we get here have to flush the buffer and start
+ * a new record for a new segment
+ */
+ seg = ln->segment;
+ obj_emit ( orp );
+ }
+ orp->parm[0] = seg->grp ? seg->grp->obj_index : 0;
+ orp->parm[1] = seg->obj_index;
+ orp = obj_word(orp, ln->lineno);
+ orp = obj_x(orp, ln->offset);
+ obj_commit (orp);
+ }
+ obj_emit (orp);
}
}
-
/*
- * Write the MODEND module end marker.
+ * we are going to locate the entry point segment now
+ * rather than wait until the MODEND record, because,
+ * then we can output a special symbol to tell where the
+ * entry point is.
+ *
*/
- recptr = record;
- rectype = MODEND;
if (obj_entry_seg != NO_SEG) {
- recptr = obj_write_byte (recptr, 0xC1);
- /*
- * Find the segment in the segment list.
- */
for (seg = seghead; seg; seg = seg->next) {
if (seg->index == obj_entry_seg) {
- if (seg->grp) {
- recptr = obj_write_byte (recptr, 0x10);
- recptr = obj_write_index (recptr, seg->grp->obj_index);
- } else {
- recptr = obj_write_byte (recptr, 0x50);
- }
- recptr = obj_write_index (recptr, seg->obj_index);
- if (seg->use32) {
- rectype = MODEND+1;
- recptr = obj_write_dword (recptr, obj_entry_ofs);
- } else
- recptr = obj_write_word (recptr, obj_entry_ofs);
+ entry_seg_ptr = seg;
break;
}
}
if (!seg)
error(ERR_NONFATAL, "entry point is not in this module");
- } else
- recptr = obj_write_byte (recptr, 0);
- obj_record (rectype, record, recptr);
-}
-
-static unsigned char *obj_write_data(unsigned char *ptr,
- unsigned char *data, int len) {
- while (len--)
- *ptr++ = *data++;
- return ptr;
-}
-
-static unsigned char *obj_write_byte(unsigned char *ptr, int data) {
- *ptr++ = data;
- return ptr;
-}
-
-static unsigned char *obj_write_word(unsigned char *ptr, int data) {
- *ptr++ = data & 0xFF;
- *ptr++ = (data >> 8) & 0xFF;
- return ptr;
-}
-
-static unsigned char *obj_write_dword(unsigned char *ptr, long data) {
- *ptr++ = data & 0xFF;
- *ptr++ = (data >> 8) & 0xFF;
- *ptr++ = (data >> 16) & 0xFF;
- *ptr++ = (data >> 24) & 0xFF;
- return ptr;
-}
-
-static unsigned char *obj_write_rword(unsigned char *ptr, int data) {
- *ptr++ = (data >> 8) & 0xFF;
- *ptr++ = data & 0xFF;
- return ptr;
-}
-
-static unsigned char *obj_write_name(unsigned char *ptr, char *data) {
- *ptr++ = strlen(data);
- if (obj_uppercase) {
- while (*data) {
- *ptr++ = (unsigned char) toupper(*data);
- data++;
- }
- } else {
- while (*data)
- *ptr++ = (unsigned char) *data++;
}
- return ptr;
-}
-static unsigned char *obj_write_index(unsigned char *ptr, int data) {
- if (data < 128)
- *ptr++ = data;
- else {
- *ptr++ = 0x80 | ((data >> 8) & 0x7F);
- *ptr++ = data & 0xFF;
+ /*
+ * get ready to put out symbol records
+ */
+ orp->type = COMENT;
+ orp->ori = ori_local;
+
+ /*
+ * put out a symbol for the entry point
+ * no dots in this symbol, because, borland does
+ * not (officially) support dots in label names
+ * and I don't know what various versions of TLINK will do
+ */
+ if (debuginfo && obj_entry_seg != NO_SEG) {
+ orp = obj_name (orp,"start_of_program");
+ orp = obj_word (orp,0x19); /* type: near label */
+ orp = obj_index (orp, seg->grp ? seg->grp->obj_index : 0);
+ orp = obj_index (orp, seg->obj_index);
+ orp = obj_x (orp, obj_entry_ofs);
+ obj_commit (orp);
+ }
+
+ /*
+ * put out the local labels
+ */
+ for (seg = seghead; seg && debuginfo; seg = seg->next) {
+ /* labels this seg */
+ for (loc = seg->lochead; loc; loc = loc->next) {
+ orp = obj_name (orp,loc->name);
+ orp = obj_word (orp, loc->type);
+ orp = obj_index (orp, seg->grp ? seg->grp->obj_index : 0);
+ orp = obj_index (orp, seg->obj_index);
+ orp = obj_x (orp,loc->offset);
+ obj_commit (orp);
+ }
}
- return ptr;
-}
+ if (orp->used)
+ obj_emit (orp);
-static unsigned char *obj_write_value(unsigned char *ptr,
- unsigned long data) {
- if (data <= 128)
- *ptr++ = data;
- else if (data <= 0xFFFF) {
- *ptr++ = 129;
- *ptr++ = data & 0xFF;
- *ptr++ = (data >> 8) & 0xFF;
- } else if (data <= 0xFFFFFFL) {
- *ptr++ = 132;
- *ptr++ = data & 0xFF;
- *ptr++ = (data >> 8) & 0xFF;
- *ptr++ = (data >> 16) & 0xFF;
- } else {
- *ptr++ = 136;
- *ptr++ = data & 0xFF;
- *ptr++ = (data >> 8) & 0xFF;
- *ptr++ = (data >> 16) & 0xFF;
- *ptr++ = (data >> 24) & 0xFF;
+ /*
+ * Write the LEDATA/FIXUPP pairs.
+ */
+ for (seg = seghead; seg; seg = seg->next) {
+ obj_emit (seg->orp);
+ nasm_free (seg->orp);
}
- return ptr;
+
+ /*
+ * Write the MODEND module end marker.
+ */
+ orp->type = MODEND;
+ orp->ori = ori_null;
+ if (entry_seg_ptr) {
+ obj_byte (orp, 0xC1);
+ seg = entry_seg_ptr;
+ if (seg->grp) {
+ obj_byte (orp, 0x10);
+ obj_index (orp, seg->grp->obj_index);
+ } else {
+ /*
+ * the below changed to prevent TLINK crashing.
+ * Previous more efficient version read:
+ *
+ * obj_byte (orp, 0x50);
+ */
+ obj_byte (orp, 0x00);
+ obj_index (orp, seg->obj_index);
+ }
+ obj_index (orp, seg->obj_index);
+ obj_x (orp, obj_entry_ofs);
+ } else
+ obj_byte (orp, 0);
+ obj_emit2 (orp);
+ nasm_free (orp);
}
-static void obj_record(int type, unsigned char *start, unsigned char *end) {
- unsigned long cksum, len;
+void obj_fwrite(ObjRecord *orp)
+{
+ unsigned int cksum, len;
+ unsigned char *ptr;
- cksum = type;
- fputc (type, ofp);
- len = end-start+1;
+ cksum = orp->type;
+ if (orp->x_size == 32)
+ cksum |= 1;
+ fputc (cksum, ofp);
+ len = orp->committed+1;
cksum += (len & 0xFF) + ((len>>8) & 0xFF);
fwriteshort (len, ofp);
- fwrite (start, 1, end-start, ofp);
- while (start < end)
- cksum += *start++;
- fputc ( (-(long)cksum) & 0xFF, ofp);
+ fwrite (orp->buf, 1, len-1, ofp);
+ for (ptr=orp->buf; --len; ptr++)
+ cksum += *ptr;
+ fputc ( (-cksum) & 0xFF, ofp);
}
static char *obj_stdmac[] = {
"%imacro group 1+.nolist",
"[group %1]",
"%endmacro",
- "%imacro uppercase 1+.nolist",
+ "%imacro uppercase 0+.nolist",
"[uppercase %1]",
"%endmacro",
"%imacro export 1+.nolist",
"%imacro import 1+.nolist",
"[import %1]",
"%endmacro",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
NULL
};
+void dbgbi_init(struct ofmt * of, void * id, FILE * fp, efunc error)
+{
+ (void) of;
+ (void) id;
+ (void) fp;
+ (void) error;
+
+ fnhead = NULL;
+ fntail = &fnhead;
+ arrindex = ARRAYBOT ;
+ arrhead = NULL;
+ arrtail = &arrhead;
+}
+static void dbgbi_cleanup(void)
+{
+ struct Segment *segtmp;
+ while (fnhead) {
+ struct FileName *fntemp = fnhead;
+ while (fnhead->lnhead) {
+ struct LineNumber *lntemp = fnhead->lnhead;
+ fnhead->lnhead = lntemp->next;
+ nasm_free( lntemp);
+ }
+ fnhead = fnhead->next;
+ nasm_free (fntemp->name);
+ nasm_free (fntemp);
+ }
+ for (segtmp=seghead; segtmp; segtmp=segtmp->next) {
+ while (segtmp->lochead) {
+ struct Public *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);
+ }
+}
+
+static void dbgbi_linnum (const char *lnfname, long lineno, long segto)
+{
+ struct FileName *fn;
+ struct LineNumber *ln;
+ struct Segment *seg;
+
+ 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 != obj_segment("__NASMDEFSEG", 2, &tempint))
+ error (ERR_PANIC, "strange segment conditions in OBJ driver");
+ }
+
+ /*
+ * Find the segment we are targetting.
+ */
+ for (seg = seghead; seg; seg = seg->next)
+ if (seg->index == segto)
+ break;
+ if (!seg)
+ error (ERR_PANIC, "lineno directed to nonexistent segment?");
+
+ for (fn = fnhead; fn; fn = fnhead->next)
+ if (!nasm_stricmp(lnfname,fn->name))
+ break;
+ if (!fn) {
+ fn = nasm_malloc ( sizeof( *fn));
+ fn->name = nasm_malloc ( strlen(lnfname) + 1) ;
+ strcpy (fn->name,lnfname);
+ fn->lnhead = NULL;
+ fn->lntail = & fn->lnhead;
+ fn->next = NULL;
+ *fntail = fn;
+ fntail = &fn->next;
+ }
+ ln = nasm_malloc ( sizeof( *ln));
+ ln->segment = seg;
+ ln->offset = seg->currentpos;
+ ln->lineno = lineno;
+ ln->next = NULL;
+ *fn->lntail = ln;
+ fn->lntail = &ln->next;
+
+}
+static void dbgbi_deflabel (char *name, long segment,
+ long offset, int is_global, char *special)
+{
+ struct Segment *seg;
+
+ (void) special;
+
+ /*
+ * If it's a special-retry from pass two, discard it.
+ */
+ if (is_global == 3)
+ return;
+
+ /*
+ * First check for the double-period, signifying something
+ * unusual.
+ */
+ if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+ return;
+ }
+
+ /*
+ * Case (i):
+ */
+ if (obj_seg_needs_update) {
+ return;
+ } else if (obj_grp_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 obj_deflabel so we can skip that.
+ */
+
+ for (seg = seghead; seg; seg = seg->next)
+ if (seg->index == segment) {
+ struct Public *loc = nasm_malloc (sizeof(*loc));
+ /*
+ * Case (ii). Maybe MODPUB someday?
+ */
+ last_defined = *seg->loctail = loc;
+ seg->loctail = &loc->next;
+ loc->next = NULL;
+ loc->name = nasm_strdup(name);
+ loc->offset = offset;
+ }
+}
+static void dbgbi_typevalue (long type)
+{
+ int vsize;
+ int elem = TYM_ELEMENTS(type);
+ type = TYM_TYPE(type);
+
+ if (!last_defined)
+ return;
+
+ switch (type) {
+ case TY_BYTE:
+ last_defined->type = 8; /* unsigned char */
+ vsize = 1;
+ break;
+ case TY_WORD:
+ last_defined->type = 10; /* unsigned word */
+ vsize = 2;
+ break;
+ case TY_DWORD:
+ last_defined->type = 12; /* unsigned dword */
+ vsize = 4;
+ break;
+ case TY_FLOAT:
+ last_defined->type = 14; /* float */
+ vsize = 4;
+ break;
+ case TY_QWORD:
+ last_defined->type = 15; /* qword */
+ vsize = 8;
+ break;
+ case TY_TBYTE:
+ last_defined->type = 16; /* TBYTE */
+ vsize = 10;
+ break;
+ default:
+ last_defined->type = 0x19; /*label */
+ vsize = 0;
+ break;
+ }
+
+ if (elem > 1) {
+ struct Array *arrtmp = nasm_malloc (sizeof(*arrtmp));
+ int vtype = last_defined->type;
+ arrtmp->size = vsize * elem;
+ arrtmp->basetype = vtype;
+ arrtmp->next = NULL;
+ last_defined->type = arrindex++;
+ *arrtail = arrtmp;
+ arrtail = & (arrtmp->next);
+ }
+ last_defined = NULL;
+}
+static void dbgbi_output (int output_type, void *param)
+{
+ (void) output_type;
+ (void) param;
+}
+static struct dfmt borland_debug_form = {
+ "Borland Debug Records",
+ "borland",
+ dbgbi_init,
+ dbgbi_linnum,
+ dbgbi_deflabel,
+ null_debug_routine,
+ dbgbi_typevalue,
+ dbgbi_output,
+ dbgbi_cleanup,
+};
+
+static struct dfmt *borland_debug_arr[3] = {
+ &borland_debug_form,
+ &null_debug_form,
+ NULL
+};
+
struct ofmt of_obj = {
- "Microsoft MS-DOS 16-bit OMF object files",
+ "MS-DOS 16-bit/32-bit OMF object files",
"obj",
+ NULL,
+ borland_debug_arr,
+ &null_debug_form,
obj_stdmac,
obj_init,
+ obj_set_info,
obj_out,
obj_deflabel,
obj_segment,
struct RelocRec rr;
unsigned char databuf[4],*pd;
+ if (segto == NO_SEG) {
+ if ((type & OUT_TYPMASK) != OUT_RESERVE)
+ error (ERR_NONFATAL, "attempt to assemble code in ABSOLUTE space");
+ return;
+ }
+
segto >>= 1; /* convert NASM segment no to RDF number */
if (segto != 0 && segto != 1 && segto != 2) {
}
}
-static void rdf_cleanup (void) {
+static void rdf_cleanup (int debuginfo) {
long l;
unsigned char b[4],*d;
struct BSSRec bs;
+ (void) debuginfo;
+
/* should write imported & exported symbol declarations to header here */
"%imacro library 1+.nolist",
"[library %1]",
"%endmacro",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
NULL
};
+static int rdf_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
+
struct ofmt of_rdf = {
"Relocatable Dynamic Object File Format v1.1",
+#ifdef OF_RDF2
+ "oldrdf",
+#else
"rdf",
+#endif
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
rdf_stdmac,
rdf_init,
+ rdf_set_info,
rdf_out,
rdf_deflabel,
rdf_section_names,
--- /dev/null
+/* outrdf2.c output routines for the Netwide Assembler to produce
+ * RDOFF version 2 format object files (which are intended
+ * mainly for use in proprietary projects, as the code to
+ * load and execute them is very simple). They will also be
+ * used for device drivers and possibly some executable files
+ * in the MOSCOW operating system. See Rdoff.txt for
+ * details.
+ *
+ * The Netwide Assembler is copyright (C) 1996-1998 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the licence given in the file "Licence"
+ * distributed in the NASM archive.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "outform.h"
+
+/* VERBOSE_WARNINGS: define this to add some extra warnings... */
+#define VERBOSE_WARNINGS
+
+#ifdef OF_RDF2
+
+#define RDF_MAXSEGS 64 /* maximum number of segments - user configurable */
+
+typedef unsigned short int16;
+typedef unsigned char byte;
+
+static const char *RDOFF2Id = "RDOFF2"; /* written to start of RDOFF files */
+
+
+/* the records that can be found in the RDOFF header */
+
+/* Note that whenever a segment is referred to in the RDOFF file, its number
+ * is always half of the segment number that NASM uses to refer to it; this
+ * is because NASM only allocates even numbered segments, so as to not
+ * waste any of the 16 bits of segment number written to the file - this
+ * allows up to 65533 external labels to be defined; otherwise it would be
+ * 32764. */
+
+struct RelocRec {
+ byte type; /* must be 1, or 6 for segment base ref */
+ byte reclen; /* set to 8 */
+ byte segment; /* only 0 for code, or 1 for data supported,
+ * but add 64 for relative refs (ie do not require
+ * reloc @ loadtime, only linkage) */
+ long offset; /* from start of segment in which reference is loc'd */
+ byte length; /* 1 2 or 4 bytes */
+ int16 refseg; /* segment to which reference refers to */
+};
+
+struct ImportRec {
+ byte type; /* must be 2, or 7 for FAR import */
+ byte reclen; /* equals 3+label length */
+ int16 segment; /* segment number allocated to the label for reloc
+ * records - label is assumed to be at offset zero
+ * in this segment, so linker must fix up with offset
+ * of segment and of offset within segment */
+ char label[33]; /* zero terminated... should be written to file until
+ * the zero, but not after it - max len = 32 chars */
+};
+
+struct ExportRec {
+ byte type; /* must be 3 */
+ byte reclen; /* equals 6+label length */
+ byte segment; /* segment referred to (0/1) */
+ long offset; /* offset within segment */
+ char label[33]; /* zero terminated as above. max len = 32 chars */
+};
+
+struct DLLRec {
+ byte type; /* must be 4 */
+ byte reclen; /* equals 1+library name */
+ char libname[128]; /* name of library to link with at load time */
+};
+
+struct BSSRec {
+ byte type; /* must be 5 */
+ byte reclen; /* equeals 4 */
+ long amount; /* number of bytes BSS to reserve */
+};
+
+#define COUNT_SEGTYPES 9
+
+static char * segmenttypes[COUNT_SEGTYPES] = {
+ "null", "text", "code", "data", "comment", "lcomment", "pcomment",
+ "symdebug", "linedebug"
+};
+
+static int segmenttypenumbers[COUNT_SEGTYPES] = {
+ 0, 1, 1, 2, 3, 4, 5, 6, 7
+};
+
+/* code for managing buffers needed to seperate code and data into individual
+ * sections until they are ready to be written to the file.
+ * We'd better hope that it all fits in memory else we're buggered... */
+
+#define BUF_BLOCK_LEN 4088 /* selected to match page size (4096)
+ * on 80x86 machines for efficiency */
+
+/***********************************************************************
+ * Actual code to deal with RDOFF2 ouput format begins here...
+ */
+
+/* global variables set during the initialisation phase */
+
+static struct SAA *seg[RDF_MAXSEGS]; /* seg 0 = code, seg 1 = data */
+static struct SAA *header; /* relocation/import/export records */
+
+static FILE *ofile;
+
+static efunc error;
+
+static struct seginfo {
+ char *segname;
+ int segnumber;
+ int16 segtype;
+ int16 segreserved;
+ long seglength;
+} segments[RDF_MAXSEGS];
+
+static int nsegments;
+
+static long bsslength;
+static long headerlength;
+
+static void rdf2_init(FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
+ int segtext, segdata, segbss;
+
+ /* set up the initial segments */
+ segments[0].segname = ".text";
+ segments[0].segnumber = 0;
+ segments[0].segtype = 1;
+ segments[0].segreserved = 0;
+ segments[0].seglength = 0;
+
+ segments[1].segname = ".data";
+ segments[1].segnumber = 1;
+ segments[1].segtype = 2;
+ segments[1].segreserved = 0;
+ segments[1].seglength = 0;
+
+ segments[2].segname = ".bss";
+ segments[2].segnumber = 2;
+ segments[2].segtype = 0xFFFF; /* reserved - should never be produced */
+ segments[2].segreserved = 0;
+ segments[2].seglength = 0;
+
+ nsegments = 3;
+
+ ofile = fp;
+ error = errfunc;
+
+ seg[0] = saa_init(1L);
+ seg[1] = saa_init(1L);
+ seg[2] = NULL; /* special case! */
+
+ header = saa_init(1L);
+
+ segtext = seg_alloc();
+ segdata = seg_alloc();
+ segbss = seg_alloc();
+ if (segtext != 0 || segdata != 2 || segbss != 4)
+ error(ERR_PANIC,"rdf segment numbers not allocated as expected (%d,%d,%d)",
+ segtext,segdata,segbss);
+ bsslength=0;
+ headerlength = 0;
+}
+
+static long rdf2_section_names(char *name, int pass, int *bits)
+{
+ int i;
+ char * p, * q;
+ int code = -1;
+ int reserved = 0;
+
+ /*
+ * Default is 32 bits, in the text segment.
+ */
+ if (!name) {
+ *bits = 32;
+ return 0;
+ }
+
+ /* look for segment type code following segment name */
+ p = name;
+ while (*p && !isspace(*p)) p++;
+ if (*p) { /* we're now in whitespace */
+ *p++ = '\0';
+ while (*p && isspace(80)) *p++ = '\0';
+ }
+ if (*p) { /* we're now in an attribute value */
+ /*
+ * see if we have an optional ',number' following the type code
+ */
+ if ((q = strchr(p, ','))) {
+ *q++ = '\0';
+
+ reserved = readnum(q, &i);
+ if (i) {
+ error(ERR_NONFATAL, "value following comma must be numeric");
+ reserved = 0;
+ }
+ }
+ /*
+ * check it against the text strings in segmenttypes
+ */
+
+ for (i = 0; i < COUNT_SEGTYPES; i++)
+ if (!nasm_stricmp(p, segmenttypes[i])) {
+ code = segmenttypenumbers[i];
+ break;
+ }
+ if (code == -1) { /* didn't find anything */
+ code = readnum(p, &i);
+ if (i) {
+ error(ERR_NONFATAL, "unrecognised RDF segment type (%s)",p);
+ code = 3;
+ }
+ }
+ }
+ for (i = 0; i < nsegments; i++) {
+ if (!strcmp(name, segments[i].segname)) {
+ if (code != -1 || reserved != 0)
+ error(ERR_NONFATAL, "segment attributes specified on"
+ " redeclaration of segment");
+ return segments[i].segnumber * 2;
+ }
+ }
+
+ /* declaring a new segment! */
+
+ if (code == -1) {
+ error(ERR_NONFATAL, "new segment declared without type code");
+ code = 3;
+ }
+ if (nsegments == RDF_MAXSEGS) {
+ error(ERR_FATAL, "reached compiled-in maximum segment limit (%d)",
+ RDF_MAXSEGS);
+ return NO_SEG;
+ }
+
+ segments[nsegments].segname = nasm_strdup(name);
+ i = seg_alloc();
+ if (i % 2 != 0)
+ error(ERR_PANIC, "seg_alloc() returned odd number");
+ segments[nsegments].segnumber = i >> 1;
+ segments[nsegments].segtype = code;
+ segments[nsegments].segreserved = reserved;
+ segments[nsegments].seglength = 0;
+
+ seg[nsegments] = saa_init(1L);
+
+ return i;
+}
+
+static void write_reloc_rec(struct RelocRec *r)
+{
+ char buf[4],*b;
+
+ if (r->refseg != (int16)NO_SEG && (r->refseg & 1)) /* segment base ref */
+ r->type = 6;
+
+ r->refseg >>= 1; /* adjust segment nos to RDF rather than NASM */
+
+ saa_wbytes(header,&r->type,1);
+ saa_wbytes(header,&r->reclen,1);
+ saa_wbytes(header,&r->segment,1);
+ b = buf; WRITELONG(b,r->offset);
+ saa_wbytes(header,buf,4);
+ saa_wbytes(header,&r->length,1);
+ b = buf; WRITESHORT(b,r->refseg);
+ saa_wbytes(header,buf,2);
+ headerlength += r->reclen + 2;
+}
+
+static void write_export_rec(struct ExportRec *r)
+{
+ char buf[4], *b;
+
+ r->segment >>= 1;
+
+ saa_wbytes(header,&r->type,1);
+ saa_wbytes(header,&r->reclen,1);
+ saa_wbytes(header,&r->segment,1);
+ b = buf; WRITELONG(b,r->offset);
+ saa_wbytes(header,buf,4);
+ saa_wbytes(header,r->label,strlen(r->label) + 1);
+ headerlength += r->reclen + 2;
+}
+
+static void write_import_rec(struct ImportRec *r)
+{
+ char buf[4], *b;
+
+ r->segment >>= 1;
+
+ saa_wbytes(header,&r->type,1);
+ saa_wbytes(header,&r->reclen,1);
+ b = buf; WRITESHORT(b,r->segment);
+ saa_wbytes(header,buf,2);
+ saa_wbytes(header,r->label,strlen(r->label) + 1);
+ headerlength += r->reclen + 2;
+}
+
+static void write_bss_rec(struct BSSRec *r)
+{
+ char buf[4], *b;
+
+ saa_wbytes(header,&r->type,1);
+ saa_wbytes(header,&r->reclen,1);
+ b = buf; WRITELONG(b,r->amount);
+ saa_wbytes(header,buf,4);
+ headerlength += r->reclen + 2;
+}
+
+static void write_dll_rec(struct DLLRec *r)
+{
+ saa_wbytes(header,&r->type,1);
+ saa_wbytes(header,&r->reclen,1);
+ saa_wbytes(header,r->libname,strlen(r->libname) + 1);
+ headerlength += r->reclen + 2;
+}
+
+static void rdf2_deflabel(char *name, long segment, long offset,
+ int is_global, char *special)
+{
+ struct ExportRec r;
+ struct ImportRec ri;
+#ifdef VERBOSE_WARNINGS
+ static int warned_common = 0;
+#endif
+ static int farsym = 0;
+ static int i;
+
+ if (special) {
+ while(*special == ' ' || *special == '\t') special++;
+
+ if (!nasm_stricmp(special, "far")) {
+ farsym = 1;
+ }
+ else if (!nasm_stricmp(special, "near")) {
+ farsym = 0;
+ }
+ else
+ error(ERR_NONFATAL, "unrecognised symbol type `%s'", special);
+ }
+
+ if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+ error (ERR_NONFATAL, "unrecognised special symbol `%s'", name);
+ return;
+ }
+
+ if (is_global == 2) {
+#ifdef VERBOSE_WARNINGS
+ if (!warned_common) {
+ error(ERR_WARNING,"common declarations not supported: using extern");
+ warned_common = 1;
+ }
+#endif
+ is_global = 1;
+ }
+
+ for (i = 0; i < nsegments; i++) {
+ if (segments[i].segnumber == segment>>1) break;
+ }
+ if (i >= nsegments) { /* EXTERN declaration */
+ if (farsym)
+ ri.type = 7;
+ else
+ ri.type = 2;
+ ri.segment = segment;
+ strncpy(ri.label,name,32);
+ ri.label[32] = 0;
+ ri.reclen = 3 + strlen(ri.label);
+ write_import_rec(&ri);
+ } else if (is_global) {
+ r.type = 3;
+ r.segment = segment;
+ r.offset = offset;
+ strncpy(r.label,name,32);
+ r.label[32] = 0;
+ r.reclen = 6 + strlen(r.label);
+ write_export_rec(&r);
+ }
+}
+
+static void membufwrite(int segment, void * data, int bytes)
+{
+ int i;
+ char buf[4], * b;
+
+ for (i = 0; i < nsegments; i++) {
+ if (segments[i].segnumber == segment) break;
+ }
+ if (i == nsegments)
+ error(ERR_PANIC, "can't find segment %d", segment);
+
+ if (bytes < 0) {
+ b = buf;
+ if (bytes == -2)
+ WRITESHORT(b,*(short *)data);
+ else
+ WRITELONG(b,*(long *)data);
+ data = buf;
+ bytes = -bytes;
+ }
+ segments[i].seglength += bytes;
+ saa_wbytes(seg[i],data,bytes);
+}
+
+static int getsegmentlength(int segment)
+{
+ int i;
+ for (i = 0; i < nsegments; i++) {
+ if (segments[i].segnumber == segment) break;
+ }
+ if (i == nsegments)
+ error(ERR_PANIC, "can't find segment %d", segment);
+
+ return segments[i].seglength;
+}
+
+static void rdf2_out (long segto, void *data, unsigned long type,
+ long segment, long wrt)
+{
+ long bytes = type & OUT_SIZMASK;
+ struct RelocRec rr;
+ unsigned char databuf[4],*pd;
+ int seg;
+
+ if (segto == NO_SEG) {
+ if ((type & OUT_TYPMASK) != OUT_RESERVE)
+ error (ERR_NONFATAL, "attempt to assemble code in ABSOLUTE space");
+ return;
+ }
+
+ segto >>= 1; /* convert NASM segment no to RDF number */
+
+ for (seg = 0; seg < nsegments; seg++) {
+ if (segments[seg].segnumber == segto) break;
+ }
+ if (seg >= nsegments) {
+ error(ERR_NONFATAL,"specified segment not supported by rdf output format");
+ return;
+ }
+
+ if (wrt != NO_SEG) {
+ wrt = NO_SEG; /* continue to do _something_ */
+ error (ERR_NONFATAL, "WRT not supported by rdf output format");
+ }
+
+ type &= OUT_TYPMASK;
+
+ if (segto == 2 && type != OUT_RESERVE)
+ {
+ error(ERR_NONFATAL, "BSS segments may not be initialised");
+
+ /* just reserve the space for now... */
+
+ if (type == OUT_REL2ADR)
+ bytes = 2;
+ else
+ bytes = 4;
+ type = OUT_RESERVE;
+ }
+
+ if (type == OUT_RESERVE) {
+ if (segto == 2) /* BSS segment space reserverd */
+ bsslength += bytes;
+ else
+ while (bytes --)
+ membufwrite(segto,databuf,1);
+ }
+ else if (type == OUT_RAWDATA) {
+ if (segment != NO_SEG)
+ error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
+
+ membufwrite(segto,data,bytes);
+ }
+ else if (type == OUT_ADDRESS) {
+
+ /* if segment == NO_SEG then we are writing an address of an
+ object within the same segment - do not produce reloc rec. */
+
+ /* FIXME - is this behaviour sane? at first glance it doesn't
+ appear to be. Must test this thoroughly...! */
+
+ if (segment != NO_SEG)
+ {
+ /* it's an address, so we must write a relocation record */
+
+ rr.type = 1; /* type signature */
+ rr.reclen = 8;
+ rr.segment = segto; /* segment we're currently in */
+ rr.offset = getsegmentlength(segto); /* current offset */
+ rr.length = bytes; /* length of reference */
+ rr.refseg = segment; /* segment referred to */
+ write_reloc_rec(&rr);
+ }
+
+ pd = databuf; /* convert address to little-endian */
+ if (bytes == 2)
+ WRITESHORT (pd, *(long *)data);
+ else
+ WRITELONG (pd, *(long *)data);
+
+ membufwrite(segto,databuf,bytes);
+
+ }
+ else if (type == OUT_REL2ADR)
+ {
+ if (segment == segto)
+ error(ERR_PANIC, "intra-segment OUT_REL2ADR");
+
+ rr.reclen = 8;
+ rr.offset = getsegmentlength(segto); /* current offset */
+ rr.length = 2; /* length of reference */
+ rr.refseg = segment; /* segment referred to (will be >>1'd)*/
+
+ if (segment != NO_SEG && segment % 2) {
+ rr.type = 6;
+ rr.segment = segto; /* memory base refs *aren't ever* relative! */
+ write_reloc_rec(&rr);
+
+ /* what do we put in the code? Simply the data. This should almost
+ * always be zero, unless someone's doing segment arithmetic...
+ */
+ rr.offset = *(long *) data;
+ }
+ else
+ {
+ rr.type = 1; /* type signature */
+ rr.segment = segto+64; /* segment we're currently in + rel flag */
+ write_reloc_rec(&rr);
+
+ /* work out what to put in the code: offset of the end of this operand,
+ * subtracted from any data specified, so that loader can just add
+ * address of imported symbol onto it to get address relative to end of
+ * instruction: import_address + data(offset) - end_of_instrn */
+
+ rr.offset = *(long *)data -(rr.offset + bytes);
+ }
+
+ membufwrite(segto,&rr.offset,-2);
+ }
+ else if (type == OUT_REL4ADR)
+ {
+ if (segment == segto)
+ error(ERR_PANIC, "intra-segment OUT_REL4ADR");
+ if (segment != NO_SEG && segment % 2) {
+ error(ERR_PANIC, "erm... 4 byte segment base ref?");
+ }
+
+ rr.type = 1; /* type signature */
+ rr.segment = segto+64; /* segment we're currently in + rel tag */
+ rr.offset = getsegmentlength(segto); /* current offset */
+ rr.length = 4; /* length of reference */
+ rr.refseg = segment; /* segment referred to */
+ rr.reclen = 8;
+ write_reloc_rec(&rr);
+
+ rr.offset = *(long *)data -(rr.offset + bytes);
+
+ membufwrite(segto,&rr.offset,-4);
+ }
+}
+
+static void rdf2_cleanup (int debuginfo) {
+ long l;
+ struct BSSRec bs;
+ int i;
+
+ (void) debuginfo;
+
+ /* should write imported & exported symbol declarations to header here */
+
+ /* generate the output file... */
+ fwrite(RDOFF2Id,6,1,ofile); /* file type magic number */
+
+ if (bsslength != 0) /* reserve BSS */
+ {
+ bs.type = 5;
+ bs.amount = bsslength;
+ bs.reclen = 4;
+ write_bss_rec(&bs);
+ }
+
+ /*
+ * calculate overall length of the output object
+ */
+ l = headerlength + 4;
+
+ for (i = 0; i < nsegments; i++) {
+ if (i == 2) continue; /* skip BSS segment */
+ l += 10 + segments[i].seglength;
+ }
+ l += 10; /* null segment */
+
+ fwritelong(l, ofile);
+
+ fwritelong(headerlength, ofile);
+ saa_fpwrite(header,ofile); /* dump header */
+ saa_free(header);
+
+ for (i = 0; i < nsegments; i++) {
+ if (i == 2) continue;
+
+ fwriteshort(segments[i].segtype, ofile);
+ fwriteshort(segments[i].segnumber, ofile);
+ fwriteshort(segments[i].segreserved, ofile);
+ fwritelong(segments[i].seglength, ofile);
+
+ saa_fpwrite(seg[i], ofile);
+ saa_free(seg[i]);
+ }
+
+ /* null segment - write 10 bytes of zero */
+ fwritelong(0,ofile);
+ fwritelong(0,ofile);
+ fwriteshort(0,ofile);
+
+ fclose(ofile);
+}
+
+static long rdf2_segbase (long segment) {
+ return segment;
+}
+
+static int rdf2_directive (char *directive, char *value, int pass) {
+ struct DLLRec r;
+
+ if (! strcmp(directive, "library")) {
+ if (pass == 1) {
+ r.type = 4;
+ strcpy(r.libname, value);
+ write_dll_rec(&r);
+ }
+ return 1;
+ }
+
+ return 0;
+}
+
+static void rdf2_filename (char *inname, char *outname, efunc error) {
+ standard_extension(inname,outname,".rdf",error);
+}
+
+static char *rdf2_stdmac[] = {
+ "%define __SECT__ [section .text]",
+ "%imacro library 1+.nolist",
+ "[library %1]",
+ "%endmacro",
+ "%macro __NASM_CDecl__ 1",
+ "%endmacro",
+ NULL
+};
+
+static int rdf2_set_info(enum geninfo type, char **val)
+{
+ return 0;
+}
+
+
+struct ofmt of_rdf2 = {
+ "Relocatable Dynamic Object File Format v2.0",
+ "rdf",
+ NULL,
+ null_debug_arr,
+ &null_debug_form,
+ rdf2_stdmac,
+ rdf2_init,
+ rdf2_set_info,
+ rdf2_out,
+ rdf2_deflabel,
+ rdf2_section_names,
+ rdf2_segbase,
+ rdf2_directive,
+ rdf2_filename,
+ rdf2_cleanup
+};
+
+#endif /* OF_RDF2 */
static int i;
static struct tokenval tokval;
static efunc error;
+static struct ofmt *outfmt; /* Structure of addresses of output routines */
+static loc_t *location; /* Pointer to current line's segment,offset */
+
+void parser_global_info (struct ofmt *output, loc_t *locp)
+{
+ outfmt = output;
+ location = locp;
+}
insn *parse_line (int pass, char *buffer, insn *result,
- efunc errfunc, evalfunc evaluate, evalinfofunc einfo) {
+ efunc errfunc, evalfunc evaluate, ldfunc ldef)
+{
int operand;
int critical;
struct eval_hints hints;
result->forw_ref = FALSE;
error = errfunc;
- einfo ("", 0L, 0L);
stdscan_reset();
stdscan_bufptr = buffer;
i = stdscan(NULL, &tokval);
+ result->label = NULL; /* Assume no label */
result->eops = NULL; /* must do this, whatever happens */
result->operands = 0; /* must initialise this */
if (i==0) { /* blank line - ignore */
- result->label = NULL; /* so, no label on it */
result->opcode = -1; /* and no instruction either */
return result;
}
(i!=TOKEN_REG || (REG_SREG & ~reg_flags[tokval.t_integer]))) {
error (ERR_NONFATAL, "label or instruction expected"
" at start of line");
- result->label = NULL;
result->opcode = -1;
return result;
}
if (i == TOKEN_ID) { /* there's a label here */
result->label = tokval.t_charptr;
- einfo (result->label, 0L, 0L);
i = stdscan(NULL, &tokval);
if (i == ':') { /* skip over the optional colon */
i = stdscan(NULL, &tokval);
- } else if (i == 0 && pass == 1) {
- error (ERR_WARNING|ERR_WARN_OL,
+ } else if (i == 0) {
+ error (ERR_WARNING|ERR_WARN_OL|ERR_PASS1,
"label alone on a line without a colon might be in error");
}
- } else /* no label; so, moving swiftly on */
- result->label = NULL;
+ if (i != TOKEN_INSN || tokval.t_integer != I_EQU)
+ {
+ /*
+ * FIXME: location->segment could be NO_SEG, in which case
+ * it is possible we should be passing 'abs_seg'. Look into this.
+ * Work out whether that is *really* what we should be doing.
+ * Generally fix things. I think this is right as it is, but
+ * am still not certain.
+ */
+ ldef (result->label, location->segment,
+ location->offset, NULL, TRUE, FALSE, outfmt, errfunc);
+ }
+ }
if (i==0) {
result->opcode = -1; /* this line contains just a label */
result->times = 1L;
while (i == TOKEN_PREFIX ||
- (i==TOKEN_REG && !(REG_SREG & ~reg_flags[tokval.t_integer]))) {
+ (i==TOKEN_REG && !(REG_SREG & ~reg_flags[tokval.t_integer])))
+ {
/*
* Handle special case: the TIMES prefix.
*/
result->times = 1L;
} else {
result->times = value->value;
- if (value->value < 0)
+ if (value->value < 0) {
error(ERR_NONFATAL, "TIMES value %d is negative",
value->value);
+ result->times = 0;
+ }
}
} else {
if (result->nprefix == MAXPREFIX)
result->opcode == I_RESQ ||
result->opcode == I_REST ||
result->opcode == I_EQU)
+ {
critical = pass;
+ }
else
critical = (pass==2 ? 2 : 0);
result->opcode == I_DD ||
result->opcode == I_DQ ||
result->opcode == I_DT ||
- result->opcode == I_INCBIN) {
+ result->opcode == I_INCBIN)
+ {
extop *eop, **tail = &result->eops, **fixptr;
int oper_num = 0;
+ result->eops_float = FALSE;
+
/*
- * Begin to read the DB/DW/DD/DQ/DT operands.
+ * Begin to read the DB/DW/DD/DQ/DT/INCBIN operands.
*/
while (1) {
i = stdscan(NULL, &tokval);
continue;
}
- if (i == TOKEN_FLOAT || i == '-') {
+ if ((i == TOKEN_FLOAT && is_comma_next()) || i == '-') {
long sign = +1L;
if (i == '-') {
char *save = stdscan_bufptr;
i = stdscan(NULL, &tokval);
sign = -1L;
- if (i != TOKEN_FLOAT) {
+ if (i != TOKEN_FLOAT || !is_comma_next()) {
stdscan_bufptr = save;
i = tokval.t_type = '-';
}
if (i == TOKEN_FLOAT) {
eop->type = EOT_DB_STRING;
+ result->eops_float = TRUE;
if (result->opcode == I_DD)
eop->stringlen = 4;
else if (result->opcode == I_DQ)
eop->stringlen = 8;
else if (result->opcode == I_DT)
- eop->stringlen = 10;
+ eop->stringlen = 10;
else {
error(ERR_NONFATAL, "floating-point constant"
" encountered in `D%c' instruction",
result->opcode == I_DW ? 'W' : 'B');
- eop->type = EOT_NOTHING;
+ /*
+ * fix suggested by Pedro Gimeno... original line
+ * was:
+ * eop->type = EOT_NOTHING;
+ */
+ eop->stringlen = 0;
}
eop = nasm_realloc(eop, sizeof(extop)+eop->stringlen);
tail = &eop->next;
*fixptr = eop;
eop->stringval = (char *)eop + sizeof(extop);
- if (!float_const (tokval.t_charptr, sign,
+ if (eop->stringlen < 4 ||
+ !float_const (tokval.t_charptr, sign,
(unsigned char *)eop->stringval,
eop->stringlen, error))
eop->type = EOT_NOTHING;
}
}
- /* anything else */ {
+ /* anything else */
+ {
expr *value;
value = evaluate (stdscan, NULL, &tokval, NULL,
critical, error, NULL);
*/
result->opcode = -1;
return result;
- }
+ } else /* DB ... */
+ if (oper_num == 0)
+ error (ERR_WARNING|ERR_PASS1,
+ "no operand for data declaration");
+ else
+ result->operands = oper_num;
return result;
}
expr *value; /* used most of the time */
int mref; /* is this going to be a memory ref? */
int bracket; /* is it a [] mref, or a & mref? */
+ int setsize = 0;
result->oprs[operand].addr_size = 0;/* have to zero this whatever */
result->oprs[operand].eaflags = 0; /* and this */
+ result->oprs[operand].opflags = 0;
+
i = stdscan(NULL, &tokval);
if (i == 0) break; /* end of operands: get out of here */
result->oprs[operand].type = 0; /* so far, no override */
while (i == TOKEN_SPECIAL) {/* size specifiers */
switch ((int)tokval.t_integer) {
case S_BYTE:
- result->oprs[operand].type |= BITS8;
+ if (!setsize) /* we want to use only the first */
+ result->oprs[operand].type |= BITS8;
+ setsize = 1;
break;
case S_WORD:
- result->oprs[operand].type |= BITS16;
+ if (!setsize)
+ result->oprs[operand].type |= BITS16;
+ setsize = 1;
break;
case S_DWORD:
case S_LONG:
- result->oprs[operand].type |= BITS32;
+ if (!setsize)
+ result->oprs[operand].type |= BITS32;
+ setsize = 1;
break;
case S_QWORD:
- result->oprs[operand].type |= BITS64;
+ if (!setsize)
+ result->oprs[operand].type |= BITS64;
+ setsize = 1;
break;
case S_TWORD:
- result->oprs[operand].type |= BITS80;
+ if (!setsize)
+ result->oprs[operand].type |= BITS80;
+ setsize = 1;
break;
case S_TO:
result->oprs[operand].type |= TO;
case S_SHORT:
result->oprs[operand].type |= SHORT;
break;
+ default:
+ error (ERR_NONFATAL, "invalid operand size specification");
}
i = stdscan(NULL, &tokval);
}
}
value = evaluate (stdscan, NULL, &tokval,
- &result->forw_ref, critical, error, &hints);
+ &result->oprs[operand].opflags,
+ critical, error, &hints);
i = tokval.t_type;
+ if (result->oprs[operand].opflags & OPFLAG_FORWARD) {
+ result->forw_ref = TRUE;
+ }
if (!value) { /* error in evaluator */
result->opcode = -1; /* unrecoverable parse error: */
return result; /* ignore this instruction */
i = stdscan(NULL, &tokval);
}
value = evaluate (stdscan, NULL, &tokval,
- &result->forw_ref, critical, error, &hints);
+ &result->oprs[operand].opflags,
+ critical, error, &hints);
i = tokval.t_type;
+ if (result->oprs[operand].opflags & OPFLAG_FORWARD) {
+ result->forw_ref = TRUE;
+ }
/* and get the offset */
if (!value) { /* but, error in evaluator */
result->opcode = -1; /* unrecoverable parse error: */
i = e->type, s = e->value;
e++;
}
- if (e->type && e->type <= EXPR_REG_END) {/* it's a 2nd register */
- if (e->value != 1) { /* it has to be indexreg */
- if (i != -1) { /* but it can't be */
- error(ERR_NONFATAL, "invalid effective address");
- result->opcode = -1;
- return result;
- } else
- i = e->type, s = e->value;
- } else { /* it can be basereg */
- if (b != -1) /* or can it? */
- i = e->type, s = 1;
- else
- b = e->type;
- }
+ if (e->type && e->type <= EXPR_REG_END) /* it's a 2nd register */
+ {
+ if (b != -1) /* If the first was the base, ... */
+ i = e->type, s = e->value; /* second has to be indexreg */
+
+ else if (e->value != 1) /* If both want to be index */
+ {
+ error(ERR_NONFATAL, "invalid effective address");
+ result->opcode = -1;
+ return result;
+ }
+ else
+ b = e->type;
e++;
}
if (e->type != 0) { /* is there an offset? */
- if (e->type <= EXPR_REG_END) {/* in fact, is there an error? */
+ if (e->type <= EXPR_REG_END) /* in fact, is there an error? */
+ {
error (ERR_NONFATAL, "invalid effective address");
result->opcode = -1;
return result;
- } else {
+ }
+ else
+ {
if (e->type == EXPR_UNKNOWN) {
- o = 0; /* doesn't matter what */
- result->oprs[operand].wrt = NO_SEG; /* nor this */
+ o = 0; /* doesn't matter what */
+ result->oprs[operand].wrt = NO_SEG; /* nor this */
result->oprs[operand].segment = NO_SEG; /* or this */
while (e->type) e++; /* go to the end of the line */
- } else {
+ }
+ else
+ {
if (e->type == EXPR_SIMPLE) {
o = e->value;
e++;
result->oprs[operand].indexreg = i;
result->oprs[operand].scale = s;
result->oprs[operand].offset = o;
- } else { /* it's not a memory reference */
+ }
+ else /* it's not a memory reference */
+ {
if (is_just_unknown(value)) { /* it's immediate but unknown */
result->oprs[operand].type |= IMMEDIATE;
result->oprs[operand].offset = 0; /* don't care */
result->oprs[operand].segment = NO_SEG; /* don't care again */
result->oprs[operand].wrt = NO_SEG;/* still don't care */
- } else if (is_reloc(value)) { /* it's immediate */
+ }
+ else if (is_reloc(value)) /* it's immediate */
+ {
result->oprs[operand].type |= IMMEDIATE;
result->oprs[operand].offset = reloc_value(value);
result->oprs[operand].segment = reloc_seg(value);
result->oprs[operand].wrt = reloc_wrt(value);
if (is_simple(value) && reloc_value(value)==1)
result->oprs[operand].type |= UNITY;
- } else { /* it's a register */
+ }
+ else /* it's a register */
+ {
+ int i;
+
if (value->type>=EXPR_SIMPLE || value->value!=1) {
error (ERR_NONFATAL, "invalid operand type");
result->opcode = -1;
return result;
}
+
+ /*
+ * check that its only 1 register, not an expression...
+ */
+ for (i = 1; value[i].type; i++)
+ if (value[i].value) {
+ error (ERR_NONFATAL, "invalid operand type");
+ result->opcode = -1;
+ return result;
+ }
+
/* clear overrides, except TO which applies to FPU regs */
+ if (result->oprs[operand].type & ~TO) {
+ /*
+ * we want to produce a warning iff the specified size
+ * is different from the register size
+ */
+ i = result->oprs[operand].type & SIZE_MASK;
+ }
+ else
+ i = 0;
+
result->oprs[operand].type &= TO;
result->oprs[operand].type |= REGISTER;
result->oprs[operand].type |= reg_flags[value->type];
result->oprs[operand].basereg = value->type;
+
+ if (i && (result->oprs[operand].type & SIZE_MASK) != i)
+ error (ERR_WARNING|ERR_PASS1,
+ "register size specification ignored");
}
}
}
return result;
}
-static int is_comma_next (void) {
+static int is_comma_next (void)
+{
char *p;
int i;
struct tokenval tv;
return (i == ',' || i == ';' || !i);
}
-void cleanup_insn (insn *i) {
+void cleanup_insn (insn *i)
+{
extop *e;
while (i->eops) {
#ifndef NASM_PARSER_H
#define NASM_PARSER_H
+void parser_global_info (struct ofmt *output, loc_t *locp);
insn *parse_line (int pass, char *buffer, insn *result,
- efunc error, evalfunc evaluate, evalinfofunc einfo);
+ efunc error, evalfunc evaluate, ldfunc ldef);
void cleanup_insn (insn *instruction);
#endif
* initial version 18/iii/97 by Simon Tatham
*/
+#define br0 '{'
+#define br1 "{"
+#define br2 '}'
+#define br3 "}"
+
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
int plus; /* is the last parameter greedy? */
int nolist; /* is this macro listing-inhibited? */
int in_progress;
- Token **defaults, *dlist;
+ Token *dlist; /* All defaults as one list */
+ Token **defaults; /* Parameter default pointers */
int ndefs; /* number of default parameters */
Line *expansion;
MMacro *next_active;
- Token **params, *iline;
+ Token **params; /* actual parameters */
+ Token *iline; /* invocation line */
int nparam, rotate, *paramlen;
unsigned long unique;
};
* This is the internal form which we break input lines up into.
* Typically stored in linked lists.
*
- * TOK_PS_OTHER is a token type used internally within
- * expand_smacro(), to denote a token which has already been
- * checked for being a potential macro, but may still be a context-
- * local label.
- *
* Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
* necessarily used as-is, but is intended to denote the number of
* the substituted parameter. So in the definition
};
enum {
TOK_WHITESPACE = 1, TOK_COMMENT, TOK_ID, TOK_PREPROC_ID, TOK_STRING,
- TOK_NUMBER, TOK_SMAC_END, TOK_OTHER, TOK_PS_OTHER, TOK_SMAC_PARAM,
+ TOK_NUMBER, TOK_SMAC_END, TOK_OTHER, TOK_SMAC_PARAM,
TOK_INTERNAL_STRING
};
static unsigned long unique; /* unique identifier numbers */
-static char *linesync, *outline;
-
static Line *predef = NULL;
static ListGen *list;
/*
* The number of hash values we use for the macro lookup tables.
+ * FIXME: We should *really* be able to configure this at run time,
+ * or even have the hash table automatically expanding when necessary.
*/
#define NHASH 31
* Forward declarations.
*/
static Token *expand_smacro (Token *tline);
-static void update_fileline (int which);
+static void make_tok_num(Token *tok, long val);
+
+/*
+ * Macros for safe checking of token pointers, avoid *(NULL)
+ */
+#define tok_type_(x,t) ((x) && (x)->type == (t))
+#define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
+#define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
+#define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
/*
* The pre-preprocessing stage... This function translates line
* flags') into NASM preprocessor line number indications (`%line
* lineno file').
*/
-static char *prepreproc(char *line) {
+static char *prepreproc(char *line)
+{
int lineno, fnlen;
char *fname, *oldline;
* invariant under case changes. We implement this by applying a
* perfectly normal hash function to the uppercase of the string.
*/
-static int hash(char *s) {
+static int hash(char *s)
+{
+ unsigned int h = 0;
+ int i = 0;
/*
* Powers of three, mod 31.
*/
1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10,
30, 28, 22, 4, 12, 5, 15, 14, 11, 2, 6, 18, 23, 7, 21
};
- int h = 0;
- int i = 0;
+
while (*s) {
h += multipliers[i] * (unsigned char) (toupper(*s));
/*
* Free a linked list of tokens.
*/
-static void free_tlist (Token *list) {
+static void free_tlist (Token *list)
+{
Token *t;
while (list) {
t = list;
/*
* Free a linked list of lines.
*/
-static void free_llist (Line *list) {
+static void free_llist (Line *list)
+{
Line *l;
while (list) {
l = list;
}
/*
+ * Free an MMacro
+ */
+static void free_mmacro (MMacro *m)
+{
+ nasm_free (m->name);
+ free_tlist (m->dlist);
+ nasm_free (m->defaults);
+ free_llist (m->expansion);
+ nasm_free (m);
+}
+
+/*
* Pop the context stack.
*/
-static void ctx_pop (void) {
+static void ctx_pop (void)
+{
Context *c = cstk;
SMacro *smac, *s;
nasm_free (c);
}
-/*
- * Generate a line synchronisation comment, to ensure the assembler
- * knows which source file the current output has really come from.
- */
-static void line_sync (void) {
- char text[30+FILENAME_MAX];
- sprintf(text, "%%line %d+%d %s",
- (istk->expansion ? istk->lineno - istk->lineinc : istk->lineno),
- (istk->expansion ? 0 : istk->lineinc), istk->fname);
- nasm_free (linesync);
- linesync = nasm_strdup(text);
-}
-
#define BUF_DELTA 512
/*
* Read a line from the top file in istk, handling multiple CR/LFs
* return lines from the standard macro set if this has not already
* been done.
*/
-static char *read_line (void) {
+static char *read_line (void)
+{
char *buffer, *p, *q;
int bufsize;
if (stdmacpos) {
if (*stdmacpos) {
char *ret = nasm_strdup(*stdmacpos++);
- if (!*stdmacpos && any_extrastdmac) {
+ if (!*stdmacpos && any_extrastdmac)
+ {
stdmacpos = extrastdmac;
any_extrastdmac = FALSE;
return ret;
* most convenient way to implement the pre-include and
* pre-define features.
*/
- if (!*stdmacpos) {
+ if (!*stdmacpos)
+ {
Line *pd, *l;
Token *head, **tail, *t, *tt;
}
}
return ret;
- } else {
+ }
+ else {
stdmacpos = NULL;
- line_sync();
- update_fileline(3); /* update __FILE__ and __LINE__ */
}
}
break;
p += strlen(p);
if (p > buffer && p[-1] == '\n') {
- istk->lineno += istk->lineinc;
- update_fileline(1); /* update __LINE__ only */
break;
}
if (p-buffer > bufsize-10) {
+ long offset = p-buffer;
bufsize += BUF_DELTA;
buffer = nasm_realloc(buffer, bufsize);
+ p = buffer+offset; /* prevent stale-pointer problems */
}
}
return NULL;
}
+ src_set_linnum(src_get_linnum() + istk->lineinc);
+
/*
* Play safe: remove CRs as well as LFs, if any of either are
* present at the end of the line.
*/
- while (p > buffer && (p[-1] == '\n' || p[-1] == '\r'))
- *--p = '\0';
+ while (--p >= buffer && (*p == '\n' || *p == '\r'))
+ *p = '\0';
/*
* Handle spurious ^Z, which may be inserted into source files
* don't need to parse the value out of e.g. numeric tokens: we
* simply split one string into many.
*/
-static Token *tokenise (char *line) {
+static Token *tokenise (char *line)
+{
char *p = line;
int type;
Token *list = NULL;
while (*line) {
p = line;
- if (*p == '%' &&
- (p[1] == '{' || p[1] == '!' || (p[1] == '%' && isidchar(p[2])) ||
- p[1] == '$' || p[1] == '+' || p[1] == '-' || isidchar(p[1]))) {
- type = TOK_PREPROC_ID;
+ if (*p == '%' && ( isdigit(p[1]) ||
+ ((p[1] == '-' || p[1] == '+') && isdigit(p[2]))))
+ {
p++;
- if (*p == '{') {
+ do {
+ p++;
+ } while (isdigit(*p));
+ type = TOK_PREPROC_ID;
+ }
+ else if (*p == '%' && p[1] == '{') {
+ p += 2;
+ while (*p && *p != '}') {
+ p[-1] = *p;
p++;
- while (*p && *p != '}') {
- p[-1] = *p;
- p++;
- }
- p[-1] = '\0';
- if (*p) p++;
- } else {
- if (*p == '!' || *p == '%' || *p == '$' ||
- *p == '+' || *p == '-') p++;
- while (*p && isidchar(*p))
- p++;
}
- } else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
+ p[-1] = '\0';
+ if (*p) p++;
+ type = TOK_PREPROC_ID;
+ }
+ else if (*p == '%' && (isidchar(p[1]) ||
+ ((p[1] == '!' || p[1] == '%' || p[1] == '$') &&
+ isidchar(p[2]))))
+ {
+ p++;
+ do {
+ p++;
+ } while (isidchar(*p));
+ type = TOK_PREPROC_ID;
+ }
+ else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
type = TOK_ID;
p++;
while (*p && isidchar(*p))
p++;
- } else if (*p == '\'' || *p == '"') {
+ }
+ else if (*p == '\'' || *p == '"') {
/*
* A string token.
*/
while (*p && *p != c)
p++;
if (*p) p++;
- } else if (isnumstart(*p)) {
+ }
+ else if (isnumstart(*p)) {
/*
* A number token.
*/
p++;
while (*p && isnumchar(*p))
p++;
- } else if (isspace(*p)) {
+ }
+ else if (isspace(*p)) {
type = TOK_WHITESPACE;
p++;
while (*p && isspace(*p))
type = TOK_COMMENT;
while (*p) p++;
}
- } else if (*p == ';') {
+ }
+ else if (*p == ';') {
type = TOK_COMMENT;
while (*p) p++;
- } else {
+ }
+ else {
/*
* Anything else is an operator of some kind. We check
* for all the double-character operators (>>, <<, //,
(p[0] == '&' && p[1] == '&') ||
(p[0] == '|' && p[1] == '|') ||
(p[0] == '^' && p[1] == '^'))
+ {
p++;
+ }
p++;
}
if (type != TOK_COMMENT) {
/*
* Convert a line of tokens back into text.
*/
-static char *detoken (Token *tlist) {
+char *detoken (Token *tlist)
+{
Token *t;
int len;
char *line, *p;
* the first token in the line to be passed in as its private_data
* field.
*/
-static int ppscan(void *private_data, struct tokenval *tokval) {
+static int ppscan(void *private_data, struct tokenval *tokval)
+{
Token **tlineptr = private_data;
Token *tline;
return tokval->t_type = TOKEN_NUM;
}
+ if (tline->type == TOK_STRING) {
+ int rn_warn;
+ char q, *r;
+ int l;
+
+ r = tline->text;
+ q = *r++;
+ l = strlen(r);
+
+ if (l == 0 || r[l-1] != q)
+ return tokval->t_type = TOKEN_ERRNUM;
+ tokval->t_integer = readstrnum(r, l-1, &rn_warn);
+ if (rn_warn)
+ error(ERR_WARNING|ERR_PASS1,
+ "character constant too long");
+ tokval->t_charptr = NULL;
+ return tokval->t_type = TOKEN_NUM;
+ }
+
if (tline->type == TOK_OTHER) {
if (!strcmp(tline->text, "<<")) return tokval->t_type = TOKEN_SHL;
if (!strcmp(tline->text, ">>")) return tokval->t_type = TOKEN_SHR;
* context stack isn't deep enough for the supplied number of $
* signs.
*/
-static Context *get_ctx (char *name) {
+static Context *get_ctx (char *name)
+{
Context *ctx;
int i;
if (!cstk) {
- error (ERR_NONFATAL|ERR_OFFBY1, "`%s': context stack is empty", name);
+ error (ERR_NONFATAL, "`%s': context stack is empty", name);
return NULL;
}
i++;
ctx = ctx->next;
if (!ctx) {
- error (ERR_NONFATAL|ERR_OFFBY1, "`%s': context stack is only"
+ error (ERR_NONFATAL, "`%s': context stack is only"
" %d level%s deep", name, i-1, (i==2 ? "" : "s"));
return NULL;
}
* simple wrapper which calls either strcmp or nasm_stricmp
* depending on the value of the `casesense' parameter.
*/
-static int mstrcmp(char *p, char *q, int casesense) {
+static int mstrcmp(char *p, char *q, int casesense)
+{
return casesense ? strcmp(p,q) : nasm_stricmp(p,q);
}
* the include path one by one until it finds the file or reaches
* the end of the path.
*/
-static FILE *inc_fopen(char *file) {
+static FILE *inc_fopen(char *file)
+{
FILE *fp;
char *prefix = "", *combine;
IncPath *ip = ipath;
- int len = strlen(file);
- do {
- combine = nasm_malloc(strlen(prefix)+len+1);
- strcpy(combine, prefix);
- strcat(combine, file);
+ while (1) {
+ combine = nasm_strcat(prefix,file);
fp = fopen(combine, "r");
nasm_free (combine);
if (fp)
return fp;
- prefix = ip ? ip->path : NULL;
- if (ip)
- ip = ip->next;
- } while (prefix);
+ if (!ip)
+ break;
+ prefix = ip->path;
+ ip = ip->next;
+ }
- error (ERR_FATAL|ERR_OFFBY1,
+ error (ERR_FATAL,
"unable to open include file `%s'", file);
return NULL; /* never reached - placate compilers */
}
* Note that this is also called with nparam zero to resolve
* `ifdef'.
*/
-static int smacro_defined (char *name, int nparam, SMacro **defn) {
+static int smacro_defined (char *name, int nparam, SMacro **defn, int nocase)
+{
SMacro *m;
Context *ctx;
char *p;
}
while (m) {
- if (!mstrcmp(m->name, p, m->casesense) &&
+ if (!mstrcmp(m->name, p, m->casesense & nocase) &&
(nparam == 0 || m->nparam == 0 || nparam == m->nparam)) {
if (defn) {
if (nparam == m->nparam)
}
/*
- * Update the __FILE__ and __LINE__ macros. Specifically, update
- * __FILE__ if bit 1 of our argument is set, and update __LINE__ if
- * bit 0 is set.
- *
- * If the macros don't exist, a `%clear' must have happened, in
- * which case we should exit quite happily and carry on going. It's
- * not an error condition.
- */
-static void update_fileline(int which) {
- SMacro *sm;
- char num[20];
-
- if ((which & 3) && smacro_defined ("__FILE__", 0, &sm) && sm) {
- free_tlist(sm->expansion);
- sm->expansion = nasm_malloc(sizeof(Token));
- sm->expansion->next = NULL;
- sm->expansion->mac = NULL;
- sm->expansion->type = TOK_STRING;
- sm->expansion->text = nasm_malloc(3+strlen(istk->fname));
- /* FIXME: throw an error if both sorts of quote are present */
- /* Better still, invent a way for us to cope with that case */
- sprintf(sm->expansion->text, "\"%s\"", istk->fname);
- }
-
- if ((which & 1) && smacro_defined ("__LINE__", 0, &sm) && sm) {
- free_tlist(sm->expansion);
- sm->expansion = nasm_malloc(sizeof(Token));
- sm->expansion->next = NULL;
- sm->expansion->mac = NULL;
- sm->expansion->type = TOK_NUMBER;
- sprintf(num, "%d", istk->lineno - istk->lineinc);
- sm->expansion->text = nasm_strdup(num);
- }
-}
-
-/*
* Count and mark off the parameters in a multi-line macro call.
* This is called both from within the multi-line macro expansion
* code, and also to mark off the default parameters when provided
* in a %macro definition line.
*/
-static void count_mmac_params (Token *t, int *nparam, Token ***params) {
+static void count_mmac_params (Token *t, int *nparam, Token ***params)
+{
int paramsize, brace;
*nparam = paramsize = 0;
paramsize += PARAM_DELTA;
*params = nasm_realloc(*params, sizeof(**params) * paramsize);
}
- if (t && t->type == TOK_WHITESPACE)
- t = t->next;
+ skip_white_(t);
brace = FALSE;
- if (t && t->type == TOK_OTHER && !strcmp(t->text, "{"))
+ if (tok_is_(t, "{"))
brace = TRUE;
(*params)[(*nparam)++] = t;
- while (t && (t->type != TOK_OTHER ||
- strcmp(t->text, brace ? "}" : ",")))
+ while (tok_isnt_(t, brace ? "}" : ","))
t = t->next;
if (t) { /* got a comma/brace */
t = t->next;
* Now we've found the closing brace, look further
* for the comma.
*/
- if (t && t->type == TOK_WHITESPACE)
- t = t->next;
- if (t && (t->type != TOK_OTHER || strcmp(t->text, ","))) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ skip_white_(t);
+ if (tok_isnt_(t, ",")) {
+ error (ERR_NONFATAL,
"braces do not enclose all of macro parameter");
- while (t && (t->type != TOK_OTHER ||
- strcmp(t->text, ",")))
+ while (tok_isnt_(t, ","))
t = t->next;
}
if (t)
t = t->next; /* eat the comma */
}
}
- else /* got EOL */
- break;
}
}
*
* We must free the tline we get passed.
*/
-static int if_condition (Token *tline, int i) {
- int j, casesense;
- Token *t, *tt, **tptr, *origline;
+static int if_condition (Token *tline, int i)
+{
+ int j, casesense;
+ Token * t, * tt, ** tptr, * origline;
struct tokenval tokval;
- expr *evalresult;
+ expr * evalresult;
origline = tline;
case PP_IFNCTX: case PP_ELIFNCTX:
j = FALSE; /* have we matched yet? */
if (!cstk)
- error(ERR_FATAL|ERR_OFFBY1,
+ error(ERR_FATAL,
"`%s': context stack is empty", directives[i]);
else while (tline) {
- if (tline->type == TOK_WHITESPACE)
- tline = tline->next;
+ skip_white_(tline);
if (!tline || tline->type != TOK_ID) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"`%s' expects context identifiers", directives[i]);
free_tlist (origline);
return -1;
case PP_IFNDEF: case PP_ELIFNDEF:
j = FALSE; /* have we matched yet? */
while (tline) {
- if (tline->type == TOK_WHITESPACE)
- tline = tline->next;
+ skip_white_(tline);
if (!tline || (tline->type != TOK_ID &&
(tline->type != TOK_PREPROC_ID ||
tline->text[1] != '$'))) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"`%%if%sdef' expects macro identifiers",
(i==PP_ELIFNDEF ? "n" : ""));
free_tlist (origline);
return -1;
}
- if (smacro_defined(tline->text, 0, NULL))
+ if (smacro_defined(tline->text, 0, NULL, 1))
j = TRUE;
tline = tline->next;
}
case PP_IFIDNI: case PP_ELIFIDNI: case PP_IFNIDNI: case PP_ELIFNIDNI:
tline = expand_smacro(tline);
t = tt = tline;
- while (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
+ while (tok_isnt_(tt, ","))
tt = tt->next;
if (!tt) {
error(ERR_NONFATAL, "`%s' expects two comma-separated arguments");
}
if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
j = FALSE; /* trailing gunk on one end or other */
- if (i == PP_IFNIDN || i == PP_ELIFNIDN)
+ if (i == PP_IFNIDN || i == PP_ELIFNIDN ||
+ i == PP_IFNIDNI || i == PP_ELIFNIDNI)
j = !j;
free_tlist (tline);
return j;
case PP_IFSTR: case PP_ELIFSTR: case PP_IFNSTR: case PP_ELIFNSTR:
tline = expand_smacro(tline);
t = tline;
- while (t && t->type == TOK_WHITESPACE)
+ while (tok_type_(t, TOK_WHITESPACE))
t = t->next;
j = FALSE; /* placate optimiser */
- switch (i) {
+ if (t) switch (i) {
case PP_IFID: case PP_ELIFID: case PP_IFNID: case PP_ELIFNID:
j = (t->type == TOK_ID);
break;
if (!evalresult)
return -1;
if (tokval.t_type)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult)) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"non-constant value given to `%s'", directives[i]);
return -1;
}
return reloc_value(evalresult) != 0;
default:
- error(ERR_FATAL|ERR_OFFBY1,
+ error(ERR_FATAL,
"preprocessor directive `%s' not yet implemented",
directives[i]);
free_tlist (origline);
* Return values go like this:
*
* bit 0 is set if a directive was found (so the line gets freed)
- * bit 1 is set if a blank line should be emitted
- * bit 2 is set if a re-sync line number comment should be emitted
- *
- * (bits 1 and 2 are mutually exclusive in that the rest of the
- * preprocessor doesn't guarantee to be able to handle the case in
- * which both are set)
*/
-static int do_directive (Token *tline) {
+static int do_directive (Token *tline)
+{
int i, j, k, m, nparam, nolist;
char *p, *mname;
Include *inc;
origline = tline;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_PREPROC_ID ||
+ skip_white_(tline);
+ if (!tok_type_(tline, TOK_PREPROC_ID) ||
(tline->text[1]=='%' || tline->text[1]=='$' || tline->text[1]=='!'))
return 0;
i != PP_IFNUM && i != PP_ELIFNUM &&
i != PP_IFSTR && i != PP_ELIFSTR &&
i != PP_ELSE && i != PP_ENDIF)
+ {
return 0;
+ }
/*
* If we're defining a macro or reading a %rep block, we should
* ignore all directives except for %macro/%imacro (which
* generate an error), %endm/%endmacro, and (only if we're in a
- * %rep block) %endrep.
+ * %rep block) %endrep. If we're in a %rep block, another %rep
+ * causes an error, so should be let through.
*/
if (defining && i != PP_MACRO && i != PP_IMACRO &&
i != PP_ENDMACRO && i != PP_ENDM &&
- (defining->name || i != PP_ENDREP))
+ (defining->name || (i != PP_ENDREP && i != PP_REP)))
+ {
return 0;
+ }
if (j != -2) {
- error(ERR_NONFATAL|ERR_OFFBY1, "unknown preprocessor directive `%s'",
+ error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
tline->text);
return 0; /* didn't get it */
}
case PP_CLEAR:
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%clear' ignored");
for (j=0; j<NHASH; j++) {
while (mmacros[j]) {
MMacro *m = mmacros[j];
- mmacros[j] = mmacros[j]->next;
- nasm_free (m->name);
- free_tlist (m->dlist);
- free_llist (m->expansion);
- nasm_free (m);
+ mmacros[j] = m->next;
+ free_mmacro(m);
}
while (smacros[j]) {
SMacro *s = smacros[j];
case PP_INCLUDE:
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
+ skip_white_(tline);
if (!tline || (tline->type != TOK_STRING &&
- tline->type != TOK_INTERNAL_STRING)) {
- error(ERR_NONFATAL|ERR_OFFBY1, "`%%include' expects a file name");
+ tline->type != TOK_INTERNAL_STRING))
+ {
+ error(ERR_NONFATAL, "`%%include' expects a file name");
free_tlist (origline);
return 3; /* but we did _something_ */
}
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%include' ignored");
if (tline->type != TOK_INTERNAL_STRING) {
p = tline->text+1; /* point past the quote to the name */
inc->next = istk;
inc->conds = NULL;
inc->fp = inc_fopen(p);
- inc->fname = nasm_strdup(p);
- inc->lineno = inc->lineinc = 1;
+ inc->fname = src_set_fname(nasm_strdup(p));
+ inc->lineno = src_set_linnum(0);
+ inc->lineinc = 1;
inc->expansion = NULL;
inc->mstk = NULL;
istk = inc;
list->uplevel (LIST_INCLUDE);
- update_fileline(3); /* update __FILE__ and __LINE__ */
free_tlist (origline);
return 5;
case PP_PUSH:
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_ID) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ skip_white_(tline);
+ if (!tok_type_(tline, TOK_ID)) {
+ error(ERR_NONFATAL,
"`%%push' expects a context identifier");
free_tlist (origline);
return 3; /* but we did _something_ */
}
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%push' ignored");
ctx = nasm_malloc(sizeof(Context));
ctx->next = cstk;
case PP_REPL:
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_ID) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ skip_white_(tline);
+ if (!tok_type_(tline, TOK_ID)) {
+ error(ERR_NONFATAL,
"`%%repl' expects a context identifier");
free_tlist (origline);
return 3; /* but we did _something_ */
}
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%repl' ignored");
if (!cstk)
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"`%%repl': context stack is empty");
else {
nasm_free (cstk->name);
case PP_POP:
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%pop' ignored");
if (!cstk)
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"`%%pop': context stack is already empty");
else
ctx_pop();
break;
case PP_ERROR:
+ tline->next = expand_smacro (tline->next);
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_STRING) {
- error(ERR_NONFATAL|ERR_OFFBY1,
- "`%%error' expects an error string");
- free_tlist (origline);
- return 3; /* but we did _something_ */
+ skip_white_(tline);
+ if (tok_type_(tline, TOK_STRING)) {
+ p = tline->text+1; /* point past the quote to the name */
+ p[strlen(p)-1] = '\0'; /* remove the trailing quote */
+ error(ERR_NONFATAL, "user error: %s", p);
+ } else {
+ p = detoken(tline);
+ error(ERR_WARNING, "user error: %s", p);
+ nasm_free(p);
}
- if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
- "trailing garbage after `%%error' ignored");
- p = tline->text+1; /* point past the quote to the name */
- p[strlen(p)-1] = '\0'; /* remove the trailing quote */
- error(ERR_NONFATAL|ERR_OFFBY1, "user error: %s", p);
free_tlist (origline);
break;
tline->next = NULL; /* it got freed */
free_tlist (origline);
if (j < 0)
- return 3;
+ /*
+ * Bogus expression in %if, but we should pretend
+ * it was OK anyway, so that we don't get an error
+ * cascade on the subsequent %else / %endif.
+ */
+ j = COND_NEVER;
else
j = j ? COND_IF_TRUE : COND_IF_FALSE;
}
case PP_ELIFNUM:
case PP_ELIFSTR:
if (!istk->conds)
- error(ERR_FATAL|ERR_OFFBY1, "`%s': no matching `%%if'",
+ error(ERR_FATAL, "`%s': no matching `%%if'",
directives[i]);
if (emitting(istk->conds->state) || istk->conds->state == COND_NEVER)
istk->conds->state = COND_NEVER;
tline->next = NULL; /* it got freed */
free_tlist (origline);
if (j < 0)
- return 3;
+ /*
+ * The expression was bogus, but let's make
+ * %endif not complain about missing %if
+ */
+ j = COND_NEVER;
else
istk->conds->state = j ? COND_IF_TRUE : COND_IF_FALSE;
}
case PP_ELSE:
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%else' ignored");
if (!istk->conds)
- error(ERR_FATAL|ERR_OFFBY1,
+ error(ERR_FATAL,
"`%%else': no matching `%%if'");
if (emitting(istk->conds->state) || istk->conds->state == COND_NEVER)
istk->conds->state = COND_ELSE_FALSE;
case PP_ENDIF:
if (tline->next)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after `%%endif' ignored");
if (!istk->conds)
- error(ERR_FATAL|ERR_OFFBY1,
+ error(ERR_FATAL,
"`%%endif': no matching `%%if'");
cond = istk->conds;
istk->conds = cond->next;
case PP_MACRO:
case PP_IMACRO:
if (defining)
- error (ERR_FATAL|ERR_OFFBY1,
+ error (ERR_FATAL,
"`%%%smacro': already defining a macro",
(i == PP_IMACRO ? "i" : ""));
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_ID) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ skip_white_(tline);
+ if (!tok_type_(tline, TOK_ID)) {
+ error (ERR_NONFATAL,
"`%%%smacro' expects a macro name",
(i == PP_IMACRO ? "i" : ""));
return 3;
defining->nolist = FALSE;
defining->in_progress = FALSE;
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_NUMBER) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ skip_white_(tline);
+ if (!tok_type_(tline, TOK_NUMBER)) {
+ error (ERR_NONFATAL,
"`%%%smacro' expects a parameter count",
(i == PP_IMACRO ? "i" : ""));
defining->nparam_min = defining->nparam_max = 0;
defining->nparam_min = defining->nparam_max =
readnum(tline->text, &j);
if (j)
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"unable to parse parameter count `%s'", tline->text);
}
- if (tline && tline->next && tline->next->type == TOK_OTHER &&
- !strcmp(tline->next->text, "-")) {
+ if (tline && tok_is_(tline->next, "-")) {
tline = tline->next->next;
- if (tline && tline->type == TOK_OTHER &&
- !strcmp(tline->text, "*"))
+ if (tok_is_(tline, "*"))
defining->nparam_max = INT_MAX;
- else if (!tline || tline->type != TOK_NUMBER)
- error (ERR_NONFATAL|ERR_OFFBY1,
+ else if (!tok_type_(tline, TOK_NUMBER))
+ error (ERR_NONFATAL,
"`%%%smacro' expects a parameter count after `-'",
(i == PP_IMACRO ? "i" : ""));
else {
defining->nparam_max = readnum(tline->text, &j);
if (j)
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"unable to parse parameter count `%s'",
tline->text);
if (defining->nparam_min > defining->nparam_max)
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"minimum parameter count exceeds maximum");
}
}
- if (tline && tline->next && tline->next->type == TOK_OTHER &&
- !strcmp(tline->next->text, "+")) {
+ if (tline && tok_is_(tline->next, "+")) {
tline = tline->next;
defining->plus = TRUE;
}
- if (tline && tline->next && tline->next->type == TOK_ID &&
- !nasm_stricmp(tline->next->text, ".nolist")) {
+ if (tline && tok_type_(tline->next, TOK_ID) &&
+ !nasm_stricmp(tline->next->text, ".nolist"))
+ {
tline = tline->next;
defining->nolist = TRUE;
}
while (mmac) {
if (!strcmp(mmac->name, defining->name) &&
(mmac->nparam_min<=defining->nparam_max || defining->plus) &&
- (defining->nparam_min<=mmac->nparam_max || mmac->plus)) {
- error (ERR_WARNING|ERR_OFFBY1,
+ (defining->nparam_min<=mmac->nparam_max || mmac->plus))
+ {
+ error (ERR_WARNING,
"redefining multi-line macro `%s'", defining->name);
break;
}
case PP_ENDM:
case PP_ENDMACRO:
if (!defining) {
- error (ERR_NONFATAL|ERR_OFFBY1, "`%s': not defining a macro",
+ error (ERR_NONFATAL, "`%s': not defining a macro",
tline->text);
return 3;
}
if (!evalresult)
return 3;
if (tokval.t_type)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult)) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"non-constant value given to `%%rotate'");
return 3;
}
while (mmac && !mmac->name) /* avoid mistaking %reps for macros */
mmac = mmac->next_active;
if (!mmac)
- error(ERR_NONFATAL, "`%rotate' invoked outside a macro call");
+ error(ERR_NONFATAL, "`%%rotate' invoked outside a macro call");
mmac->rotate = mmac->rotate + reloc_value(evalresult);
if (mmac->rotate < 0)
mmac->rotate = mmac->nparam - (-mmac->rotate) % mmac->nparam;
return 1;
case PP_REP:
+ if (defining) {
+ /*
+ * We don't allow nested %reps, because of a strange bug
+ * that was causing a panic. The cause of the bug appears to be
+ * that the nested %rep isn't taken into account when matching
+ * against the %endreps, so some mechanism to count the
+ * %reps in and the %endreps out may well work here.
+ *
+ * That's for experimentation with later, though.
+ * For informations sake, the panic produced by
+ * nesting %reps was:
+ *
+ * istk->mstk has no name but defining is set at end
+ * of expansion
+ */
+ error(ERR_NONFATAL, "nested `%%rep' invocation not allowed");
+ break;
+ }
nolist = FALSE;
tline = tline->next;
if (tline->next && tline->next->type == TOK_WHITESPACE)
if (!evalresult)
return 3;
if (tokval.t_type)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult)) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"non-constant value given to `%%rep'");
return 3;
}
defining->nolist = nolist;
defining->in_progress = reloc_value(evalresult) + 1;
defining->nparam_min = defining->nparam_max = 0;
+ defining->defaults = NULL;
+ defining->dlist = NULL;
defining->expansion = NULL;
defining->next_active = istk->mstk;
return 1;
case PP_ENDREP:
- if (!defining) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ if (!defining || defining->name) {
+ error (ERR_NONFATAL,
"`%%endrep': no matching `%%rep'");
return 3;
}
list->uplevel (defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
defining = NULL;
free_tlist (origline);
- return 1; /* the expansion will line-sync */
+ return 1;
case PP_EXITREP:
/*
if (l->finishes && !l->finishes->name)
break;
- if (l->finishes && !l->finishes->name)
+ if (l)
l->finishes->in_progress = 0;
else
error (ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
free_tlist (origline);
- return 1; /* the end marker will line-sync */
+ return 1;
case PP_DEFINE:
case PP_IDEFINE:
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
+ skip_white_(tline);
if (!tline || (tline->type != TOK_ID &&
(tline->type != TOK_PREPROC_ID ||
tline->text[1] != '$'))) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"`%%%sdefine' expects a macro identifier",
(i == PP_IDEFINE ? "i" : ""));
free_tlist (origline);
last = tline;
param_start = tline = tline->next;
nparam = 0;
- if (tline && tline->type == TOK_OTHER && !strcmp(tline->text, "(")) {
+ if (tok_is_(tline, "(")) {
/*
* This macro has parameters.
*/
tline = tline->next;
while (1) {
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
+ skip_white_(tline);
if (!tline) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"parameter identifier expected");
free_tlist (origline);
return 3;
}
if (tline->type != TOK_ID) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"`%s': parameter identifier expected",
tline->text);
free_tlist (origline);
}
tline->type = TOK_SMAC_PARAM + nparam++;
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (tline && tline->type == TOK_OTHER &&
- !strcmp(tline->text, ",")) {
+ skip_white_(tline);
+ if (tok_is_(tline, ",")) {
tline = tline->next;
continue;
}
- if (!tline || tline->type != TOK_OTHER ||
- strcmp(tline->text, ")")) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ if (!tok_is_(tline, ")")) {
+ error (ERR_NONFATAL,
"`)' expected to terminate macro template");
free_tlist (origline);
return 3;
last = tline;
tline = tline->next;
}
- if (tline && tline->type == TOK_WHITESPACE)
+ if (tok_type_(tline, TOK_WHITESPACE))
last = tline, tline = tline->next;
macro_start = NULL;
last->next = NULL;
* carefully re-terminated after chopping off the expansion
* from the end).
*/
- if (smacro_defined (mname, nparam, &smac)) {
- if (!smac)
- error (ERR_WARNING|ERR_OFFBY1,
+ if (smacro_defined (mname, nparam, &smac, i==PP_DEFINE)) {
+ if (!smac) {
+ error (ERR_WARNING,
"single-line macro `%s' defined both with and"
" without parameters", mname);
- else {
+ free_tlist (origline);
+ free_tlist (macro_start);
+ return 3;
+ } else {
/*
* We're redefining, so we have to take over an
* existing SMacro structure. This means freeing
case PP_ASSIGN:
case PP_IASSIGN:
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
+ skip_white_(tline);
if (!tline || (tline->type != TOK_ID &&
(tline->type != TOK_PREPROC_ID ||
tline->text[1] != '$'))) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"`%%%sassign' expects a macro identifier",
(i == PP_IASSIGN ? "i" : ""));
free_tlist (origline);
}
if (tokval.t_type)
- error(ERR_WARNING|ERR_OFFBY1,
+ error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult)) {
- error(ERR_NONFATAL|ERR_OFFBY1,
+ error(ERR_NONFATAL,
"non-constant value given to `%%%sassign'",
(i == PP_IASSIGN ? "i" : ""));
free_tlist (origline);
macro_start = nasm_malloc(sizeof(*macro_start));
macro_start->next = NULL;
- {
- char numbuf[20];
- sprintf(numbuf, "%ld", reloc_value(evalresult));
- macro_start->text = nasm_strdup(numbuf);
- }
+ make_tok_num(macro_start, reloc_value(evalresult));
macro_start->mac = NULL;
- macro_start->type = TOK_NUMBER;
/*
* We now have a macro name, an implicit parameter count of
* zero, and a numeric token to use as an expansion. Create
* and store an SMacro.
*/
- if (smacro_defined (mname, 0, &smac)) {
+ if (smacro_defined (mname, 0, &smac, i==PP_ASSIGN)) {
if (!smac)
- error (ERR_WARNING|ERR_OFFBY1,
+ error (ERR_WARNING,
"single-line macro `%s' defined both with and"
" without parameters", mname);
else {
nasm_free (smac->name);
free_tlist (smac->expansion);
}
- } else {
+ }
+ else {
smac = nasm_malloc(sizeof(SMacro));
smac->next = *smhead;
*smhead = smac;
* Syntax is `%line nnn[+mmm] [filename]'
*/
tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_NUMBER) {
- error (ERR_NONFATAL|ERR_OFFBY1, "`%%line' expects line number");
+ skip_white_(tline);
+ if (!tok_type_(tline, TOK_NUMBER)) {
+ error (ERR_NONFATAL, "`%%line' expects line number");
free_tlist (origline);
return 3;
}
k = readnum(tline->text, &j);
m = 1;
tline = tline->next;
- if (tline && tline->type == TOK_OTHER && !strcmp(tline->text, "+")) {
+ if (tok_is_(tline, "+")) {
tline = tline->next;
- if (!tline || tline->type != TOK_NUMBER) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ if (!tok_type_(tline, TOK_NUMBER)) {
+ error (ERR_NONFATAL,
"`%%line' expects line increment");
free_tlist (origline);
return 3;
m = readnum(tline->text, &j);
tline = tline->next;
}
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- istk->lineno = k;
+ skip_white_(tline);
+ src_set_linnum(k);
istk->lineinc = m;
- update_fileline(3); /* update __FILE__ and __LINE__ */
if (tline) {
- char *s = detoken(tline);
- nasm_free (istk->fname);
- istk->fname = s;
+ nasm_free ( src_set_fname ( detoken(tline) ) );
}
free_tlist (origline);
return 5;
default:
- error(ERR_FATAL|ERR_OFFBY1,
+ error(ERR_FATAL,
"preprocessor directive `%s' not yet implemented",
directives[i]);
break;
* nothing else. Return the condition code index if so, or -1
* otherwise.
*/
-static int find_cc (Token *t) {
+static int find_cc (Token *t)
+{
Token *tt;
int i, j, k, m;
- if (t && t->type == TOK_WHITESPACE)
- t = t->next;
+ skip_white_(t);
if (t->type != TOK_ID)
return -1;
tt = t->next;
- if (tt && tt->type == TOK_WHITESPACE)
- tt = tt->next;
+ skip_white_(tt);
if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
return -1;
* Expand MMacro-local things: parameter references (%0, %n, %+n,
* %-n) and MMacro-local identifiers (%%foo).
*/
-static Token *expand_mmac_params (Token *tline) {
+static Token *expand_mmac_params (Token *tline)
+{
Token *t, *tt, *ttt, **tail, *thead;
tail = &thead;
case '%':
type = TOK_ID;
sprintf(tmpbuf, "..@%lu.", mac->unique);
- text = nasm_malloc(strlen(tmpbuf)+strlen(t->text+2)+1);
- strcpy(text, tmpbuf);
- strcat(text, t->text+2);
+ text = nasm_strcat(tmpbuf, t->text+2);
break;
case '-':
n = atoi(t->text+2)-1;
}
cc = find_cc (tt);
if (cc == -1) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"macro parameter %d is not a condition code",
n+1);
text = NULL;
} else {
type = TOK_ID;
if (inverse_ccs[cc] == -1) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"condition code `%s' is not invertible",
conditions[cc]);
text = NULL;
}
cc = find_cc (tt);
if (cc == -1) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+ error (ERR_NONFATAL,
"macro parameter %d is not a condition code",
n+1);
text = NULL;
if (tt) {
for (i=0; i<mac->paramlen[n]; i++) {
ttt = *tail = nasm_malloc(sizeof(Token));
- ttt->next = NULL;
tail = &ttt->next;
ttt->type = tt->type;
ttt->text = nasm_strdup(tt->text);
break;
}
nasm_free (t->text);
- nasm_free (t);
- if (text) {
- t = *tail = nasm_malloc(sizeof(Token));
- t->next = NULL;
+ if (!text) {
+ nasm_free (t);
+ } else {
+ *tail = t;
tail = &t->next;
t->type = type;
t->text = text;
t = *tail = tline;
tline = tline->next;
t->mac = NULL;
- t->next = NULL;
tail = &t->next;
}
}
+ *tail = NULL;
+ t = thead;
+ for (; t && (tt=t->next)!=NULL ; t = t->next)
+ switch (t->type) {
+ case TOK_WHITESPACE:
+ if (tt->type == TOK_WHITESPACE) {
+ t->next = tt->next;
+ nasm_free(tt->text);
+ nasm_free(tt);
+ }
+ break;
+ case TOK_ID:
+ if (tt->type == TOK_ID || tt->type == TOK_NUMBER) {
+ char *tmp = nasm_strcat(t->text, tt->text);
+ nasm_free(t->text);
+ t->text = tmp;
+ t->next = tt->next;
+ nasm_free(tt->text);
+ nasm_free(tt);
+ }
+ break;
+ case TOK_NUMBER:
+ if (tt->type == TOK_NUMBER) {
+ char *tmp = nasm_strcat(t->text, tt->text);
+ nasm_free(t->text);
+ t->text = tmp;
+ t->next = tt->next;
+ nasm_free(tt->text);
+ nasm_free(tt);
+ }
+ break;
+ }
+
return thead;
}
* Tokens from input to output a lot of the time, rather than
* actually bothering to destroy and replicate.)
*/
-static Token *expand_smacro (Token *tline) {
+static Token *expand_smacro (Token *tline)
+{
Token *t, *tt, *mstart, **tail, *thead;
- SMacro *head, *m;
+ SMacro *head = NULL, *m;
Token **params;
int *paramsize;
int nparam, sparam, brackets;
tail = &thead;
thead = NULL;
- while (tline) {
- while (tline && tline->type != TOK_ID &&
- (tline->type != TOK_PREPROC_ID || tline->text[1] != '$')) {
- if (tline->type == TOK_SMAC_END) {
- tline->mac->in_progress = FALSE;
- t = tline;
- tline = tline->next;
- nasm_free (t);
- } else {
- t = *tail = tline;
- tline = tline->next;
- t->mac = NULL;
- t->next = NULL;
- tail = &t->next;
- if (t->type == TOK_PS_OTHER) {
- /*
- * If we see a PS_OTHER, we must at the very
- * least restore its correct token type. We
- * should also check for a %$ token, since this
- * is the point at which we expand context-
- * local labels.
- */
- t->type = TOK_ID;
- if (t->text[0] == '%' && t->text[1] == '$') {
- Context *c = get_ctx (t->text);
- char *p, *q, buffer[40];
-
- if (c) {
- q = t->text+1;
- q += strspn(q, "$");
- sprintf(buffer, "..@%lu.", c->number);
- p = nasm_malloc (strlen(buffer)+strlen(q)+1);
- strcpy (p, buffer);
- strcat (p, q);
- nasm_free (t->text);
- t->text = p;
- }
- }
- }
- }
- }
-
- if (!tline)
- break;
- /*
- * We've hit an identifier. As in is_mmacro below, we first
- * check whether the identifier is a single-line macro at
- * all, then think about checking for parameters if
- * necessary.
- */
+ while (tline) { /* main token loop */
+ p = NULL;
if (tline->type == TOK_ID) {
head = smacros[hash(tline->text)];
p = tline->text;
- } else {
+ } else if (tline->type == TOK_PREPROC_ID && tline->text[1] == '$') {
Context *ctx = get_ctx (tline->text);
if (ctx) {
- p = tline->text+1;
- p += strspn(p, "$");
head = ctx->localmac;
- } else {
- tline->type = TOK_OTHER; /* so it will get copied above */
- continue;
+ p = tline->text+2;
+ p += strspn(p, "$");
}
}
- for (m = head; m; m = m->next)
- if (!mstrcmp(m->name, p, m->casesense))
- break;
- if (!m || m->in_progress) {
- /*
- * Either we didn't find a macro, so this can't be a
- * macro call, or we found a macro which was already in
- * progress, in which case we don't _treat_ this as a
- * macro call. Copy it through and ignore it.
- */
- tline->type = TOK_PS_OTHER; /* so it will get copied above */
- continue;
- }
- mstart = tline;
- if (m->nparam == 0) {
- /*
- * Simple case: the macro is parameterless. Discard the
- * one token that the macro call took, and push the
- * expansion back on the to-do stack.
- */
- params = NULL;
- paramsize = NULL;
- } else {
- /*
- * Complicated case: at least one macro with this name
- * exists and takes parameters. We must find the
- * parameters in the call, count them, find the SMacro
- * that corresponds to that form of the macro call, and
- * substitute for the parameters when we expand. What a
- * pain.
- */
- nparam = sparam = 0;
- params = NULL;
- paramsize = NULL;
- tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (!tline || tline->type != TOK_OTHER ||
- strcmp(tline->text, "(")) {
+ if (p) {
+ /*
+ * We've hit an identifier. As in is_mmacro below, we first
+ * check whether the identifier is a single-line macro at
+ * all, then think about checking for parameters if
+ * necessary.
+ */
+ for (m = head; m; m = m->next)
+ if (!mstrcmp(m->name, p, m->casesense))
+ break;
+ if (m) {
+ mstart = tline;
+ params = NULL;
+ paramsize = NULL;
+ if (m->nparam == 0) {
/*
- * This macro wasn't called with parameters: ignore
- * the call. (Behaviour borrowed from gnu cpp.)
+ * Simple case: the macro is parameterless. Discard the
+ * one token that the macro call took, and push the
+ * expansion back on the to-do stack.
*/
- tline = mstart;
- tline->type = TOK_PS_OTHER;
- continue;
- }
- tline = tline->next;
- while (1) {
- if (tline && tline->type == TOK_WHITESPACE)
+ if (!m->expansion)
+ {
+ if (!strcmp("__FILE__", m->name)) {
+ long num=0;
+ src_get(&num, &(tline->text));
+ nasm_quote(&(tline->text));
+ tline->type = TOK_STRING;
+ continue;
+ }
+ if (!strcmp("__LINE__", m->name)) {
+ nasm_free(tline->text);
+ make_tok_num(tline, src_get_linnum());
+ continue;
+ }
+ t = tline;
tline = tline->next;
- if (!tline) {
- error(ERR_NONFATAL|ERR_OFFBY1,
- "macro call expects terminating `)'");
- break;
+ nasm_free (t->text);
+ nasm_free (t);
+ continue;
}
- if (nparam >= sparam) {
- sparam += PARAM_DELTA;
- params = nasm_realloc (params, sparam*sizeof(Token *));
- paramsize = nasm_realloc (paramsize, sparam*sizeof(int));
+ }
+ else {
+ /*
+ * Complicated case: at least one macro with this name
+ * exists and takes parameters. We must find the
+ * parameters in the call, count them, find the SMacro
+ * that corresponds to that form of the macro call, and
+ * substitute for the parameters when we expand. What a
+ * pain.
+ */
+ tline = tline->next;
+ skip_white_(tline);
+ if (!tok_is_(tline, "(")) {
+ /*
+ * This macro wasn't called with parameters: ignore
+ * the call. (Behaviour borrowed from gnu cpp.)
+ */
+ tline = mstart;
+ m = NULL;
+ }
+ else {
+ int paren = 0;
+ int white = 0;
+ brackets = 0;
+ nparam = 0;
+ tline = tline->next;
+ sparam = PARAM_DELTA;
+ params = nasm_malloc (sparam*sizeof(Token *));
+ params[0] = tline;
+ paramsize = nasm_malloc (sparam*sizeof(int));
+ paramsize[0] = 0;
+ for (;;tline = tline->next) { /* parameter loop */
+ if (!tline) {
+ error(ERR_NONFATAL,
+ "macro call expects terminating `)'");
+ break;
+ }
+ if (tline->type == TOK_WHITESPACE && brackets<=0) {
+ if (paramsize[nparam])
+ white++;
+ else
+ params[nparam] = tline->next;
+ continue; /* parameter loop */
+ }
+ if (tline->type == TOK_OTHER && tline->text[1]==0) {
+ char ch = tline->text[0];
+ if (ch == ',' && !paren && brackets<=0) {
+ if (++nparam >= sparam) {
+ sparam += PARAM_DELTA;
+ params = nasm_realloc (params,
+ sparam*sizeof(Token *));
+ paramsize = nasm_realloc (paramsize,
+ sparam*sizeof(int));
+ }
+ params[nparam] = tline->next;
+ paramsize[nparam] = 0;
+ white = 0;
+ continue; /* parameter loop */
+ }
+ if (ch == br0 &&
+ (brackets>0 || (brackets==0 &&
+ !paramsize[nparam])))
+ {
+ if (!(brackets++))
+ {
+ params[nparam] = tline->next;
+ continue; /* parameter loop */
+ }
+ }
+ if (ch == br2 && brackets>0)
+ if (--brackets == 0) {
+ brackets = -1;
+ continue; /* parameter loop */
+ }
+ if (ch == '(' && !brackets)
+ paren++;
+ if (ch == ')' && brackets<=0)
+ if (--paren < 0)
+ break;
+ }
+ if (brackets<0) {
+ brackets = 0;
+ error (ERR_NONFATAL, "braces do not "
+ "enclose all of macro parameter");
+ }
+ paramsize[nparam] += white+1;
+ white = 0;
+ } /* parameter loop */
+ nparam++;
+ while (m && (m->nparam != nparam ||
+ mstrcmp(m->name, p, m->casesense)))
+ m = m->next;
+ if (!m)
+ error (ERR_WARNING|ERR_WARN_MNP,
+ "macro `%s' exists, "
+ "but not taking %d parameters",
+ mstart->text, nparam);
+ }
+ }
+ if (m && m->in_progress)
+ m = NULL;
+ if (!m) /* in progess or didn't find '(' or wrong nparam */
+ {
+ /*
+ * Design question: should we handle !tline, which
+ * indicates missing ')' here, or expand those
+ * macros anyway, which requires the (t) test a few
+ * lines down?
+ */
+ nasm_free (params);
+ nasm_free (paramsize);
+ tline = mstart;
+ }
+ else {
+ /*
+ * Expand the macro: we are placed on the last token of the
+ * call, so that we can easily split the call from the
+ * following tokens. We also start by pushing an SMAC_END
+ * token for the cycle removal.
+ */
+ t = tline;
+ if (t) {
+ tline = t->next;
+ t->next = NULL;
}
- params[nparam] = tline;
- paramsize[nparam] = 0;
- brackets = 0;
- if (tline && tline->type == TOK_OTHER &&
- !strcmp(tline->text, "{")) {
- params[nparam] = tline = tline->next;
- while (tline && (brackets > 0 ||
- tline->type != TOK_OTHER ||
- strcmp(tline->text, "}"))) {
- tline = tline->next;
- paramsize[nparam]++;
- }
- tline = tline->next;
- if (tline && tline->type == TOK_WHITESPACE)
- tline = tline->next;
- if (tline && (tline->type != TOK_OTHER ||
- (strcmp(tline->text, ")") &&
- strcmp(tline->text, ",")))) {
- error (ERR_NONFATAL|ERR_OFFBY1, "braces do not "
- "enclose all of macro parameter");
- }
- if (tline && tline->type == TOK_OTHER &&
- !strcmp(tline->text, ","))
- tline = tline->next;
- } else {
- while (tline && (brackets > 0 ||
- tline->type != TOK_OTHER ||
- (strcmp(tline->text, ",") &&
- strcmp(tline->text, ")")))) {
- if (tline->type == TOK_OTHER && !tline->text[1])
- brackets += (tline->text[0] == '(' ? 1 :
- tline->text[0] == ')' ? -1 : 0);
- tline = tline->next;
- paramsize[nparam]++;
+ tt = nasm_malloc(sizeof(Token));
+ tt->type = TOK_SMAC_END;
+ tt->text = NULL;
+ tt->mac = m;
+ m->in_progress = TRUE;
+ tt->next = tline;
+ tline = tt;
+ for (t = m->expansion; t; t = t->next) {
+ if (t->type >= TOK_SMAC_PARAM) {
+ Token *pcopy = tline, **ptail = &pcopy;
+ Token *ttt, *pt;
+ int i;
+
+ ttt = params[t->type - TOK_SMAC_PARAM];
+ for (i=paramsize[t->type-TOK_SMAC_PARAM]; --i>=0;) {
+ pt = *ptail = nasm_malloc(sizeof(Token));
+ pt->next = tline;
+ ptail = &pt->next;
+ pt->text = nasm_strdup(ttt->text);
+ pt->type = ttt->type;
+ pt->mac = NULL;
+ ttt = ttt->next;
+ }
+ tline = pcopy;
+ } else {
+ tt = nasm_malloc(sizeof(Token));
+ tt->type = t->type;
+ tt->text = nasm_strdup(t->text);
+ tt->mac = NULL;
+ tt->next = tline;
+ tline = tt;
}
}
- nparam++;
- if (tline && !strcmp(tline->text, ")"))
- break;
- if (tline && !strcmp(tline->text, ","))
- tline = tline->next;
- }
- while (m && m->nparam != nparam) {
- while ( (m = m->next) )
- if (!strcmp(m->name, mstart->text))
- break;
- }
- if (!m) {
- error (ERR_WARNING|ERR_OFFBY1|ERR_WARN_MNP,
- "macro `%s' exists, but not taking %d parameters",
- mstart->text, nparam);
+
+ /*
+ * Having done that, get rid of the macro call, and clean
+ * up the parameters.
+ */
nasm_free (params);
nasm_free (paramsize);
- tline = mstart;
- tline->type = TOK_PS_OTHER;
- continue;
+ free_tlist (mstart);
+ continue; /* main token loop */
+ }
}
}
- /*
- * Expand the macro: we are placed on the last token of the
- * call, so that we can easily split the call from the
- * following tokens. We also start by pushing an SMAC_END
- * token for the cycle removal.
- */
- t = tline;
- tline = tline->next;
- t->next = NULL;
- tt = nasm_malloc(sizeof(Token));
- tt->type = TOK_SMAC_END;
- tt->text = NULL;
- tt->mac = m;
- m->in_progress = TRUE;
- tt->next = tline;
- tline = tt;
- for (t = m->expansion; t; t = t->next) {
- if (t->type >= TOK_SMAC_PARAM) {
- Token *pcopy = tline, **ptail = &pcopy;
- Token *ttt, *pt;
- int i;
-
- ttt = params[t->type - TOK_SMAC_PARAM];
- for (i=0; i<paramsize[t->type-TOK_SMAC_PARAM]; i++) {
- pt = *ptail = nasm_malloc(sizeof(Token));
- pt->next = tline;
- ptail = &pt->next;
- pt->text = nasm_strdup(ttt->text);
- pt->type = ttt->type;
- pt->mac = NULL;
- ttt = ttt->next;
+
+ if (tline->type == TOK_SMAC_END) {
+ tline->mac->in_progress = FALSE;
+ t = tline;
+ tline = tline->next;
+ nasm_free (t);
+ } else {
+ t = *tail = tline;
+ tline = tline->next;
+ t->mac = NULL;
+ t->next = NULL;
+ tail = &t->next;
+ if (t->type == TOK_PREPROC_ID && t->text[1] == '$') {
+ Context *c = get_ctx (t->text);
+ char *p, *q, buffer[40];
+
+ t->type = TOK_ID;
+ if (c) {
+ q = t->text+1;
+ q += strspn(q, "$");
+ sprintf(buffer, "..@%lu.", c->number);
+ p = nasm_strcat (buffer,q);
+ nasm_free (t->text);
+ t->text = p;
}
- tline = pcopy;
- } else {
- tt = nasm_malloc(sizeof(Token));
- tt->type = t->type;
- tt->text = nasm_strdup(t->text);
- tt->mac = NULL;
- tt->next = tline;
- tline = tt;
}
}
-
- /*
- * Having done that, get rid of the macro call, and clean
- * up the parameters.
- */
- nasm_free (params);
- nasm_free (paramsize);
- free_tlist (mstart);
}
return thead;
* to be called with tline->type == TOK_ID, so the putative macro
* name is easy to find.
*/
-static MMacro *is_mmacro (Token *tline, Token ***params_array) {
+static MMacro *is_mmacro (Token *tline, Token ***params_array)
+{
MMacro *head, *m;
Token **params;
int nparam;
* prohibits us using it before we actually celebrate...
*/
if (m->in_progress) {
- error (ERR_NONFATAL|ERR_OFFBY1,
+#if 0
+ error (ERR_NONFATAL,
"self-reference in multi-line macro `%s'",
m->name);
+#endif
nasm_free (params);
return NULL;
}
* After all that, we didn't find one with the right number of
* parameters. Issue a warning, and fail to expand the macro.
*/
- error (ERR_WARNING|ERR_OFFBY1|ERR_WARN_MNP,
+ error (ERR_WARNING|ERR_WARN_MNP,
"macro `%s' exists, but not taking %d parameters",
tline->text, nparam);
nasm_free (params);
/*
* Expand the multi-line macro call made by the given line, if
* there is one to be expanded. If there is, push the expansion on
- * istk->expansion and return 1 or 2, as according to whether a
- * line sync is needed (2 if it is). Otherwise return 0.
+ * istk->expansion and return 1. Otherwise return 0.
*/
-static int expand_mmacro (Token *tline) {
- Token *label = NULL, **params, *t, *tt, *last = NULL;
- MMacro *m = NULL;
+static int expand_mmacro (Token *tline)
+{
+ Token *startline = tline;
+ Token *label = NULL;
+ int dont_prepend = 0;
+ Token **params, *t, *tt;
+ MMacro *m;
Line *l, *ll;
int i, nparam, *paramlen;
- int need_sync = FALSE;
t = tline;
- if (t && t->type == TOK_WHITESPACE)
+ skip_white_(t);
+ if (!tok_type_(t, TOK_ID))
+ return 0;
+ m = is_mmacro (t, ¶ms);
+ if (!m) {
+ Token *last;
+ /*
+ * We have an id which isn't a macro call. We'll assume
+ * it might be a label; we'll also check to see if a
+ * colon follows it. Then, if there's another id after
+ * that lot, we'll check it again for macro-hood.
+ */
+ label = last = t;
t = t->next;
- if (t && t->type == TOK_ID) {
- m = is_mmacro (t, ¶ms);
- if (!m) {
- /*
- * We have an id which isn't a macro call. We'll assume
- * it might be a label; we'll also check to see if a
- * colon follows it. Then, if there's another id after
- * that lot, we'll check it again for macro-hood.
- */
+ if (tok_type_(t, TOK_WHITESPACE))
last = t, t = t->next;
- if (t && t->type == TOK_WHITESPACE)
- last = t, t = t->next;
- if (t && t->type == TOK_OTHER && !strcmp(t->text, ":"))
- last = t, t = t->next;
- if (t && t->type == TOK_WHITESPACE)
+ if (tok_is_(t, ":")) {
+ dont_prepend = 1;
+ last = t, t = t->next;
+ if (tok_type_(t, TOK_WHITESPACE))
last = t, t = t->next;
- if (t && t->type == TOK_ID) {
- m = is_mmacro(t, ¶ms);
- if (m) {
- last->next = NULL;
- label = tline;
- tline = t;
- }
- }
- }
+ }
+ if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, ¶ms)) == NULL)
+ return 0;
+ last->next = NULL;
+ tline = t;
}
- if (!m)
- return 0;
-
- /*
- * If we're not already inside another macro expansion, we'd
- * better push a line synchronisation to ensure we stay put on
- * line numbering.
- */
- if (!istk->expansion)
- need_sync = TRUE;
/*
* Fix up the parameters: this involves stripping leading and
* trailing whitespace, then stripping braces if they are
* present.
*/
- for (nparam = 0; params[nparam]; nparam++);
+ for (nparam = 0; params[nparam]; nparam++)
+ ;
paramlen = nparam ? nasm_malloc(nparam*sizeof(*paramlen)) : NULL;
for (i = 0; params[i]; i++) {
int comma = (!m->plus || i < nparam-1);
t = params[i];
- if (t && t->type == TOK_WHITESPACE)
- t = t->next;
- if (t && t->type == TOK_OTHER && !strcmp(t->text, "{"))
+ skip_white_(t);
+ if (tok_is_(t, "{"))
t = t->next, brace = TRUE, comma = FALSE;
params[i] = t;
paramlen[i] = 0;
while (t) {
- if (!t) /* end of param because EOL */
- break;
if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
break; /* ... because we have hit a comma */
- if (comma && t->type == TOK_WHITESPACE &&
- t->next->type == TOK_OTHER && !strcmp(t->next->text, ","))
+ if (comma && t->type == TOK_WHITESPACE && tok_is_(t->next, ","))
break; /* ... or a space then a comma */
if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
break; /* ... or a brace */
Token **tail;
ll = nasm_malloc(sizeof(Line));
- ll->next = istk->expansion;
ll->finishes = NULL;
- ll->first = NULL;
+ ll->next = istk->expansion;
+ istk->expansion = ll;
tail = &ll->first;
for (t = l->first; t; t = t->next) {
+ Token *x = t;
+ if (t->type == TOK_PREPROC_ID &&
+ t->text[1]=='0' && t->text[2]=='0')
+ {
+ dont_prepend = -1;
+ x = label;
+ if (!x)
+ continue;
+ }
tt = *tail = nasm_malloc(sizeof(Token));
- tt->next = NULL;
tail = &tt->next;
- tt->type = t->type;
- tt->text = nasm_strdup(t->text);
+ tt->type = x->type;
+ tt->text = nasm_strdup(x->text);
tt->mac = NULL;
}
-
- istk->expansion = ll;
-
+ *tail = NULL;
}
/*
- * If we had a label, push it on the front of the first line of
- * the macro expansion. We must check that this doesn't give
- * two consecutive TOK_WHITESPACE.
+ * If we had a label, push it on as the first line of
+ * the macro expansion.
*/
- if (label) {
- if (last->type == TOK_WHITESPACE &&
- istk->expansion->first->type == TOK_WHITESPACE) {
- Token *victim = istk->expansion->first; /* kill this whitespace */
- istk->expansion->first = victim->next;
- nasm_free (victim->text);
- nasm_free (victim);
- }
- last->next = istk->expansion->first;
- istk->expansion->first = label;
- }
+ if (label)
+ if (dont_prepend<0)
+ free_tlist(startline);
+ else {
+ ll = nasm_malloc(sizeof(Line));
+ ll->finishes = NULL;
+ ll->next = istk->expansion;
+ istk->expansion = ll;
+ ll->first = startline;
+ if (!dont_prepend) {
+ while (label->next)
+ label = label->next;
+ label->next = tt = nasm_malloc(sizeof(Token));
+ tt->next = NULL;
+ tt->mac = NULL;
+ tt->type = TOK_OTHER;
+ tt->text = nasm_strdup(":");
+ }
+ }
list->uplevel (m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
- return need_sync ? 2 : 1;
+ return 1;
}
static void pp_reset (char *file, int apass, efunc errfunc, evalfunc eval,
- ListGen *listgen) {
+ ListGen *listgen)
+{
int h;
error = errfunc;
cstk = NULL;
- linesync = outline = NULL;
istk = nasm_malloc(sizeof(Include));
istk->next = NULL;
istk->conds = NULL;
istk->expansion = NULL;
istk->mstk = NULL;
istk->fp = fopen(file, "r");
- istk->fname = nasm_strdup(file);
- istk->lineno = istk->lineinc = 1;
+ istk->fname = NULL;
+ src_set_fname(nasm_strdup(file));
+ src_set_linnum(0);
+ istk->lineinc = 1;
if (!istk->fp)
error (ERR_FATAL|ERR_NOFILE, "unable to open input file `%s'", file);
defining = NULL;
pass = apass;
}
-static char *pp_getline (void) {
+static char *pp_getline (void)
+{
char *line;
Token *tline;
int ret;
- if (outline) {
- line = outline;
- outline = NULL;
- return line;
- }
-
while (1) {
/*
* Fetch a tokenised line, either from the macro-expansion
istk->expansion = ll;
}
- line_sync();
} else {
/*
* Check whether a `%rep' was started and not ended
" expansion of macro `%s'", istk->mstk->name);
}
- if (istk->mstk->name) {
- /*
- * This was a real macro call, not a %rep, and
- * therefore the parameter information needs to
- * be freed.
- */
- nasm_free(istk->mstk->params);
- free_tlist(istk->mstk->iline);
- nasm_free(istk->mstk->paramlen);
+ /*
+ * FIXME: investigate the relationship at this point between
+ * istk->mstk and l->finishes
+ */
+ {
+ MMacro *m = istk->mstk;
+ istk->mstk = m->next_active;
+ if (m->name) {
+ /*
+ * This was a real macro call, not a %rep, and
+ * therefore the parameter information needs to
+ * be freed.
+ */
+ nasm_free(m->params);
+ free_tlist(m->iline);
+ nasm_free(m->paramlen);
+ l->finishes->in_progress = FALSE;
+ }
+ else
+ free_mmacro(m);
}
- istk->mstk = istk->mstk->next_active;
- l->finishes->in_progress = FALSE;
istk->expansion = l->next;
nasm_free (l);
list->downlevel (LIST_MACRO);
- if (!istk->expansion)
- line_sync();
}
}
- if (istk->expansion) {
- char *p;
- Line *l = istk->expansion;
- tline = l->first;
- istk->expansion = l->next;
- nasm_free (l);
- p = detoken(tline);
- list->line (LIST_MACRO, p);
- nasm_free(p);
- if (!istk->expansion)
- line_sync();
- } else {
+ while (1) { /* until we get a line we can use */
+
+ if (istk->expansion) { /* from a macro expansion */
+ char *p;
+ Line *l = istk->expansion;
+ tline = l->first;
+ istk->expansion = l->next;
+ nasm_free (l);
+ p = detoken(tline);
+ list->line (LIST_MACRO, p);
+ nasm_free(p);
+ break;
+ }
line = read_line();
- while (!line) {
- /*
- * The current file has ended; work down the istk
- * until we find a file we can read from.
- */
- Include *i;
- fclose(istk->fp);
- if (istk->conds)
+ if (line) { /* from the current input file */
+ line = prepreproc(line);
+ tline = tokenise(line);
+ nasm_free (line);
+ break;
+ }
+ /*
+ * The current file has ended; work down the istk
+ */
+ {
+ Include *i = istk;
+ fclose(i->fp);
+ if (i->conds)
error(ERR_FATAL, "expected `%%endif' before end of file");
- i = istk;
- istk = istk->next;
+ istk = i->next;
list->downlevel (LIST_INCLUDE);
- nasm_free (i->fname);
+ src_set_linnum(i->lineno);
+ nasm_free ( src_set_fname(i->fname) );
nasm_free (i);
if (!istk)
return NULL;
- else
- line_sync();
- update_fileline(3); /* update __FILE__ and __LINE__ */
- line = read_line();
}
- line = prepreproc(line);
- tline = tokenise(line);
- nasm_free (line);
}
/*
* with things like `%define something %1' such as STRUC
* uses. Unless we're _defining_ a MMacro, in which case
* those tokens should be left alone to go into the
- * definition.
+ * definition; and unless we're in a non-emitting
+ * condition, in which case we don't want to meddle with
+ * anything.
*/
- if (!defining)
+ if (!defining && !(istk->conds && !emitting(istk->conds->state)))
tline = expand_mmac_params(tline);
/*
*/
ret = do_directive(tline);
if (ret & 1) {
- if (ret & 4)
- line_sync();
- if ((ret & 2) && !stdmacpos) {/* give a blank line to the output */
- outline = nasm_strdup("");
- break;
- }
- else
continue;
} else if (defining) {
/*
* We're defining a multi-line macro. We emit nothing
- * at all, not even a blank line (when we finish
- * defining the macro, we'll emit a line-number
- * directive so that we keep sync properly), and just
+ * at all, and just
* shove the tokenised line on to the macro definition.
*/
Line *l = nasm_malloc(sizeof(Line));
*/
line = detoken(tline);
free_tlist (tline);
- outline = line;
break;
} else {
- if (ret == 2)
- line_sync();
continue; /* expand_mmacro calls free_tlist */
}
}
}
- /*
- * Once we're out of this loop, outline _must_ be non-NULL. The
- * only question is whether linesync is NULL or not.
- */
- if (linesync) {
- line = linesync;
- linesync = NULL;
- } else {
- line = outline;
- outline = NULL;
- }
return line;
}
-static void pp_cleanup (void) {
+static void pp_cleanup (void)
+{
int h;
if (defining) {
error (ERR_NONFATAL, "end of file while still defining macro `%s'",
defining->name);
- nasm_free (defining->name);
- free_tlist (defining->dlist);
- free_llist (defining->expansion);
- nasm_free (defining);
+ free_mmacro (defining);
}
- nasm_free (linesync); /* might just be necessary */
- nasm_free (outline); /* really shouldn't be necessary */
while (cstk)
ctx_pop();
for (h=0; h<NHASH; h++) {
while (mmacros[h]) {
MMacro *m = mmacros[h];
mmacros[h] = mmacros[h]->next;
- nasm_free (m->name);
- free_tlist (m->dlist);
- nasm_free (m->defaults);
- free_llist (m->expansion);
- nasm_free (m);
+ free_mmacro(m);
}
while (smacros[h]) {
SMacro *s = smacros[h];
ctx_pop();
}
-void pp_include_path (char *path) {
+void pp_include_path (char *path)
+{
IncPath *i;
i = nasm_malloc(sizeof(IncPath));
ipath = i;
}
-void pp_pre_include (char *fname) {
+void pp_pre_include (char *fname)
+{
Token *inc, *space, *name;
Line *l;
predef = l;
}
-void pp_pre_define (char *definition) {
- Token *def, *space, *name;
+void pp_pre_define (char *definition)
+{
+ Token *def, *space;
Line *l;
char *equals;
def->next = space = nasm_malloc(sizeof(Token));
if (equals)
*equals = ' ';
- space->next = name = tokenise(definition);
+ space->next = tokenise(definition);
if (equals)
*equals = '=';
predef = l;
}
-void pp_extra_stdmac (char **macros) {
+void pp_extra_stdmac (char **macros)
+{
extrastdmac = macros;
}
+static void make_tok_num(Token *tok, long val)
+{
+ char numbuf[20];
+ sprintf(numbuf, "%ld", val);
+ tok->text = nasm_strdup(numbuf);
+ tok->type = TOK_NUMBER;
+}
+
Preproc nasmpp = {
pp_reset,
pp_getline,
} *synx;
static int nsynx;
-void init_sync(void) {
+void init_sync(void)
+{
/*
* I'd like to allocate an array of size SYNC_MAX, then write
* `synx--' which would allow numbering the array from one
nsynx = 0;
}
-void add_sync(unsigned long pos, unsigned long length) {
+void add_sync(unsigned long pos, unsigned long length)
+{
int i;
if (nsynx == SYNC_MAX)
}
}
-unsigned long next_sync(unsigned long position, unsigned long *length) {
+unsigned long next_sync(unsigned long position, unsigned long *length)
+{
while (nsynx > 0 && synx[1].pos + synx[1].length <= position) {
int i, j;
struct Sync t;
--- /dev/null
+/* outieee.c output routines for the Netwide Assembler to produce
+ * IEEE-std object files
+ *
+ * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
+ * Julian Hall. All rights reserved. The software is
+ * redistributable under the licence given in the file "Licence"
+ * distributed in the NASM archive.
+ */
+
+/* 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <stdarg.h> /* Note: we need the ANSI version of stdarg.h */
+#include <ctype.h>
+
+#include "nasm.h"
+#include "nasmlib.h"
+#include "outform.h"
+
+#ifdef OF_IEEE
+
+#define ARRAY_BOT 0x1
+
+static char ieee_infile[FILENAME_MAX];
+static int ieee_uppercase;
+
+static efunc error;
+static ldfunc deflabel;
+static FILE *ofp;
+static int 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;
+ long offset;
+ long lineno;
+};
+
+static struct FileName {
+ struct FileName *next;
+ char *name;
+ long index;
+} *fnhead, **fntail;
+
+static struct Array {
+ struct Array *next;
+ unsigned size;
+ int basetype;
+} *arrhead, **arrtail;
+
+static struct ieeePublic {
+ struct ieeePublic *next;
+ char *name;
+ long offset;
+ long segment; /* only if it's far-absolute */
+ long index;
+ int type; /* for debug purposes */
+} *fpubhead, **fpubtail, *last_defined;
+
+static struct ieeeExternal {
+ struct ieeeExternal *next;
+ char *name;
+ long 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 ieeeObjData *data,*datacurr;
+ struct ieeeSection *next;
+ struct ieeeFixupp *fptr, * flptr;
+ long index; /* the NASM segment id */
+ long ieee_index; /* the OBJ-file segment index */
+ long currentpos;
+ long align; /* can be SEG_ABS + absolute addr */
+ long startpos;
+ enum {
+ CMB_PRIVATE = 0,
+ CMB_PUBLIC = 2,
+ CMB_COMMON = 6
+ } combine;
+ long use32; /* is this segment 32-bit? */
+ struct ieeePublic *pubhead, **pubtail, *lochead, **loctail;
+ char *name;
+} *seghead, **segtail, *ieee_seg_needs_update;
+
+static struct ieeeObjData {
+ struct ieeeObjData *next;
+ unsigned char 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;
+ short size;
+ long id1;
+ long id2;
+ long offset;
+ long addend;
+};
+
+static long ieee_entry_seg, ieee_entry_ofs;
+static int checksum;
+
+extern struct ofmt of_ieee;
+
+static void ieee_data_new(struct ieeeSection *);
+static void ieee_write_fixup (long, long, struct ieeeSection *,
+ int, long, long);
+static void ieee_install_fixup(struct ieeeSection *, struct ieeeFixupp *);
+static long ieee_segment (char *, int, int *);
+static void ieee_write_file(int debuginfo);
+static void ieee_write_byte(struct ieeeSection *, int);
+static void ieee_write_word(struct ieeeSection *, int);
+static void ieee_write_dword(struct ieeeSection *, long);
+static void ieee_putascii(char *, ...);
+static void ieee_putcs(int);
+static long ieee_putld(long, long, unsigned char *);
+static long ieee_putlr(struct ieeeFixupp *);
+static void ieee_unqualified_name(char *, char *);
+
+
+/*
+ * pup init
+ */
+static void ieee_init (FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval)
+{
+ (void) eval;
+ ofp = fp;
+ error = errfunc;
+ deflabel = ldef;
+ 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;
+ of_ieee.current_dfmt->init (&of_ieee,NULL,fp,errfunc);
+}
+static int ieee_set_info(enum geninfo type, char **val)
+{
+ (void) type;
+ (void) val;
+
+ return 0;
+}
+/*
+ * Rundown
+ */
+static void ieee_cleanup (int debuginfo)
+{
+ ieee_write_file(debuginfo);
+ of_ieee.current_dfmt->cleanup ();
+ fclose (ofp);
+ 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, long segment,
+ long 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) {
+ error(ERR_NONFATAL, "unrecognised symbol type `%s'", special);
+ }
+ /*
+ * First check for the double-period, signifying something
+ * unusual.
+ */
+ if (name[0] == '.' && name[1] == '.') {
+ 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_malloc(sizeof(*eb));
+ eb->next = NULL;
+ ebtail = &eb->next;
+ }
+ while (i > EXT_BLKSIZ) {
+ if (eb && eb->next)
+ eb = eb->next;
+ else {
+ eb = *ebtail = nasm_malloc(sizeof(*eb));
+ eb->next = NULL;
+ ebtail = &eb->next;
+ }
+ i -= EXT_BLKSIZ;
+ }
+ eb->index[i] = externals++;
+ }
+
+}
+
+/*
+ * Put data out
+ */
+static void ieee_out (long segto, void *data, unsigned long type,
+ long segment, long wrt) {
+ long size, realtype;
+ unsigned char *ucdata;
+ long ldata;
+ struct ieeeSection *seg;
+
+ /*
+ * handle absolute-assembly (structure definitions)
+ */
+ if (segto == NO_SEG) {
+ if ((type & OUT_TYPMASK) != OUT_RESERVE)
+ error (ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
+ " space");
+ return;
+ }
+
+ /*
+ * If `any_segs' is still FALSE, we must define a default
+ * segment.
+ */
+ if (!any_segs) {
+ int tempint; /* ignored */
+ if (segto != ieee_segment("__NASMDEFSEG", 2, &tempint))
+ error (ERR_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)
+ error (ERR_PANIC, "code directed to nonexistent segment?");
+
+ size = type & OUT_SIZMASK;
+ realtype = type & OUT_TYPMASK;
+ if (realtype == OUT_RAWDATA) {
+ ucdata = data;
+ while (size--)
+ ieee_write_byte(seg,*ucdata++);
+ } else if (realtype == OUT_ADDRESS || realtype == OUT_REL2ADR ||
+ realtype == OUT_REL4ADR) {
+ if (segment == NO_SEG && realtype != OUT_ADDRESS)
+ error(ERR_NONFATAL, "relative call to absolute address not"
+ " supported by IEEE format");
+ ldata = *(long *)data;
+ if (realtype == OUT_REL2ADR)
+ ldata += (size-2);
+ if (realtype == OUT_REL4ADR)
+ ldata += (size-4);
+ ieee_write_fixup (segment, wrt, seg, size, realtype,ldata);
+ if (size == 2)
+ ieee_write_word (seg, ldata);
+ else
+ ieee_write_dword (seg, ldata);
+ }
+ else if (realtype == 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 (long segment, long wrt, struct ieeeSection * segto,
+ int size, long realtype, long 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
+ */
+ long 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
+ error(ERR_NONFATAL,
+ "Source of WRT must be an offset");
+ }
+
+ }
+ else
+ error(ERR_PANIC,
+ "unrecognised WRT value in ieee_write_fixup");
+ }
+ else
+ error(ERR_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
+ */
+ long 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) {
+ error(ERR_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 */
+ error(ERR_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
+ */
+ long 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 */
+ error(ERR_PANIC,
+ "unrecognised segment value in ieee_write_fixup");
+ }
+ }
+ if (size != 2 && s.ftype == FT_SEG)
+ error(ERR_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 long ieee_segment (char *name, int pass, 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, rn_error;
+ char *p;
+
+ /*
+ * Look for segment attributes.
+ */
+ attrs = 0;
+ while (*name == '.')
+ name++; /* hack, but a documented one */
+ p = name;
+ while (*p && !isspace(*p))
+ p++;
+ if (*p) {
+ *p++ = '\0';
+ while (*p && isspace(*p))
+ *p++ = '\0';
+ }
+ while (*p) {
+ while (*p && !isspace(*p))
+ p++;
+ if (*p) {
+ *p++ = '\0';
+ while (*p && 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 && pass == 1)
+ error(ERR_WARNING, "segment attributes specified on"
+ " redeclaration of segment: ignoring");
+ if (seg->use32)
+ *bits = 32;
+ else
+ *bits = 16;
+ 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;
+ error (ERR_NONFATAL, "segment alignment should be"
+ " numeric");
+ }
+ switch ((int) 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:
+ error(ERR_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)
+ error (ERR_NONFATAL, "argument to `absolute' segment"
+ " attribute should be numeric");
+ }
+ }
+
+ ieee_seg_needs_update = seg;
+ if (seg->align >= SEG_ABS)
+ deflabel (name, NO_SEG, seg->align - SEG_ABS,
+ NULL, FALSE, FALSE, &of_ieee, error);
+ else
+ deflabel (name, seg->index+1, 0L,
+ NULL, FALSE, FALSE, &of_ieee, error);
+ ieee_seg_needs_update = NULL;
+
+ if (seg->use32)
+ *bits = 32;
+ else
+ *bits = 16;
+ return seg->index;
+ }
+}
+/*
+ * directives supported
+ */
+static int ieee_directive (char *directive, char *value, int pass)
+{
+
+ (void) value;
+ (void) pass;
+ if (!strcmp(directive, "uppercase")) {
+ ieee_uppercase = TRUE;
+ return 1;
+ }
+ return 0;
+}
+/*
+ * Return segment data
+ */
+static long ieee_segbase (long 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 */
+}
+/*
+ * filename
+ */
+static void ieee_filename (char *inname, char *outname, efunc error) {
+ strcpy(ieee_infile, inname);
+ standard_extension (inname, outname, ".o", error);
+}
+
+static void ieee_write_file (int debuginfo) {
+ struct tm *thetime;
+ time_t reltime;
+ struct FileName *fn;
+ struct ieeeSection *seg;
+ struct ieeePublic *pub, *loc;
+ struct ieeeExternal *ext;
+ struct ieeeObjData *data;
+ struct ieeeFixupp *fix;
+ struct Array *arr;
+ static char boast[] = "The Netwide Assembler " NASM_VER;
+ int i;
+
+ /*
+ * Write the module header
+ */
+ ieee_putascii("MBFNASM,%02X%s.\r\n",strlen(ieee_infile),ieee_infile);
+
+ /*
+ * Write the NASM boast comment.
+ */
+ ieee_putascii("CO0,%02X%s.\r\n",strlen(boast),boast);
+
+ /*
+ * write processor-specific information
+ */
+ ieee_putascii("AD8,4,L.\r\n");
+
+ /*
+ * date and time
+ */
+ time(&reltime);
+ thetime = localtime(&reltime);
+ ieee_putascii("DT%04d%02d%02d%02d%02d%02d.\r\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.\r\n",strlen(fn->name),fn->name);
+ }
+
+ ieee_putascii("CO101,07ENDHEAD.\r\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.\r\n",seg->ieee_index,strlen(buf), buf);
+ ieee_putascii("ASL%X,%lX.\r\n",seg->ieee_index, (seg->align - SEG_ABS)*16);
+ }
+ else {
+ ieee_putascii("ST%X,%c,%02X%s.\r\n",seg->ieee_index,attrib,strlen(buf), buf);
+ ieee_putascii("SA%X,%lX.\r\n",seg->ieee_index,seg->align);
+ ieee_putascii("ASS%X,%X.\r\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)
+ error(ERR_PANIC,"Start address records are incorrect");
+ else
+ ieee_putascii("ASG,R%X,%lX,+.\r\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.\r\n",i, strlen(buf), buf);
+ if (pub->segment == -1)
+ ieee_putascii("ASI%X,R%X,%lX,+.\r\n", i, pub->index,pub->offset);
+ else
+ ieee_putascii("ASI%X,%lX,%lX,+.\r\n", i, pub->segment*16,pub->offset);
+ if (debuginfo)
+ if (pub->type >= 0x100)
+ ieee_putascii("ATI%X,T%X.\r\n", i, pub->type - 0x100);
+ else
+ ieee_putascii("ATI%X,%X.\r\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.\r\n",i, strlen(buf), buf);
+ if (pub->segment == -1)
+ ieee_putascii("ASI%X,R%X,%lX,+.\r\n", i, pub->index,pub->offset);
+ else
+ ieee_putascii("ASI%X,%lX,%lX,+.\r\n", i, pub->segment*16,pub->offset);
+ if (debuginfo)
+ if (pub->type >= 0x100)
+ ieee_putascii("ATI%X,T%X.\r\n", i, pub->type - 0x100);
+ else
+ ieee_putascii("ATI%X,%X.\r\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.\r\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.\r\n");
+
+ /*
+ * now put types
+ */
+ i = ARRAY_BOT;
+ for (arr = arrhead; arr && debuginfo; arr = arr->next) {
+ ieee_putascii("TY%X,20,%X,%lX.\r\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.\r\n",i, strlen(buf), buf);
+ if (loc->segment == -1)
+ ieee_putascii("ASN%X,R%X,%lX,+.\r\n", i, loc->index,loc->offset);
+ else
+ ieee_putascii("ASN%X,%lX,%lX,+.\r\n", i, loc->segment*16,loc->offset);
+ if (debuginfo)
+ if (loc->type >= 0x100)
+ ieee_putascii("ATN%X,T%X.\r\n", i, loc->type - 0x100);
+ else
+ ieee_putascii("ATN%X,%X.\r\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) {
+ long size,org = 0;
+ data = seg->data;
+ ieee_putascii("SB%X.\r\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.\r\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, long 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);
+ vsprintf(buffer, format, ap);
+ l = strlen(buffer);
+ for (i=0; i < l; i++)
+ if ((buffer[i] & 0xff) > 31)
+ checksum+=buffer[i];
+ va_end(ap);
+ fprintf(ofp,buffer);
+}
+
+/*
+ * put out a checksum record */
+static void ieee_putcs(int toclear)
+{
+ if (toclear) {
+ ieee_putascii("CS.\r\n");
+ }
+ else {
+ checksum += 'C';
+ checksum += 'S';
+ ieee_putascii("CS%02X.\r\n",checksum & 127);
+ }
+ checksum = 0;
+}
+
+static long ieee_putld(long start, long end, unsigned char *buf)
+{
+ long 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(".\r\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(".\r\n");
+ return(start);
+}
+static long 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];
+ long size=p->size;
+ switch(p->ftype) {
+ case FT_SEG:
+ if (p->id1 < 0)
+ sprintf(buf,"%lX",-p->id1);
+ else
+ sprintf(buf,"L%X,10,/",p->id1);
+ break;
+ case FT_OFS:
+ sprintf(buf,"R%X,%lX,+",p->id1,p->addend);
+ break;
+ case FT_REL:
+ sprintf(buf,"R%X,%lX,+,P,-,%X,-",p->id1,p->addend,p->size);
+ break;
+
+ case FT_WRT:
+ if (p->id2 < 0)
+ sprintf(buf,"R%X,%lX,+,L%X,+,%lX,-",p->id2,p->addend,p->id2,-p->id1*16);
+ else
+ sprintf(buf,"R%X,%lX,+,L%X,+,L%X,-",p->id2,p->addend,p->id2,p->id1);
+ break;
+ case FT_EXT:
+ sprintf(buf,"X%X",p->id1,p->id1);
+ break;
+ case FT_EXTREL:
+ sprintf(buf,"X%X,P,-,%X,-",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%X,10,/",p->id1);
+ break;
+ case FT_EXTWRT:
+ if (p->id2 < 0)
+ sprintf(buf,"X%X,Y%X,+,%lX,-",p->id2,p->id2,-p->id1*16);
+ else
+ sprintf(buf,"X%X,Y%X,+,L%X,-",p->id2,p->id2,p->id1);
+ break;
+ }
+ ieee_putascii("LR(%s,%lX).\r\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);
+}
+void dbgls_init(struct ofmt * of, void * id, FILE * fp, efunc error)
+{
+ int tempint;
+ (void) of;
+ (void) id;
+ (void) fp;
+ (void) error;
+
+ fnhead = NULL;
+ fntail = &fnhead;
+ arrindex = ARRAY_BOT ;
+ arrhead = NULL;
+ arrtail = &arrhead;
+ ieee_segment("??LINE", 2, &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, long lineno, long 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", 2, &tempint))
+ error (ERR_PANIC, "strange segment conditions in OBJ driver");
+ }
+
+ /*
+ * Find the segment we are targetting.
+ */
+ for (seg = seghead; seg; seg = seg->next)
+ if (seg->index == segto)
+ break;
+ if (!seg)
+ error (ERR_PANIC, "lineno directed to nonexistent segment?");
+
+ for (fn = fnhead; fn; fn = fnhead->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, long segment,
+ long offset, int is_global, char *special)
+{
+ struct ieeeSection *seg;
+ int used_special = FALSE; /* have we used the special text? */
+
+ (void) special;
+
+ /*
+ * If it's a special-retry from pass two, discard it.
+ */
+ if (is_global == 3)
+ return;
+
+ /*
+ * First check for the double-period, signifying something
+ * unusual.
+ */
+ if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
+ 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 (long type)
+{
+ int elem = TYM_ELEMENTS(type);
+ type = TYM_TYPE(type);
+
+ if (! last_defined)
+ return;
+
+ switch (type) {
+ case TY_BYTE:
+ last_defined->type = 1; /* unsigned char */
+ 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 struct dfmt ladsoft_debug_form = {
+ "LADsoft Debug Records",
+ "ladsoft",
+ dbgls_init,
+ dbgls_linnum,
+ dbgls_deflabel,
+ null_debug_routine,
+ dbgls_typevalue,
+ dbgls_output,
+ dbgls_cleanup,
+};
+static struct dfmt *ladsoft_debug_arr[3] = {
+ &ladsoft_debug_form,
+ &null_debug_form,
+ NULL
+};
+struct ofmt of_ieee = {
+ "IEEE-695 (LADsoft variant) object file format",
+ "ieee",
+ NULL,
+ ladsoft_debug_arr,
+ &null_debug_form,
+ NULL,
+ ieee_init,
+ ieee_set_info,
+ ieee_out,
+ ieee_deflabel,
+ ieee_segment,
+ ieee_segbase,
+ ieee_directive,
+ ieee_filename,
+ ieee_cleanup
+};
+
+#endif /* OF_IEEE */
projects / platform / upstream / nasm.git / commitdiff