1 /* nasm.h main header file for the Netwide Assembler: inter-module interface
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the licence given in the file "Licence"
6 * distributed in the NASM archive.
8 * initial version: 27/iii/95 by Simon Tatham
14 #define NASM_MAJOR_VER 0
15 #define NASM_MINOR_VER 98
16 #define NASM_VER "0.98.21"
23 #define FALSE 0 /* comes in handy */
29 #define NO_SEG -1L /* null segment value */
30 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
33 #define FILENAME_MAX 256
41 #define POSTFIX_MAX 10
47 * Name pollution problems: <time.h> on Digital UNIX pulls in some
48 * strange hardware header file which sees fit to define R_SP. We
49 * undefine it here so as not to break the enum below.
56 * We must declare the existence of this structure type up here,
57 * since we have to reference it before we define it...
62 * -------------------------
63 * Error reporting functions
64 * -------------------------
68 * An error reporting function should look like this.
70 typedef void (*efunc
) (int severity
, char *fmt
, ...);
73 * These are the error severity codes which get passed as the first
74 * argument to an efunc.
77 #define ERR_DEBUG 0x00000008 /* put out debugging message */
78 #define ERR_WARNING 0x00000000 /* warn only: no further action */
79 #define ERR_NONFATAL 0x00000001 /* terminate assembly after phase */
80 #define ERR_FATAL 0x00000002 /* instantly fatal: exit with error */
81 #define ERR_PANIC 0x00000003 /* internal error: panic instantly
82 * and dump core for reference */
83 #define ERR_MASK 0x0000000F /* mask off the above codes */
84 #define ERR_NOFILE 0x00000010 /* don't give source file name/line */
85 #define ERR_USAGE 0x00000020 /* print a usage message */
86 #define ERR_PASS1 0x00000040 /* only print this error on pass one */
89 * These codes define specific types of suppressible warning.
92 #define ERR_WARN_MASK 0x0000FF00 /* the mask for this feature */
93 #define ERR_WARN_SHR 8 /* how far to shift right */
95 #define ERR_WARN_MNP 0x00000100 /* macro-num-parameters warning */
96 #define ERR_WARN_MSR 0x00000200 /* macro self-reference */
97 #define ERR_WARN_OL 0x00000300 /* orphan label (no colon, and
99 #define ERR_WARN_NOV 0x00000400 /* numeric overflow */
100 #define ERR_WARN_MAX 4 /* the highest numbered one */
103 * -----------------------
104 * Other function typedefs
105 * -----------------------
109 * A label-lookup function should look like this.
111 typedef int (*lfunc
) (char *label
, long *segment
, long *offset
);
114 * And a label-definition function like this. The boolean parameter
115 * `is_norm' states whether the label is a `normal' label (which
116 * should affect the local-label system), or something odder like
117 * an EQU or a segment-base symbol, which shouldn't.
119 typedef void (*ldfunc
) (char *label
, long segment
, long offset
, char *special
,
120 int is_norm
, int isextrn
, struct ofmt
*ofmt
,
124 * List-file generators should look like this:
128 * Called to initialise the listing file generator. Before this
129 * is called, the other routines will silently do nothing when
130 * called. The `char *' parameter is the file name to write the
133 void (*init
) (char *, efunc
);
136 * Called to clear stuff up and close the listing file.
138 void (*cleanup
) (void);
141 * Called to output binary data. Parameters are: the offset;
142 * the data; the data type. Data types are similar to the
143 * output-format interface, only OUT_ADDRESS will _always_ be
144 * displayed as if it's relocatable, so ensure that any non-
145 * relocatable address has been converted to OUT_RAWDATA by
146 * then. Note that OUT_RAWDATA+0 is a valid data type, and is a
147 * dummy call used to give the listing generator an offset to
148 * work with when doing things like uplevel(LIST_TIMES) or
149 * uplevel(LIST_INCBIN).
151 void (*output
) (long, void *, unsigned long);
154 * Called to send a text line to the listing generator. The
155 * `int' parameter is LIST_READ or LIST_MACRO depending on
156 * whether the line came directly from an input file or is the
157 * result of a multi-line macro expansion.
159 void (*line
) (int, char *);
162 * Called to change one of the various levelled mechanisms in
163 * the listing generator. LIST_INCLUDE and LIST_MACRO can be
164 * used to increase the nesting level of include files and
165 * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
166 * two binary-output-suppression mechanisms for large-scale
167 * pseudo-instructions.
169 * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
170 * it indicates the beginning of the expansion of a `nolist'
171 * macro, so anything under that level won't be expanded unless
172 * it includes another file.
174 void (*uplevel
) (int);
177 * Reverse the effects of uplevel.
179 void (*downlevel
) (int);
183 * The expression evaluator must be passed a scanner function; a
184 * standard scanner is provided as part of nasmlib.c. The
185 * preprocessor will use a different one. Scanners, and the
186 * token-value structures they return, look like this.
188 * The return value from the scanner is always a copy of the
189 * `t_type' field in the structure.
193 long t_integer
, t_inttwo
;
196 typedef int (*scanner
) (void *private_data
, struct tokenval
*tv
);
199 * Token types returned by the scanner, in addition to ordinary
200 * ASCII character values, and zero for end-of-string.
202 enum { /* token types, other than chars */
203 TOKEN_INVALID
= -1, /* a placeholder value */
204 TOKEN_EOS
= 0, /* end of string */
205 TOKEN_EQ
= '=', TOKEN_GT
= '>', TOKEN_LT
= '<', /* aliases */
206 TOKEN_ID
= 256, TOKEN_NUM
, TOKEN_REG
, TOKEN_INSN
, /* major token types */
207 TOKEN_ERRNUM
, /* numeric constant with error in */
208 TOKEN_HERE
, TOKEN_BASE
, /* $ and $$ */
209 TOKEN_SPECIAL
, /* BYTE, WORD, DWORD, FAR, NEAR, etc */
210 TOKEN_PREFIX
, /* A32, O16, LOCK, REPNZ, TIMES, etc */
211 TOKEN_SHL
, TOKEN_SHR
, /* << and >> */
212 TOKEN_SDIV
, TOKEN_SMOD
, /* // and %% */
213 TOKEN_GE
, TOKEN_LE
, TOKEN_NE
, /* >=, <= and <> (!= is same as <>) */
214 TOKEN_DBL_AND
, TOKEN_DBL_OR
, TOKEN_DBL_XOR
, /* &&, || and ^^ */
215 TOKEN_SEG
, TOKEN_WRT
, /* SEG and WRT */
216 TOKEN_FLOAT
/* floating-point constant */
226 * Expression-evaluator datatype. Expressions, within the
227 * evaluator, are stored as an array of these beasts, terminated by
228 * a record with type==0. Mostly, it's a vector type: each type
229 * denotes some kind of a component, and the value denotes the
230 * multiple of that component present in the expression. The
231 * exception is the WRT type, whose `value' field denotes the
232 * segment to which the expression is relative. These segments will
233 * be segment-base types, i.e. either odd segment values or SEG_ABS
234 * types. So it is still valid to assume that anything with a
235 * `value' field of zero is insignificant.
238 long type
; /* a register, or EXPR_xxx */
239 long value
; /* must be >= 32 bits */
243 * The evaluator can also return hints about which of two registers
244 * used in an expression should be the base register. See also the
245 * `operand' structure.
253 * The actual expression evaluator function looks like this. When
254 * called, it expects the first token of its expression to already
255 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
256 * it will start by calling the scanner.
258 * If a forward reference happens during evaluation, the evaluator
259 * must set `*fwref' to TRUE if `fwref' is non-NULL.
261 * `critical' is non-zero if the expression may not contain forward
262 * references. The evaluator will report its own error if this
263 * occurs; if `critical' is 1, the error will be "symbol not
264 * defined before use", whereas if `critical' is 2, the error will
265 * be "symbol undefined".
267 * If `critical' has bit 8 set (in addition to its main value: 0x101
268 * and 0x102 correspond to 1 and 2) then an extended expression
269 * syntax is recognised, in which relational operators such as =, <
270 * and >= are accepted, as well as low-precedence logical operators
273 * If `hints' is non-NULL, it gets filled in with some hints as to
274 * the base register in complex effective addresses.
276 #define CRITICAL 0x100
277 typedef expr
*(*evalfunc
) (scanner sc
, void *scprivate
, struct tokenval
*tv
,
278 int *fwref
, int critical
, efunc error
,
279 struct eval_hints
*hints
);
282 * Special values for expr->type. ASSUMPTION MADE HERE: the number
283 * of distinct register names (i.e. possible "type" fields for an
284 * expr structure) does not exceed 124 (EXPR_REG_START through
287 #define EXPR_REG_START 1
288 #define EXPR_REG_END 124
289 #define EXPR_UNKNOWN 125L /* for forward references */
290 #define EXPR_SIMPLE 126L
291 #define EXPR_WRT 127L
292 #define EXPR_SEGBASE 128L
295 * Preprocessors ought to look like this:
299 * Called at the start of a pass; given a file name, the number
300 * of the pass, an error reporting function, an evaluator
301 * function, and a listing generator to talk to.
303 void (*reset
) (char *, int, efunc
, evalfunc
, ListGen
*);
306 * Called to fetch a line of preprocessed source. The line
307 * returned has been malloc'ed, and so should be freed after
310 char *(*getline
) (void);
313 * Called at the end of a pass.
315 void (*cleanup
) (int);
319 * ----------------------------------------------------------------
320 * Some lexical properties of the NASM source language, included
321 * here because they are shared between the parser and preprocessor
322 * ----------------------------------------------------------------
326 * isidstart matches any character that may start an identifier, and isidchar
327 * matches any character that may appear at places other than the start of an
328 * identifier. E.g. a period may only appear at the start of an identifier
329 * (for local labels), whereas a number may appear anywhere *but* at the
333 #define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
335 #define isidchar(c) ( isidstart(c) || isdigit(c) || (c)=='$' || (c)=='#' \
338 /* Ditto for numeric constants. */
340 #define isnumstart(c) ( isdigit(c) || (c)=='$' )
341 #define isnumchar(c) ( isalnum(c) )
343 /* This returns the numeric value of a given 'digit'. */
345 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
348 * Data-type flags that get passed to listing-file routines.
351 LIST_READ
, LIST_MACRO
, LIST_MACRO_NOLIST
, LIST_INCLUDE
,
352 LIST_INCBIN
, LIST_TIMES
356 * -----------------------------------------------------------
357 * Format of the `insn' structure returned from `parser.c' and
358 * passed into `assemble.c'
359 * -----------------------------------------------------------
363 * Here we define the operand types. These are implemented as bit
364 * masks, since some are subsets of others; e.g. AX in a MOV
365 * instruction is a special operand type, whereas AX in other
366 * contexts is just another 16-bit register. (Also, consider CL in
367 * shift instructions, DX in OUT, etc.)
370 /* size, and other attributes, of the operand */
371 #define BITS8 0x00000001L
372 #define BITS16 0x00000002L
373 #define BITS32 0x00000004L
374 #define BITS64 0x00000008L /* FPU only */
375 #define BITS80 0x00000010L /* FPU only */
376 #define FAR 0x00000020L /* grotty: this means 16:16 or */
377 /* 16:32, like in CALL/JMP */
378 #define NEAR 0x00000040L
379 #define SHORT 0x00000080L /* and this means what it says :) */
381 #define SIZE_MASK 0x000000FFL /* all the size attributes */
382 #define NON_SIZE (~SIZE_MASK)
384 #define TO 0x00000100L /* reverse effect in FADD, FSUB &c */
385 #define COLON 0x00000200L /* operand is followed by a colon */
387 /* type of operand: memory reference, register, etc. */
388 #define MEMORY 0x00204000L
389 #define REGISTER 0x00001000L /* register number in 'basereg' */
390 #define IMMEDIATE 0x00002000L
392 #define REGMEM 0x00200000L /* for r/m, ie EA, operands */
393 #define REGNORM 0x00201000L /* 'normal' reg, qualifies as EA */
394 #define REG8 0x00201001L
395 #define REG16 0x00201002L
396 #define REG32 0x00201004L
397 #define MMXREG 0x00201008L /* MMX registers */
398 #define XMMREG 0x00201010L /* XMM Katmai reg */
399 #define FPUREG 0x01000000L /* floating point stack registers */
400 #define FPU0 0x01000800L /* FPU stack register zero */
402 /* special register operands: these may be treated differently */
403 #define REG_SMASK 0x00070000L /* a mask for the following */
404 #define REG_ACCUM 0x00211000L /* accumulator: AL, AX or EAX */
405 #define REG_AL 0x00211001L /* REG_ACCUM | BITSxx */
406 #define REG_AX 0x00211002L /* ditto */
407 #define REG_EAX 0x00211004L /* and again */
408 #define REG_COUNT 0x00221000L /* counter: CL, CX or ECX */
409 #define REG_CL 0x00221001L /* REG_COUNT | BITSxx */
410 #define REG_CX 0x00221002L /* ditto */
411 #define REG_ECX 0x00221004L /* another one */
412 #define REG_DX 0x00241002L
413 #define REG_SREG 0x00081002L /* any segment register */
414 #define REG_CS 0x01081002L /* CS */
415 #define REG_DESS 0x02081002L /* DS, ES, SS (non-CS 86 registers) */
416 #define REG_FSGS 0x04081002L /* FS, GS (386 extended registers) */
417 #define REG_CDT 0x00101004L /* CRn, DRn and TRn */
418 #define REG_CREG 0x08101004L /* CRn */
419 #define REG_CR4 0x08101404L /* CR4 (Pentium only) */
420 #define REG_DREG 0x10101004L /* DRn */
421 #define REG_TREG 0x20101004L /* TRn */
423 /* special type of EA */
424 #define MEM_OFFS 0x00604000L /* simple [address] offset */
426 /* special type of immediate operand */
427 #define ONENESS 0x00800000L /* so UNITY == IMMEDIATE | ONENESS */
428 #define UNITY 0x00802000L /* for shift/rotate instructions */
429 #define BYTENESS 0x40000000L /* so SBYTE == IMMEDIATE | BYTENESS */
430 #define SBYTE 0x40002000L /* for op r16/32,immediate instrs. */
433 * Next, the codes returned from the parser, for registers and
437 enum { /* register names */
438 R_AH
= EXPR_REG_START
, R_AL
, R_AX
, R_BH
, R_BL
, R_BP
, R_BX
, R_CH
,
439 R_CL
, R_CR0
, R_CR2
, R_CR3
, R_CR4
, R_CS
, R_CX
, R_DH
, R_DI
, R_DL
,
440 R_DR0
, R_DR1
, R_DR2
, R_DR3
, R_DR6
, R_DR7
, R_DS
, R_DX
, R_EAX
,
441 R_EBP
, R_EBX
, R_ECX
, R_EDI
, R_EDX
, R_ES
, R_ESI
, R_ESP
, R_FS
,
442 R_GS
, R_MM0
, R_MM1
, R_MM2
, R_MM3
, R_MM4
, R_MM5
, R_MM6
, R_MM7
,
443 R_SI
, R_SP
, R_SS
, R_ST0
, R_ST1
, R_ST2
, R_ST3
, R_ST4
, R_ST5
,
444 R_ST6
, R_ST7
, R_TR3
, R_TR4
, R_TR5
, R_TR6
, R_TR7
,
445 R_XMM0
, R_XMM1
, R_XMM2
, R_XMM3
, R_XMM4
, R_XMM5
, R_XMM6
, R_XMM7
, REG_ENUM_LIMIT
448 /* Instruction names automatically generated from insns.dat */
451 /* max length of any instruction, register name etc. */
453 #define MAX_KEYWORD MAX_INSLEN
455 #define MAX_KEYWORD 9
458 enum { /* condition code names */
459 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
460 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
461 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
465 * Note that because segment registers may be used as instruction
466 * prefixes, we must ensure the enumerations for prefixes and
467 * register names do not overlap.
469 enum { /* instruction prefixes */
470 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
471 P_A16
= PREFIX_ENUM_START
, P_A32
, P_LOCK
, P_O16
, P_O32
, P_REP
, P_REPE
,
472 P_REPNE
, P_REPNZ
, P_REPZ
, P_TIMES
475 enum { /* extended operand types */
476 EOT_NOTHING
, EOT_DB_STRING
, EOT_DB_NUMBER
479 enum { /* special EA flags */
480 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
481 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
482 EAF_TIMESTWO
= 4 /* really do EAX*2 not EAX+EAX */
485 enum { /* values for `hinttype' */
486 EAH_NOHINT
= 0, /* no hint at all - our discretion */
487 EAH_MAKEBASE
= 1, /* try to make given reg the base */
488 EAH_NOTBASE
= 2 /* try _not_ to make reg the base */
491 typedef struct { /* operand to an instruction */
492 long type
; /* type of operand */
493 int addr_size
; /* 0 means default; 16; 32 */
494 int basereg
, indexreg
, scale
; /* registers and scale involved */
495 int hintbase
, hinttype
; /* hint as to real base register */
496 long segment
; /* immediate segment, if needed */
497 long offset
; /* any immediate number */
498 long wrt
; /* segment base it's relative to */
499 int eaflags
; /* special EA flags */
500 int opflags
; /* see OPFLAG_* defines below */
503 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
504 #define OPFLAG_EXTERN 2 /* operand is an external reference */
506 typedef struct extop
{ /* extended operand */
507 struct extop
*next
; /* linked list */
508 long type
; /* defined above */
509 char *stringval
; /* if it's a string, then here it is */
510 int stringlen
; /* ... and here's how long it is */
511 long segment
; /* if it's a number/address, then... */
512 long offset
; /* ... it's given here ... */
513 long wrt
; /* ... and here */
518 typedef struct { /* an instruction itself */
519 char *label
; /* the label defined, or NULL */
520 int prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
521 int nprefix
; /* number of entries in above */
522 int opcode
; /* the opcode - not just the string */
523 int condition
; /* the condition code, if Jcc/SETcc */
524 int operands
; /* how many operands? 0-3
525 * (more if db et al) */
526 operand oprs
[3]; /* the operands, defined as above */
527 extop
*eops
; /* extended operands */
528 int eops_float
; /* true if DD and floating */
529 long times
; /* repeat count (TIMES prefix) */
530 int forw_ref
; /* is there a forward reference? */
533 enum geninfo
{ GI_SWITCH
};
535 * ------------------------------------------------------------
536 * The data structure defining an output format driver, and the
537 * interfaces to the functions therein.
538 * ------------------------------------------------------------
543 * This is a short (one-liner) description of the type of
544 * output generated by the driver.
549 * This is a single keyword used to select the driver.
554 * this is reserved for out module specific help.
555 * It is set to NULL in all the out modules but is not implemented
556 * in the main program
561 * this is a pointer to the first element of the debug information
563 struct dfmt
**debug_formats
;
566 * and a pointer to the element that is being used
567 * note: this is set to the default at compile time and changed if the
568 * -F option is selected. If developing a set of new debug formats for
569 * an output format, be sure to set this to whatever default you want
572 struct dfmt
*current_dfmt
;
575 * This, if non-NULL, is a NULL-terminated list of `char *'s
576 * pointing to extra standard macros supplied by the object
577 * format (e.g. a sensible initial default value of __SECT__,
578 * and user-level equivalents for any format-specific
584 * This procedure is called at the start of an output session.
585 * It tells the output format what file it will be writing to,
586 * what routine to report errors through, and how to interface
587 * to the label manager and expression evaluator if necessary.
588 * It also gives it a chance to do other initialisation.
590 void (*init
) (FILE *fp
, efunc error
, ldfunc ldef
, evalfunc eval
);
593 * This procedure is called to pass generic information to the
594 * object file. The first parameter gives the information type
595 * (currently only command line switches)
596 * and the second parameter gives the value. This function returns
597 * 1 if recognized, 0 if unrecognized
599 int (*setinfo
)(enum geninfo type
, char **string
);
602 * This procedure is called by assemble() to write actual
603 * generated code or data to the object file. Typically it
604 * doesn't have to actually _write_ it, just store it for
607 * The `type' argument specifies the type of output data, and
608 * usually the size as well: its contents are described below.
610 void (*output
) (long segto
, void *data
, unsigned long type
,
611 long segment
, long wrt
);
614 * This procedure is called once for every symbol defined in
615 * the module being assembled. It gives the name and value of
616 * the symbol, in NASM's terms, and indicates whether it has
617 * been declared to be global. Note that the parameter "name",
618 * when passed, will point to a piece of static storage
619 * allocated inside the label manager - it's safe to keep using
620 * that pointer, because the label manager doesn't clean up
621 * until after the output driver has.
623 * Values of `is_global' are: 0 means the symbol is local; 1
624 * means the symbol is global; 2 means the symbol is common (in
625 * which case `offset' holds the _size_ of the variable).
626 * Anything else is available for the output driver to use
629 * This routine explicitly _is_ allowed to call the label
630 * manager to define further symbols, if it wants to, even
631 * though it's been called _from_ the label manager. That much
632 * re-entrancy is guaranteed in the label manager. However, the
633 * label manager will in turn call this routine, so it should
634 * be prepared to be re-entrant itself.
636 * The `special' parameter contains special information passed
637 * through from the command that defined the label: it may have
638 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
639 * be obvious to the output format from the other parameters.
641 void (*symdef
) (char *name
, long segment
, long offset
, int is_global
,
645 * This procedure is called when the source code requests a
646 * segment change. It should return the corresponding segment
647 * _number_ for the name, or NO_SEG if the name is not a valid
650 * It may also be called with NULL, in which case it is to
651 * return the _default_ section number for starting assembly in.
653 * It is allowed to modify the string it is given a pointer to.
655 * It is also allowed to specify a default instruction size for
656 * the segment, by setting `*bits' to 16 or 32. Or, if it
657 * doesn't wish to define a default, it can leave `bits' alone.
659 long (*section
) (char *name
, int pass
, int *bits
);
662 * This procedure is called to modify the segment base values
663 * returned from the SEG operator. It is given a segment base
664 * value (i.e. a segment value with the low bit set), and is
665 * required to produce in return a segment value which may be
666 * different. It can map segment bases to absolute numbers by
667 * means of returning SEG_ABS types.
669 * It should return NO_SEG if the segment base cannot be
670 * determined; the evaluator (which calls this routine) is
671 * responsible for throwing an error condition if that occurs
672 * in pass two or in a critical expression.
674 long (*segbase
) (long segment
);
677 * This procedure is called to allow the output driver to
678 * process its own specific directives. When called, it has the
679 * directive word in `directive' and the parameter string in
680 * `value'. It is called in both assembly passes, and `pass'
681 * will be either 1 or 2.
683 * This procedure should return zero if it does not _recognise_
684 * the directive, so that the main program can report an error.
685 * If it recognises the directive but then has its own errors,
686 * it should report them itself and then return non-zero. It
687 * should also return non-zero if it correctly processes the
690 int (*directive
) (char *directive
, char *value
, int pass
);
693 * This procedure is called before anything else - even before
694 * the "init" routine - and is passed the name of the input
695 * file from which this output file is being generated. It
696 * should return its preferred name for the output file in
697 * `outname', if outname[0] is not '\0', and do nothing to
698 * `outname' otherwise. Since it is called before the driver is
699 * properly initialised, it has to be passed its error handler
702 * This procedure may also take its own copy of the input file
703 * name for use in writing the output file: it is _guaranteed_
704 * that it will be called before the "init" routine.
706 * The parameter `outname' points to an area of storage
707 * guaranteed to be at least FILENAME_MAX in size.
709 void (*filename
) (char *inname
, char *outname
, efunc error
);
712 * This procedure is called after assembly finishes, to allow
713 * the output driver to clean itself up and free its memory.
714 * Typically, it will also be the point at which the object
715 * file actually gets _written_.
717 * One thing the cleanup routine should always do is to close
718 * the output file pointer.
720 void (*cleanup
) (int debuginfo
);
724 * values for the `type' parameter to an output function. Each one
725 * must have the actual number of _bytes_ added to it.
727 * Exceptions are OUT_RELxADR, which denote an x-byte relocation
728 * which will be a relative jump. For this we need to know the
729 * distance in bytes from the start of the relocated record until
730 * the end of the containing instruction. _This_ is what is stored
731 * in the size part of the parameter, in this case.
733 * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
734 * and the contents of the "data" parameter is irrelevant.
736 * The "data" parameter for the output function points to a "long",
737 * containing the address in question, unless the type is
738 * OUT_RAWDATA, in which case it points to an "unsigned char"
741 #define OUT_RAWDATA 0x00000000UL
742 #define OUT_ADDRESS 0x10000000UL
743 #define OUT_REL2ADR 0x20000000UL
744 #define OUT_REL4ADR 0x30000000UL
745 #define OUT_RESERVE 0x40000000UL
746 #define OUT_TYPMASK 0xF0000000UL
747 #define OUT_SIZMASK 0x0FFFFFFFUL
750 * ------------------------------------------------------------
751 * The data structure defining a debug format driver, and the
752 * interfaces to the functions therein.
753 * ------------------------------------------------------------
759 * This is a short (one-liner) description of the type of
760 * output generated by the driver.
765 * This is a single keyword used to select the driver.
771 * init - called initially to set up local pointer to object format,
772 * void pointer to implementation defined data, file pointer (which
773 * probably won't be used, but who knows?), and error function.
775 void (*init
) (struct ofmt
* of
, void * id
, FILE * fp
, efunc error
);
778 * linenum - called any time there is output with a change of
779 * line number or file.
781 void (*linenum
) (const char * filename
, long linenumber
, long segto
);
784 * debug_deflabel - called whenever a label is defined. Parameters
785 * are the same as to 'symdef()' in the output format. This function
786 * would be called before the output format version.
789 void (*debug_deflabel
) (char * name
, long segment
, long offset
,
790 int is_global
, char * special
);
792 * debug_directive - called whenever a DEBUG directive other than 'LINE'
793 * is encountered. 'directive' contains the first parameter to the
794 * DEBUG directive, and params contains the rest. For example,
795 * 'DEBUG VAR _somevar:int' would translate to a call to this
796 * function with 'directive' equal to "VAR" and 'params' equal to
799 void (*debug_directive
) (const char * directive
, const char * params
);
802 * typevalue - called whenever the assembler wishes to register a type
803 * for the last defined label. This routine MUST detect if a type was
804 * already registered and not re-register it.
806 void (*debug_typevalue
) (long type
);
809 * debug_output - called whenever output is required
810 * 'type' is the type of info required, and this is format-specific
812 void (*debug_output
) (int type
, void *param
);
815 * cleanup - called after processing of file is complete
817 void (*cleanup
) (void);
821 * The type definition macros
824 * low 3 bits: reserved
826 * next 24 bits: number of elements for arrays (0 for labels)
829 #define TY_UNKNOWN 0x00
830 #define TY_LABEL 0x08
833 #define TY_DWORD 0x20
834 #define TY_FLOAT 0x28
835 #define TY_QWORD 0x30
836 #define TY_TBYTE 0x38
837 #define TY_COMMON 0xE0
839 #define TY_EXTERN 0xF0
842 #define TYM_TYPE(x) ((x) & 0xF8)
843 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
845 #define TYS_ELEMENTS(x) ((x) << 8)
853 * This is a useful #define which I keep meaning to use more often:
854 * the number of elements of a statically defined array.
857 #define elements(x) ( sizeof(x) / sizeof(*(x)) )
859 extern int tasm_compatible_mode
;
862 * This declaration passes the "pass" number to all other modules
863 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
864 * where 0 = optimizing pass
869 extern int pass0
; /* this is globally known */
870 extern int optimizing
;