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
16 #include "version.h" /* generated NASM version macros */
19 #include "insnsi.h" /* For enum opcode */
26 #define FALSE 0 /* comes in handy */
32 #define NO_SEG -1L /* null segment value */
33 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
36 #define FILENAME_MAX 256
44 #define POSTFIX_MAX 10
47 #define IDLEN_MAX 4096
50 * Name pollution problems: <time.h> on Digital UNIX pulls in some
51 * strange hardware header file which sees fit to define R_SP. We
52 * undefine it here so as not to break the enum below.
59 * We must declare the existence of this structure type up here,
60 * since we have to reference it before we define it...
65 * -----------------------
66 * Other function typedefs
67 * -----------------------
71 * A label-lookup function should look like this.
73 typedef int (*lfunc
) (char *label
, int32_t *segment
, int32_t *offset
);
76 * And a label-definition function like this. The boolean parameter
77 * `is_norm' states whether the label is a `normal' label (which
78 * should affect the local-label system), or something odder like
79 * an EQU or a segment-base symbol, which shouldn't.
81 typedef void (*ldfunc
) (char *label
, int32_t segment
, int32_t offset
,
82 char *special
, int is_norm
, int isextrn
,
83 struct ofmt
* ofmt
, efunc error
);
86 * List-file generators should look like this:
90 * Called to initialize the listing file generator. Before this
91 * is called, the other routines will silently do nothing when
92 * called. The `char *' parameter is the file name to write the
95 void (*init
) (char *, efunc
);
98 * Called to clear stuff up and close the listing file.
100 void (*cleanup
) (void);
103 * Called to output binary data. Parameters are: the offset;
104 * the data; the data type. Data types are similar to the
105 * output-format interface, only OUT_ADDRESS will _always_ be
106 * displayed as if it's relocatable, so ensure that any non-
107 * relocatable address has been converted to OUT_RAWDATA by
108 * then. Note that OUT_RAWDATA+0 is a valid data type, and is a
109 * dummy call used to give the listing generator an offset to
110 * work with when doing things like uplevel(LIST_TIMES) or
111 * uplevel(LIST_INCBIN).
113 void (*output
) (int32_t, const void *, uint32_t);
116 * Called to send a text line to the listing generator. The
117 * `int' parameter is LIST_READ or LIST_MACRO depending on
118 * whether the line came directly from an input file or is the
119 * result of a multi-line macro expansion.
121 void (*line
) (int, char *);
124 * Called to change one of the various levelled mechanisms in
125 * the listing generator. LIST_INCLUDE and LIST_MACRO can be
126 * used to increase the nesting level of include files and
127 * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
128 * two binary-output-suppression mechanisms for large-scale
129 * pseudo-instructions.
131 * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
132 * it indicates the beginning of the expansion of a `nolist'
133 * macro, so anything under that level won't be expanded unless
134 * it includes another file.
136 void (*uplevel
) (int);
139 * Reverse the effects of uplevel.
141 void (*downlevel
) (int);
145 * The expression evaluator must be passed a scanner function; a
146 * standard scanner is provided as part of nasmlib.c. The
147 * preprocessor will use a different one. Scanners, and the
148 * token-value structures they return, look like this.
150 * The return value from the scanner is always a copy of the
151 * `t_type' field in the structure.
155 int64_t t_integer
, t_inttwo
;
158 typedef int (*scanner
) (void *private_data
, struct tokenval
* tv
);
161 * Token types returned by the scanner, in addition to ordinary
162 * ASCII character values, and zero for end-of-string.
164 enum { /* token types, other than chars */
165 TOKEN_INVALID
= -1, /* a placeholder value */
166 TOKEN_EOS
= 0, /* end of string */
167 TOKEN_EQ
= '=', TOKEN_GT
= '>', TOKEN_LT
= '<', /* aliases */
168 TOKEN_ID
= 256, TOKEN_NUM
, TOKEN_REG
, TOKEN_INSN
, /* major token types */
169 TOKEN_ERRNUM
, /* numeric constant with error in */
170 TOKEN_HERE
, TOKEN_BASE
, /* $ and $$ */
171 TOKEN_SPECIAL
, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
172 TOKEN_PREFIX
, /* A32, O16, LOCK, REPNZ, TIMES, etc */
173 TOKEN_SHL
, TOKEN_SHR
, /* << and >> */
174 TOKEN_SDIV
, TOKEN_SMOD
, /* // and %% */
175 TOKEN_GE
, TOKEN_LE
, TOKEN_NE
, /* >=, <= and <> (!= is same as <>) */
176 TOKEN_DBL_AND
, TOKEN_DBL_OR
, TOKEN_DBL_XOR
, /* &&, || and ^^ */
177 TOKEN_SEG
, TOKEN_WRT
, /* SEG and WRT */
178 TOKEN_FLOAT
, /* floating-point constant */
179 TOKEN_FLOATIZE
, /* __floatX__ */
199 * Expression-evaluator datatype. Expressions, within the
200 * evaluator, are stored as an array of these beasts, terminated by
201 * a record with type==0. Mostly, it's a vector type: each type
202 * denotes some kind of a component, and the value denotes the
203 * multiple of that component present in the expression. The
204 * exception is the WRT type, whose `value' field denotes the
205 * segment to which the expression is relative. These segments will
206 * be segment-base types, i.e. either odd segment values or SEG_ABS
207 * types. So it is still valid to assume that anything with a
208 * `value' field of zero is insignificant.
211 int32_t type
; /* a register, or EXPR_xxx */
212 int64_t value
; /* must be >= 32 bits */
216 * Library routines to manipulate expression data types.
218 int is_reloc(expr
*);
219 int is_simple(expr
*);
220 int is_really_simple(expr
*);
221 int is_unknown(expr
*);
222 int is_just_unknown(expr
*);
223 int64_t reloc_value(expr
*);
224 int32_t reloc_seg(expr
*);
225 int32_t reloc_wrt(expr
*);
228 * The evaluator can also return hints about which of two registers
229 * used in an expression should be the base register. See also the
230 * `operand' structure.
238 * The actual expression evaluator function looks like this. When
239 * called, it expects the first token of its expression to already
240 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
241 * it will start by calling the scanner.
243 * If a forward reference happens during evaluation, the evaluator
244 * must set `*fwref' to TRUE if `fwref' is non-NULL.
246 * `critical' is non-zero if the expression may not contain forward
247 * references. The evaluator will report its own error if this
248 * occurs; if `critical' is 1, the error will be "symbol not
249 * defined before use", whereas if `critical' is 2, the error will
250 * be "symbol undefined".
252 * If `critical' has bit 8 set (in addition to its main value: 0x101
253 * and 0x102 correspond to 1 and 2) then an extended expression
254 * syntax is recognised, in which relational operators such as =, <
255 * and >= are accepted, as well as low-precedence logical operators
258 * If `hints' is non-NULL, it gets filled in with some hints as to
259 * the base register in complex effective addresses.
261 #define CRITICAL 0x100
262 typedef expr
*(*evalfunc
) (scanner sc
, void *scprivate
,
263 struct tokenval
* tv
, int *fwref
, int critical
,
264 efunc error
, struct eval_hints
* hints
);
267 * Special values for expr->type. These come after EXPR_REG_END
268 * as defined in regs.h.
271 #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */
272 #define EXPR_SIMPLE (EXPR_REG_END+2)
273 #define EXPR_WRT (EXPR_REG_END+3)
274 #define EXPR_SEGBASE (EXPR_REG_END+4)
277 * Preprocessors ought to look like this:
279 typedef struct preproc_ops
{
281 * Called at the start of a pass; given a file name, the number
282 * of the pass, an error reporting function, an evaluator
283 * function, and a listing generator to talk to.
285 void (*reset
) (char *, int, efunc
, evalfunc
, ListGen
*);
288 * Called to fetch a line of preprocessed source. The line
289 * returned has been malloc'ed, and so should be freed after
292 char *(*getline
) (void);
295 * Called at the end of a pass.
297 void (*cleanup
) (int);
300 extern Preproc nasmpp
;
303 * ----------------------------------------------------------------
304 * Some lexical properties of the NASM source language, included
305 * here because they are shared between the parser and preprocessor
306 * ----------------------------------------------------------------
310 * isidstart matches any character that may start an identifier, and isidchar
311 * matches any character that may appear at places other than the start of an
312 * identifier. E.g. a period may only appear at the start of an identifier
313 * (for local labels), whereas a number may appear anywhere *but* at the
317 #define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
319 #define isidchar(c) ( isidstart(c) || isdigit(c) || (c)=='$' || (c)=='#' \
322 /* Ditto for numeric constants. */
324 #define isnumstart(c) ( isdigit(c) || (c)=='$' )
325 #define isnumchar(c) ( isalnum(c) )
327 /* This returns the numeric value of a given 'digit'. */
329 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
332 * Data-type flags that get passed to listing-file routines.
335 LIST_READ
, LIST_MACRO
, LIST_MACRO_NOLIST
, LIST_INCLUDE
,
336 LIST_INCBIN
, LIST_TIMES
340 * -----------------------------------------------------------
341 * Format of the `insn' structure returned from `parser.c' and
342 * passed into `assemble.c'
343 * -----------------------------------------------------------
347 * Here we define the operand types. These are implemented as bit
348 * masks, since some are subsets of others; e.g. AX in a MOV
349 * instruction is a special operand type, whereas AX in other
350 * contexts is just another 16-bit register. (Also, consider CL in
351 * shift instructions, DX in OUT, etc.)
353 * The basic concept here is that
354 * (class & ~operand) == 0
356 * if and only if "operand" belongs to class type "class".
358 * The bits are assigned as follows:
360 * Bits 0-7, 29: sizes
369 * 29: 128 bits (OWORD)
371 * Bits 8-11 modifiers
377 * Bits 12-15: type of operand
380 * 14: MEMORY (always has REGMEM attribute as well)
381 * 15: REGMEM (valid EA operand)
383 * Bits 16-19: subclasses
390 * 16: REG_ACCUM (AL, AX, EAX, RAX)
391 * 17: REG_COUNT (CL, CX, ECX, RCX)
392 * 18: REG_DATA (DL, DX, EDX, RDX)
393 * 19: REG_HIGH (AH, CH, DH, BH)
397 * 17: REG_DESS (DS, ES, SS)
408 * 16: MEM_OFFS (this is a simple offset)
409 * 17: IP_REL (IP-relative offset)
413 * 17: BYTENESS (-128..127)
415 * Bits 20-26: register classes
416 * 20: REG_CDT (CRx, DRx, TRx)
417 * 21: RM_GPR (REG_GPR) (integer register)
419 * 23: IP_REG (RIP or EIP) [unused]
421 * 25: RM_MMX (MMXREG)
422 * 26: RM_XMM (XMMREG)
424 * Bits 27-29 & 31 are currently unallocated.
427 * Special flag only used in instruction patterns; means this operand
428 * has to be identical to another operand. Currently only supported
432 typedef uint32_t opflags_t
;
434 /* Size, and other attributes, of the operand */
435 #define BITS8 0x00000001L
436 #define BITS16 0x00000002L
437 #define BITS32 0x00000004L
438 #define BITS64 0x00000008L /* x64 and FPU only */
439 #define BITS80 0x00000010L /* FPU only */
440 #define BITS128 0x20000000L
441 #define FAR 0x00000020L /* grotty: this means 16:16 or */
442 /* 16:32, like in CALL/JMP */
443 #define NEAR 0x00000040L
444 #define SHORT 0x00000080L /* and this means what it says :) */
446 #define SIZE_MASK 0x200000FFL /* all the size attributes */
449 #define MODIFIER_MASK 0x00000f00L
450 #define TO 0x00000100L /* reverse effect in FADD, FSUB &c */
451 #define COLON 0x00000200L /* operand is followed by a colon */
452 #define STRICT 0x00000400L /* do not optimize this operand */
454 /* Type of operand: memory reference, register, etc. */
455 #define OPTYPE_MASK 0x0000f000L
456 #define REGISTER 0x00001000L /* register number in 'basereg' */
457 #define IMMEDIATE 0x00002000L
458 #define MEMORY 0x0000c000L
459 #define REGMEM 0x00008000L /* for r/m, ie EA, operands */
461 /* Register classes */
462 #define REG_EA 0x00009000L /* 'normal' reg, qualifies as EA */
463 #define RM_GPR 0x00208000L /* integer operand */
464 #define REG_GPR 0x00209000L /* integer register */
465 #define REG8 0x00209001L /* 8-bit GPR */
466 #define REG16 0x00209002L /* 16-bit GPR */
467 #define REG32 0x00209004L /* 32-bit GPR */
468 #define REG64 0x00209008L /* 64-bit GPR */
469 #define IP_REG 0x00801000L /* RIP or EIP register */
470 #define RIPREG 0x00801008L /* RIP */
471 #define EIPREG 0x00801004L /* EIP */
472 #define FPUREG 0x01001000L /* floating point stack registers */
473 #define FPU0 0x01011000L /* FPU stack register zero */
474 #define RM_MMX 0x02008000L /* MMX operand */
475 #define MMXREG 0x02009000L /* MMX register */
476 #define RM_XMM 0x04008000L /* XMM (SSE) operand */
477 #define XMMREG 0x04009000L /* XMM (SSE) register */
478 #define XMM0 0x04019000L /* XMM register zero */
479 #define REG_CDT 0x00101004L /* CRn, DRn and TRn */
480 #define REG_CREG 0x00111004L /* CRn */
481 #define REG_DREG 0x00121004L /* DRn */
482 #define REG_TREG 0x00141004L /* TRn */
483 #define REG_SREG 0x00401002L /* any segment register */
484 #define REG_CS 0x00411002L /* CS */
485 #define REG_DESS 0x00421002L /* DS, ES, SS */
486 #define REG_FSGS 0x00441002L /* FS, GS */
487 #define REG_SEG67 0x00481002L /* Unimplemented segment registers */
489 #define REG_RIP 0x00801008L /* RIP relative addressing */
490 #define REG_EIP 0x00801004L /* EIP relative addressing */
493 #define REG_SMASK 0x000f0000L /* a mask for the following */
494 #define REG_ACCUM 0x00219000L /* accumulator: AL, AX, EAX, RAX */
495 #define REG_AL 0x00219001L
496 #define REG_AX 0x00219002L
497 #define REG_EAX 0x00219004L
498 #define REG_RAX 0x00219008L
499 #define REG_COUNT 0x00229000L /* counter: CL, CX, ECX, RCX */
500 #define REG_CL 0x00229001L
501 #define REG_CX 0x00229002L
502 #define REG_ECX 0x00229004L
503 #define REG_RCX 0x00229008L
504 #define REG_DL 0x00249001L /* data: DL, DX, EDX, RDX */
505 #define REG_DX 0x00249002L
506 #define REG_EDX 0x00249004L
507 #define REG_RDX 0x00249008L
508 #define REG_HIGH 0x00289001L /* high regs: AH, CH, DH, BH */
510 /* special types of EAs */
511 #define MEM_OFFS 0x0001c000L /* simple [address] offset - absolute! */
512 #define IP_REL 0x0002c000L /* IP-relative offset */
514 /* memory which matches any type of r/m operand */
515 #define MEMORY_ANY (MEMORY|RM_GPR|RM_MMX|RM_XMM)
517 /* special type of immediate operand */
518 #define UNITY 0x00012000L /* for shift/rotate instructions */
519 #define SBYTE 0x00022000L /* for op r16/32,immediate instrs. */
522 #define SAME_AS 0x40000000L
524 /* Register names automatically generated from regs.dat */
527 enum ccode
{ /* condition code names */
528 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
529 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
530 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
,
537 #define REX_OC 0x0200 /* DREX suffix has the OC0 bit set */
538 #define REX_D 0x0100 /* Instruction uses DREX instead of REX */
539 #define REX_H 0x80 /* High register present, REX forbidden */
540 #define REX_P 0x40 /* REX prefix present/required */
541 #define REX_L 0x20 /* Use LOCK prefix instead of REX.R */
542 #define REX_W 0x08 /* 64-bit operand size */
543 #define REX_R 0x04 /* ModRM reg extension */
544 #define REX_X 0x02 /* SIB index extension */
545 #define REX_B 0x01 /* ModRM r/m extension */
546 #define REX_REAL 0x4f /* Actual REX prefix bits */
549 * Note that because segment registers may be used as instruction
550 * prefixes, we must ensure the enumerations for prefixes and
551 * register names do not overlap.
553 enum prefixes
{ /* instruction prefixes */
554 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
555 P_A16
= PREFIX_ENUM_START
, P_A32
, P_LOCK
, P_O16
, P_O32
,
556 P_REP
, P_REPE
, P_REPNE
, P_REPNZ
, P_REPZ
, P_TIMES
559 enum { /* extended operand types */
560 EOT_NOTHING
, EOT_DB_STRING
, EOT_DB_NUMBER
563 enum { /* special EA flags */
564 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
565 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
566 EAF_TIMESTWO
= 4, /* really do EAX*2 not EAX+EAX */
567 EAF_REL
= 8, /* IP-relative addressing */
568 EAF_ABS
= 16, /* non-IP-relative addressing */
569 EAF_FSGS
= 32 /* fs/gs segment override present */
572 enum eval_hint
{ /* values for `hinttype' */
573 EAH_NOHINT
= 0, /* no hint at all - our discretion */
574 EAH_MAKEBASE
= 1, /* try to make given reg the base */
575 EAH_NOTBASE
= 2 /* try _not_ to make reg the base */
578 typedef struct { /* operand to an instruction */
579 int32_t type
; /* type of operand */
580 int addr_size
; /* 0 means default; 16; 32; 64 */
581 enum reg_enum basereg
, indexreg
; /* address registers */
582 int scale
; /* index scale */
584 enum eval_hint hinttype
; /* hint as to real base register */
585 int32_t segment
; /* immediate segment, if needed */
586 int64_t offset
; /* any immediate number */
587 int32_t wrt
; /* segment base it's relative to */
588 int eaflags
; /* special EA flags */
589 int opflags
; /* see OPFLAG_* defines below */
592 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
593 #define OPFLAG_EXTERN 2 /* operand is an external reference */
595 typedef struct extop
{ /* extended operand */
596 struct extop
*next
; /* linked list */
597 int32_t type
; /* defined above */
598 char *stringval
; /* if it's a string, then here it is */
599 int stringlen
; /* ... and here's how long it is */
600 int32_t segment
; /* if it's a number/address, then... */
601 int64_t offset
; /* ... it's given here ... */
602 int32_t wrt
; /* ... and here */
606 #define MAX_OPERANDS 4
608 typedef struct { /* an instruction itself */
609 char *label
; /* the label defined, or NULL */
610 enum prefixes prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
611 int nprefix
; /* number of entries in above */
612 enum opcode opcode
; /* the opcode - not just the string */
613 enum ccode condition
; /* the condition code, if Jcc/SETcc */
614 int operands
; /* how many operands? 0-3
615 * (more if db et al) */
616 operand oprs
[MAX_OPERANDS
]; /* the operands, defined as above */
617 extop
*eops
; /* extended operands */
618 int eops_float
; /* true if DD and floating */
619 int32_t times
; /* repeat count (TIMES prefix) */
620 int forw_ref
; /* is there a forward reference? */
621 int rex
; /* Special REX Prefix */
622 int drexdst
; /* Destination register for DREX suffix */
625 enum geninfo
{ GI_SWITCH
};
627 * ------------------------------------------------------------
628 * The data structure defining an output format driver, and the
629 * interfaces to the functions therein.
630 * ------------------------------------------------------------
635 * This is a short (one-liner) description of the type of
636 * output generated by the driver.
638 const char *fullname
;
641 * This is a single keyword used to select the driver.
643 const char *shortname
;
647 * this is reserved for out module specific help.
648 * It is set to NULL in all the out modules and is not implemented
649 * in the main program
651 const char *helpstring
;
654 * this is a pointer to the first element of the debug information
656 struct dfmt
**debug_formats
;
659 * and a pointer to the element that is being used
660 * note: this is set to the default at compile time and changed if the
661 * -F option is selected. If developing a set of new debug formats for
662 * an output format, be sure to set this to whatever default you want
665 struct dfmt
*current_dfmt
;
668 * This, if non-NULL, is a NULL-terminated list of `char *'s
669 * pointing to extra standard macros supplied by the object
670 * format (e.g. a sensible initial default value of __SECT__,
671 * and user-level equivalents for any format-specific
677 * This procedure is called at the start of an output session.
678 * It tells the output format what file it will be writing to,
679 * what routine to report errors through, and how to interface
680 * to the label manager and expression evaluator if necessary.
681 * It also gives it a chance to do other initialisation.
683 void (*init
) (FILE * fp
, efunc error
, ldfunc ldef
, evalfunc eval
);
686 * This procedure is called to pass generic information to the
687 * object file. The first parameter gives the information type
688 * (currently only command line switches)
689 * and the second parameter gives the value. This function returns
690 * 1 if recognized, 0 if unrecognized
692 int (*setinfo
) (enum geninfo type
, char **string
);
695 * This procedure is called by assemble() to write actual
696 * generated code or data to the object file. Typically it
697 * doesn't have to actually _write_ it, just store it for
700 * The `type' argument specifies the type of output data, and
701 * usually the size as well: its contents are described below.
703 void (*output
) (int32_t segto
, const void *data
, uint32_t type
,
704 int32_t segment
, int32_t wrt
);
707 * This procedure is called once for every symbol defined in
708 * the module being assembled. It gives the name and value of
709 * the symbol, in NASM's terms, and indicates whether it has
710 * been declared to be global. Note that the parameter "name",
711 * when passed, will point to a piece of static storage
712 * allocated inside the label manager - it's safe to keep using
713 * that pointer, because the label manager doesn't clean up
714 * until after the output driver has.
716 * Values of `is_global' are: 0 means the symbol is local; 1
717 * means the symbol is global; 2 means the symbol is common (in
718 * which case `offset' holds the _size_ of the variable).
719 * Anything else is available for the output driver to use
722 * This routine explicitly _is_ allowed to call the label
723 * manager to define further symbols, if it wants to, even
724 * though it's been called _from_ the label manager. That much
725 * re-entrancy is guaranteed in the label manager. However, the
726 * label manager will in turn call this routine, so it should
727 * be prepared to be re-entrant itself.
729 * The `special' parameter contains special information passed
730 * through from the command that defined the label: it may have
731 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
732 * be obvious to the output format from the other parameters.
734 void (*symdef
) (char *name
, int32_t segment
, int32_t offset
, int is_global
,
738 * This procedure is called when the source code requests a
739 * segment change. It should return the corresponding segment
740 * _number_ for the name, or NO_SEG if the name is not a valid
743 * It may also be called with NULL, in which case it is to
744 * return the _default_ section number for starting assembly in.
746 * It is allowed to modify the string it is given a pointer to.
748 * It is also allowed to specify a default instruction size for
749 * the segment, by setting `*bits' to 16 or 32. Or, if it
750 * doesn't wish to define a default, it can leave `bits' alone.
752 int32_t (*section
) (char *name
, int pass
, int *bits
);
755 * This procedure is called to modify the segment base values
756 * returned from the SEG operator. It is given a segment base
757 * value (i.e. a segment value with the low bit set), and is
758 * required to produce in return a segment value which may be
759 * different. It can map segment bases to absolute numbers by
760 * means of returning SEG_ABS types.
762 * It should return NO_SEG if the segment base cannot be
763 * determined; the evaluator (which calls this routine) is
764 * responsible for throwing an error condition if that occurs
765 * in pass two or in a critical expression.
767 int32_t (*segbase
) (int32_t segment
);
770 * This procedure is called to allow the output driver to
771 * process its own specific directives. When called, it has the
772 * directive word in `directive' and the parameter string in
773 * `value'. It is called in both assembly passes, and `pass'
774 * will be either 1 or 2.
776 * This procedure should return zero if it does not _recognise_
777 * the directive, so that the main program can report an error.
778 * If it recognises the directive but then has its own errors,
779 * it should report them itself and then return non-zero. It
780 * should also return non-zero if it correctly processes the
783 int (*directive
) (char *directive
, char *value
, int pass
);
786 * This procedure is called before anything else - even before
787 * the "init" routine - and is passed the name of the input
788 * file from which this output file is being generated. It
789 * should return its preferred name for the output file in
790 * `outname', if outname[0] is not '\0', and do nothing to
791 * `outname' otherwise. Since it is called before the driver is
792 * properly initialized, it has to be passed its error handler
795 * This procedure may also take its own copy of the input file
796 * name for use in writing the output file: it is _guaranteed_
797 * that it will be called before the "init" routine.
799 * The parameter `outname' points to an area of storage
800 * guaranteed to be at least FILENAME_MAX in size.
802 void (*filename
) (char *inname
, char *outname
, efunc error
);
805 * This procedure is called after assembly finishes, to allow
806 * the output driver to clean itself up and free its memory.
807 * Typically, it will also be the point at which the object
808 * file actually gets _written_.
810 * One thing the cleanup routine should always do is to close
811 * the output file pointer.
813 void (*cleanup
) (int debuginfo
);
817 * values for the `type' parameter to an output function. Each one
818 * must have the actual number of _bytes_ added to it.
820 * Exceptions are OUT_RELxADR, which denote an x-byte relocation
821 * which will be a relative jump. For this we need to know the
822 * distance in bytes from the start of the relocated record until
823 * the end of the containing instruction. _This_ is what is stored
824 * in the size part of the parameter, in this case.
826 * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
827 * and the contents of the "data" parameter is irrelevant.
829 * The "data" parameter for the output function points to a "int32_t",
830 * containing the address in question, unless the type is
831 * OUT_RAWDATA, in which case it points to an "uint8_t"
834 #define OUT_RAWDATA 0x00000000UL
835 #define OUT_ADDRESS 0x10000000UL
836 #define OUT_REL2ADR 0x20000000UL
837 #define OUT_REL4ADR 0x30000000UL
838 #define OUT_RESERVE 0x40000000UL
839 #define OUT_TYPMASK 0xF0000000UL
840 #define OUT_SIZMASK 0x0FFFFFFFUL
843 * ------------------------------------------------------------
844 * The data structure defining a debug format driver, and the
845 * interfaces to the functions therein.
846 * ------------------------------------------------------------
852 * This is a short (one-liner) description of the type of
853 * output generated by the driver.
855 const char *fullname
;
858 * This is a single keyword used to select the driver.
860 const char *shortname
;
863 * init - called initially to set up local pointer to object format,
864 * void pointer to implementation defined data, file pointer (which
865 * probably won't be used, but who knows?), and error function.
867 void (*init
) (struct ofmt
* of
, void *id
, FILE * fp
, efunc error
);
870 * linenum - called any time there is output with a change of
871 * line number or file.
873 void (*linenum
) (const char *filename
, int32_t linenumber
, int32_t segto
);
876 * debug_deflabel - called whenever a label is defined. Parameters
877 * are the same as to 'symdef()' in the output format. This function
878 * would be called before the output format version.
881 void (*debug_deflabel
) (char *name
, int32_t segment
, int32_t offset
,
882 int is_global
, char *special
);
884 * debug_directive - called whenever a DEBUG directive other than 'LINE'
885 * is encountered. 'directive' contains the first parameter to the
886 * DEBUG directive, and params contains the rest. For example,
887 * 'DEBUG VAR _somevar:int' would translate to a call to this
888 * function with 'directive' equal to "VAR" and 'params' equal to
891 void (*debug_directive
) (const char *directive
, const char *params
);
894 * typevalue - called whenever the assembler wishes to register a type
895 * for the last defined label. This routine MUST detect if a type was
896 * already registered and not re-register it.
898 void (*debug_typevalue
) (int32_t type
);
901 * debug_output - called whenever output is required
902 * 'type' is the type of info required, and this is format-specific
904 void (*debug_output
) (int type
, void *param
);
907 * cleanup - called after processing of file is complete
909 void (*cleanup
) (void);
913 * The type definition macros
916 * low 3 bits: reserved
918 * next 24 bits: number of elements for arrays (0 for labels)
921 #define TY_UNKNOWN 0x00
922 #define TY_LABEL 0x08
925 #define TY_DWORD 0x20
926 #define TY_FLOAT 0x28
927 #define TY_QWORD 0x30
928 #define TY_TBYTE 0x38
929 #define TY_OWORD 0x40
930 #define TY_COMMON 0xE0
932 #define TY_EXTERN 0xF0
935 #define TYM_TYPE(x) ((x) & 0xF8)
936 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
938 #define TYS_ELEMENTS(x) ((x) << 8)
946 enum special_tokens
{
947 S_ABS
, S_BYTE
, S_DWORD
, S_FAR
, S_LONG
, S_NEAR
, S_NOSPLIT
,
948 S_OWORD
, S_QWORD
, S_REL
, S_SHORT
, S_STRICT
, S_TO
, S_TWORD
, S_WORD
958 * This is a useful #define which I keep meaning to use more often:
959 * the number of elements of a statically defined array.
962 #define elements(x) ( sizeof(x) / sizeof(*(x)) )
971 * This declaration passes the "pass" number to all other modules
972 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
973 * where 0 = optimizing pass
980 extern int tasm_compatible_mode
;
981 extern int optimizing
;
982 extern int globalbits
; /* 16, 32 or 64-bit mode */
983 extern int globalrel
; /* default to relative addressing? */
984 extern int maxbits
; /* max bits supported by output */