NASM 2.00rc3
[nasm.git] / nasm.h
blob3186f4f07e6bb0a63bf9193d3dbb24b615e8fe07
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
9 */
11 #ifndef NASM_NASM_H
12 #define NASM_NASM_H
14 #include "compiler.h"
16 #include <stdio.h>
17 #include <inttypes.h>
18 #include "version.h" /* generated NASM version macros */
19 #include "nasmlib.h"
20 #include "insnsi.h" /* For enum opcode */
22 #define NO_SEG -1L /* null segment value */
23 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
25 #ifndef FILENAME_MAX
26 #define FILENAME_MAX 256
27 #endif
29 #ifndef PREFIX_MAX
30 #define PREFIX_MAX 10
31 #endif
33 #ifndef POSTFIX_MAX
34 #define POSTFIX_MAX 10
35 #endif
37 #define IDLEN_MAX 4096
40 * Name pollution problems: <time.h> on Digital UNIX pulls in some
41 * strange hardware header file which sees fit to define R_SP. We
42 * undefine it here so as not to break the enum below.
44 #ifdef R_SP
45 #undef R_SP
46 #endif
49 * We must declare the existence of this structure type up here,
50 * since we have to reference it before we define it...
52 struct ofmt;
55 * values for the `type' parameter to an output function.
57 * Exceptions are OUT_RELxADR, which denote an x-byte relocation
58 * which will be a relative jump. For this we need to know the
59 * distance in bytes from the start of the relocated record until
60 * the end of the containing instruction. _This_ is what is stored
61 * in the size part of the parameter, in this case.
63 * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
64 * and the contents of the "data" parameter is irrelevant.
66 * The "data" parameter for the output function points to a "int32_t",
67 * containing the address in question, unless the type is
68 * OUT_RAWDATA, in which case it points to an "uint8_t"
69 * array.
71 enum out_type {
72 OUT_RAWDATA, /* Plain bytes */
73 OUT_ADDRESS, /* An address (symbol value) */
74 OUT_RESERVE, /* Reserved bytes (RESB et al) */
75 OUT_REL2ADR, /* 2-byte relative address */
76 OUT_REL4ADR, /* 4-byte relative address */
77 OUT_REL8ADR, /* 8-byte relative address */
81 * -----------------------
82 * Other function typedefs
83 * -----------------------
87 * A label-lookup function should look like this.
89 typedef bool (*lfunc) (char *label, int32_t *segment, int64_t *offset);
92 * And a label-definition function like this. The boolean parameter
93 * `is_norm' states whether the label is a `normal' label (which
94 * should affect the local-label system), or something odder like
95 * an EQU or a segment-base symbol, which shouldn't.
97 typedef void (*ldfunc) (char *label, int32_t segment, int64_t offset,
98 char *special, bool is_norm, bool isextrn,
99 struct ofmt * ofmt, efunc error);
102 * List-file generators should look like this:
104 typedef struct {
106 * Called to initialize the listing file generator. Before this
107 * is called, the other routines will silently do nothing when
108 * called. The `char *' parameter is the file name to write the
109 * listing to.
111 void (*init) (char *, efunc);
114 * Called to clear stuff up and close the listing file.
116 void (*cleanup) (void);
119 * Called to output binary data. Parameters are: the offset;
120 * the data; the data type. Data types are similar to the
121 * output-format interface, only OUT_ADDRESS will _always_ be
122 * displayed as if it's relocatable, so ensure that any non-
123 * relocatable address has been converted to OUT_RAWDATA by
124 * then. Note that OUT_RAWDATA,0 is a valid data type, and is a
125 * dummy call used to give the listing generator an offset to
126 * work with when doing things like uplevel(LIST_TIMES) or
127 * uplevel(LIST_INCBIN).
129 void (*output) (int32_t, const void *, enum out_type, uint64_t);
132 * Called to send a text line to the listing generator. The
133 * `int' parameter is LIST_READ or LIST_MACRO depending on
134 * whether the line came directly from an input file or is the
135 * result of a multi-line macro expansion.
137 void (*line) (int, char *);
140 * Called to change one of the various levelled mechanisms in
141 * the listing generator. LIST_INCLUDE and LIST_MACRO can be
142 * used to increase the nesting level of include files and
143 * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
144 * two binary-output-suppression mechanisms for large-scale
145 * pseudo-instructions.
147 * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
148 * it indicates the beginning of the expansion of a `nolist'
149 * macro, so anything under that level won't be expanded unless
150 * it includes another file.
152 void (*uplevel) (int);
155 * Reverse the effects of uplevel.
157 void (*downlevel) (int);
158 } ListGen;
161 * The expression evaluator must be passed a scanner function; a
162 * standard scanner is provided as part of nasmlib.c. The
163 * preprocessor will use a different one. Scanners, and the
164 * token-value structures they return, look like this.
166 * The return value from the scanner is always a copy of the
167 * `t_type' field in the structure.
169 struct tokenval {
170 int t_type;
171 int64_t t_integer, t_inttwo;
172 char *t_charptr;
174 typedef int (*scanner) (void *private_data, struct tokenval * tv);
177 * Token types returned by the scanner, in addition to ordinary
178 * ASCII character values, and zero for end-of-string.
180 enum { /* token types, other than chars */
181 TOKEN_INVALID = -1, /* a placeholder value */
182 TOKEN_EOS = 0, /* end of string */
183 TOKEN_EQ = '=', TOKEN_GT = '>', TOKEN_LT = '<', /* aliases */
184 TOKEN_ID = 256, TOKEN_NUM, TOKEN_REG, TOKEN_INSN, /* major token types */
185 TOKEN_ERRNUM, /* numeric constant with error in */
186 TOKEN_HERE, TOKEN_BASE, /* $ and $$ */
187 TOKEN_SPECIAL, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
188 TOKEN_PREFIX, /* A32, O16, LOCK, REPNZ, TIMES, etc */
189 TOKEN_SHL, TOKEN_SHR, /* << and >> */
190 TOKEN_SDIV, TOKEN_SMOD, /* // and %% */
191 TOKEN_GE, TOKEN_LE, TOKEN_NE, /* >=, <= and <> (!= is same as <>) */
192 TOKEN_DBL_AND, TOKEN_DBL_OR, TOKEN_DBL_XOR, /* &&, || and ^^ */
193 TOKEN_SEG, TOKEN_WRT, /* SEG and WRT */
194 TOKEN_FLOAT, /* floating-point constant */
195 TOKEN_FLOATIZE, /* __floatX__ */
198 enum floatize {
199 FLOAT_8,
200 FLOAT_16,
201 FLOAT_32,
202 FLOAT_64,
203 FLOAT_80M,
204 FLOAT_80E,
205 FLOAT_128L,
206 FLOAT_128H,
209 struct location {
210 int64_t offset;
211 int32_t segment;
212 int known;
216 * Expression-evaluator datatype. Expressions, within the
217 * evaluator, are stored as an array of these beasts, terminated by
218 * a record with type==0. Mostly, it's a vector type: each type
219 * denotes some kind of a component, and the value denotes the
220 * multiple of that component present in the expression. The
221 * exception is the WRT type, whose `value' field denotes the
222 * segment to which the expression is relative. These segments will
223 * be segment-base types, i.e. either odd segment values or SEG_ABS
224 * types. So it is still valid to assume that anything with a
225 * `value' field of zero is insignificant.
227 typedef struct {
228 int32_t type; /* a register, or EXPR_xxx */
229 int64_t value; /* must be >= 32 bits */
230 } expr;
233 * Library routines to manipulate expression data types.
235 int is_reloc(expr *);
236 int is_simple(expr *);
237 int is_really_simple(expr *);
238 int is_unknown(expr *);
239 int is_just_unknown(expr *);
240 int64_t reloc_value(expr *);
241 int32_t reloc_seg(expr *);
242 int32_t reloc_wrt(expr *);
245 * The evaluator can also return hints about which of two registers
246 * used in an expression should be the base register. See also the
247 * `operand' structure.
249 struct eval_hints {
250 int64_t base;
251 int type;
255 * The actual expression evaluator function looks like this. When
256 * called, it expects the first token of its expression to already
257 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
258 * it will start by calling the scanner.
260 * If a forward reference happens during evaluation, the evaluator
261 * must set `*fwref' to true if `fwref' is non-NULL.
263 * `critical' is non-zero if the expression may not contain forward
264 * references. The evaluator will report its own error if this
265 * occurs; if `critical' is 1, the error will be "symbol not
266 * defined before use", whereas if `critical' is 2, the error will
267 * be "symbol undefined".
269 * If `critical' has bit 8 set (in addition to its main value: 0x101
270 * and 0x102 correspond to 1 and 2) then an extended expression
271 * syntax is recognised, in which relational operators such as =, <
272 * and >= are accepted, as well as low-precedence logical operators
273 * &&, ^^ and ||.
275 * If `hints' is non-NULL, it gets filled in with some hints as to
276 * the base register in complex effective addresses.
278 #define CRITICAL 0x100
279 typedef expr *(*evalfunc) (scanner sc, void *scprivate,
280 struct tokenval * tv, int *fwref, int critical,
281 efunc error, struct eval_hints * hints);
284 * Special values for expr->type. These come after EXPR_REG_END
285 * as defined in regs.h.
288 #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */
289 #define EXPR_SIMPLE (EXPR_REG_END+2)
290 #define EXPR_WRT (EXPR_REG_END+3)
291 #define EXPR_SEGBASE (EXPR_REG_END+4)
294 * Preprocessors ought to look like this:
296 typedef struct preproc_ops {
298 * Called at the start of a pass; given a file name, the number
299 * of the pass, an error reporting function, an evaluator
300 * function, and a listing generator to talk to.
302 void (*reset) (char *, int, efunc, evalfunc, ListGen *);
305 * Called to fetch a line of preprocessed source. The line
306 * returned has been malloc'ed, and so should be freed after
307 * use.
309 char *(*getline) (void);
312 * Called at the end of a pass.
314 void (*cleanup) (int);
315 } Preproc;
317 extern Preproc nasmpp;
320 * ----------------------------------------------------------------
321 * Some lexical properties of the NASM source language, included
322 * here because they are shared between the parser and preprocessor
323 * ----------------------------------------------------------------
327 * isidstart matches any character that may start an identifier, and isidchar
328 * matches any character that may appear at places other than the start of an
329 * identifier. E.g. a period may only appear at the start of an identifier
330 * (for local labels), whereas a number may appear anywhere *but* at the
331 * start.
334 #define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
335 || (c)=='@' )
336 #define isidchar(c) ( isidstart(c) || isdigit(c) || (c)=='$' || (c)=='#' \
337 || (c)=='~' )
339 /* Ditto for numeric constants. */
341 #define isnumstart(c) ( isdigit(c) || (c)=='$' )
342 #define isnumchar(c) ( isalnum(c) || (c)=='_' )
344 /* This returns the numeric value of a given 'digit'. */
346 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
349 * Data-type flags that get passed to listing-file routines.
351 enum {
352 LIST_READ, LIST_MACRO, LIST_MACRO_NOLIST, LIST_INCLUDE,
353 LIST_INCBIN, LIST_TIMES
357 * -----------------------------------------------------------
358 * Format of the `insn' structure returned from `parser.c' and
359 * passed into `assemble.c'
360 * -----------------------------------------------------------
364 * Here we define the operand types. These are implemented as bit
365 * masks, since some are subsets of others; e.g. AX in a MOV
366 * instruction is a special operand type, whereas AX in other
367 * contexts is just another 16-bit register. (Also, consider CL in
368 * shift instructions, DX in OUT, etc.)
370 * The basic concept here is that
371 * (class & ~operand) == 0
373 * if and only if "operand" belongs to class type "class".
375 * The bits are assigned as follows:
377 * Bits 0-7, 29: sizes
378 * 0: 8 bits (BYTE)
379 * 1: 16 bits (WORD)
380 * 2: 32 bits (DWORD)
381 * 3: 64 bits (QWORD)
382 * 4: 80 bits (TWORD)
383 * 5: FAR
384 * 6: NEAR
385 * 7: SHORT
386 * 29: 128 bits (OWORD)
388 * Bits 8-11 modifiers
389 * 8: TO
390 * 9: COLON
391 * 10: STRICT
392 * 11: (reserved)
394 * Bits 12-15: type of operand
395 * 12: REGISTER
396 * 13: IMMEDIATE
397 * 14: MEMORY (always has REGMEM attribute as well)
398 * 15: REGMEM (valid EA operand)
400 * Bits 16-19, 28: subclasses
401 * With REG_CDT:
402 * 16: REG_CREG (CRx)
403 * 17: REG_DREG (DRx)
404 * 18: REG_TREG (TRx)
406 * With REG_GPR:
407 * 16: REG_ACCUM (AL, AX, EAX, RAX)
408 * 17: REG_COUNT (CL, CX, ECX, RCX)
409 * 18: REG_DATA (DL, DX, EDX, RDX)
410 * 19: REG_HIGH (AH, CH, DH, BH)
411 * 28: REG_NOTACC (not REG_ACCUM)
413 * With REG_SREG:
414 * 16: REG_CS
415 * 17: REG_DESS (DS, ES, SS)
416 * 18: REG_FSGS
417 * 19: REG_SEG67
419 * With FPUREG:
420 * 16: FPU0
422 * With XMMREG:
423 * 16: XMM0
425 * With MEMORY:
426 * 16: MEM_OFFS (this is a simple offset)
427 * 17: IP_REL (IP-relative offset)
429 * With IMMEDIATE:
430 * 16: UNITY (1)
431 * 17: BYTENESS (-128..127)
433 * Bits 20-26: register classes
434 * 20: REG_CDT (CRx, DRx, TRx)
435 * 21: RM_GPR (REG_GPR) (integer register)
436 * 22: REG_SREG
437 * 23: IP_REG (RIP or EIP) [unused]
438 * 24: FPUREG
439 * 25: RM_MMX (MMXREG)
440 * 26: RM_XMM (XMMREG)
442 * Bits 27, 31 are currently unallocated.
444 * 30: SAME_AS
445 * Special flag only used in instruction patterns; means this operand
446 * has to be identical to another operand. Currently only supported
447 * for registers.
450 typedef uint32_t opflags_t;
452 /* Size, and other attributes, of the operand */
453 #define BITS8 0x00000001U
454 #define BITS16 0x00000002U
455 #define BITS32 0x00000004U
456 #define BITS64 0x00000008U /* x64 and FPU only */
457 #define BITS80 0x00000010U /* FPU only */
458 #define BITS128 0x20000000U
459 #define FAR 0x00000020U /* grotty: this means 16:16 or */
460 /* 16:32, like in CALL/JMP */
461 #define NEAR 0x00000040U
462 #define SHORT 0x00000080U /* and this means what it says :) */
464 #define SIZE_MASK 0x200000FFU /* all the size attributes */
466 /* Modifiers */
467 #define MODIFIER_MASK 0x00000f00U
468 #define TO 0x00000100U /* reverse effect in FADD, FSUB &c */
469 #define COLON 0x00000200U /* operand is followed by a colon */
470 #define STRICT 0x00000400U /* do not optimize this operand */
472 /* Type of operand: memory reference, register, etc. */
473 #define OPTYPE_MASK 0x0000f000U
474 #define REGISTER 0x00001000U /* register number in 'basereg' */
475 #define IMMEDIATE 0x00002000U
476 #define MEMORY 0x0000c000U
477 #define REGMEM 0x00008000U /* for r/m, ie EA, operands */
479 /* Register classes */
480 #define REG_EA 0x00009000U /* 'normal' reg, qualifies as EA */
481 #define RM_GPR 0x00208000U /* integer operand */
482 #define REG_GPR 0x00209000U /* integer register */
483 #define REG8 0x00209001U /* 8-bit GPR */
484 #define REG16 0x00209002U /* 16-bit GPR */
485 #define REG32 0x00209004U /* 32-bit GPR */
486 #define REG64 0x00209008U /* 64-bit GPR */
487 #define IP_REG 0x00801000U /* RIP or EIP register */
488 #define RIPREG 0x00801008U /* RIP */
489 #define EIPREG 0x00801004U /* EIP */
490 #define FPUREG 0x01001000U /* floating point stack registers */
491 #define FPU0 0x01011000U /* FPU stack register zero */
492 #define RM_MMX 0x02008000U /* MMX operand */
493 #define MMXREG 0x02009000U /* MMX register */
494 #define RM_XMM 0x04008000U /* XMM (SSE) operand */
495 #define XMMREG 0x04009000U /* XMM (SSE) register */
496 #define XMM0 0x04019000U /* XMM register zero */
497 #define REG_CDT 0x00101004U /* CRn, DRn and TRn */
498 #define REG_CREG 0x00111004U /* CRn */
499 #define REG_DREG 0x00121004U /* DRn */
500 #define REG_TREG 0x00141004U /* TRn */
501 #define REG_SREG 0x00401002U /* any segment register */
502 #define REG_CS 0x00411002U /* CS */
503 #define REG_DESS 0x00421002U /* DS, ES, SS */
504 #define REG_FSGS 0x00441002U /* FS, GS */
505 #define REG_SEG67 0x00481002U /* Unimplemented segment registers */
507 #define REG_RIP 0x00801008U /* RIP relative addressing */
508 #define REG_EIP 0x00801004U /* EIP relative addressing */
510 /* Special GPRs */
511 #define REG_SMASK 0x100f0000U /* a mask for the following */
512 #define REG_ACCUM 0x00219000U /* accumulator: AL, AX, EAX, RAX */
513 #define REG_AL 0x00219001U
514 #define REG_AX 0x00219002U
515 #define REG_EAX 0x00219004U
516 #define REG_RAX 0x00219008U
517 #define REG_COUNT 0x10229000U /* counter: CL, CX, ECX, RCX */
518 #define REG_CL 0x10229001U
519 #define REG_CX 0x10229002U
520 #define REG_ECX 0x10229004U
521 #define REG_RCX 0x10229008U
522 #define REG_DL 0x10249001U /* data: DL, DX, EDX, RDX */
523 #define REG_DX 0x10249002U
524 #define REG_EDX 0x10249004U
525 #define REG_RDX 0x10249008U
526 #define REG_HIGH 0x10289001U /* high regs: AH, CH, DH, BH */
527 #define REG_NOTACC 0x10000000U /* non-accumulator register */
528 #define REG8NA 0x10209001U /* 8-bit non-acc GPR */
529 #define REG16NA 0x10209002U /* 16-bit non-acc GPR */
530 #define REG32NA 0x10209004U /* 32-bit non-acc GPR */
531 #define REG64NA 0x10209008U /* 64-bit non-acc GPR */
533 /* special types of EAs */
534 #define MEM_OFFS 0x0001c000U /* simple [address] offset - absolute! */
535 #define IP_REL 0x0002c000U /* IP-relative offset */
537 /* memory which matches any type of r/m operand */
538 #define MEMORY_ANY (MEMORY|RM_GPR|RM_MMX|RM_XMM)
540 /* special type of immediate operand */
541 #define UNITY 0x00012000U /* for shift/rotate instructions */
542 #define SBYTE 0x00022000U /* for op r16/32,immediate instrs. */
544 /* special flags */
545 #define SAME_AS 0x40000000U
547 /* Register names automatically generated from regs.dat */
548 #include "regs.h"
550 enum ccode { /* condition code names */
551 C_A, C_AE, C_B, C_BE, C_C, C_E, C_G, C_GE, C_L, C_LE, C_NA, C_NAE,
552 C_NB, C_NBE, C_NC, C_NE, C_NG, C_NGE, C_NL, C_NLE, C_NO, C_NP,
553 C_NS, C_NZ, C_O, C_P, C_PE, C_PO, C_S, C_Z,
554 C_none = -1
558 * REX flags
560 #define REX_OC 0x0200 /* DREX suffix has the OC0 bit set */
561 #define REX_D 0x0100 /* Instruction uses DREX instead of REX */
562 #define REX_H 0x80 /* High register present, REX forbidden */
563 #define REX_P 0x40 /* REX prefix present/required */
564 #define REX_L 0x20 /* Use LOCK prefix instead of REX.R */
565 #define REX_W 0x08 /* 64-bit operand size */
566 #define REX_R 0x04 /* ModRM reg extension */
567 #define REX_X 0x02 /* SIB index extension */
568 #define REX_B 0x01 /* ModRM r/m extension */
569 #define REX_REAL 0x4f /* Actual REX prefix bits */
572 * Note that because segment registers may be used as instruction
573 * prefixes, we must ensure the enumerations for prefixes and
574 * register names do not overlap.
576 enum prefixes { /* instruction prefixes */
577 P_none = 0,
578 PREFIX_ENUM_START = REG_ENUM_LIMIT,
579 P_A16 = PREFIX_ENUM_START, P_A32, P_A64, P_ASP,
580 P_LOCK, P_O16, P_O32, P_O64, P_OSP,
581 P_REP, P_REPE, P_REPNE, P_REPNZ, P_REPZ, P_TIMES,
582 PREFIX_ENUM_LIMIT
585 enum { /* extended operand types */
586 EOT_NOTHING, EOT_DB_STRING, EOT_DB_NUMBER
589 enum { /* special EA flags */
590 EAF_BYTEOFFS = 1, /* force offset part to byte size */
591 EAF_WORDOFFS = 2, /* force offset part to [d]word size */
592 EAF_TIMESTWO = 4, /* really do EAX*2 not EAX+EAX */
593 EAF_REL = 8, /* IP-relative addressing */
594 EAF_ABS = 16, /* non-IP-relative addressing */
595 EAF_FSGS = 32 /* fs/gs segment override present */
598 enum eval_hint { /* values for `hinttype' */
599 EAH_NOHINT = 0, /* no hint at all - our discretion */
600 EAH_MAKEBASE = 1, /* try to make given reg the base */
601 EAH_NOTBASE = 2 /* try _not_ to make reg the base */
604 typedef struct operand { /* operand to an instruction */
605 int32_t type; /* type of operand */
606 int disp_size; /* 0 means default; 16; 32; 64 */
607 enum reg_enum basereg, indexreg; /* address registers */
608 int scale; /* index scale */
609 int hintbase;
610 enum eval_hint hinttype; /* hint as to real base register */
611 int32_t segment; /* immediate segment, if needed */
612 int64_t offset; /* any immediate number */
613 int32_t wrt; /* segment base it's relative to */
614 int eaflags; /* special EA flags */
615 int opflags; /* see OPFLAG_* defines below */
616 } operand;
618 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
619 #define OPFLAG_EXTERN 2 /* operand is an external reference */
621 typedef struct extop { /* extended operand */
622 struct extop *next; /* linked list */
623 int32_t type; /* defined above */
624 char *stringval; /* if it's a string, then here it is */
625 int stringlen; /* ... and here's how long it is */
626 int32_t segment; /* if it's a number/address, then... */
627 int64_t offset; /* ... it's given here ... */
628 int32_t wrt; /* ... and here */
629 } extop;
631 /* Prefix positions: each type of prefix goes in a specific slot.
632 This affects the final ordering of the assembled output, which
633 shouldn't matter to the processor, but if you have stylistic
634 preferences, you can change this. REX prefixes are handled
635 differently for the time being.
637 Note that LOCK and REP are in the same slot. This is
638 an x86 architectural constraint. */
639 enum prefix_pos {
640 PPS_LREP, /* Lock or REP prefix */
641 PPS_SEG, /* Segment override prefix */
642 PPS_OSIZE, /* Operand size prefix */
643 PPS_ASIZE, /* Address size prefix */
644 MAXPREFIX /* Total number of prefix slots */
647 #define MAX_OPERANDS 4
649 typedef struct insn { /* an instruction itself */
650 char *label; /* the label defined, or NULL */
651 enum prefixes prefixes[MAXPREFIX]; /* instruction prefixes, if any */
652 enum opcode opcode; /* the opcode - not just the string */
653 enum ccode condition; /* the condition code, if Jcc/SETcc */
654 int operands; /* how many operands? 0-3
655 * (more if db et al) */
656 int addr_size; /* address size */
657 operand oprs[MAX_OPERANDS]; /* the operands, defined as above */
658 extop *eops; /* extended operands */
659 int eops_float; /* true if DD and floating */
660 int32_t times; /* repeat count (TIMES prefix) */
661 int forw_ref; /* is there a forward reference? */
662 int rex; /* Special REX Prefix */
663 int drexdst; /* Destination register for DREX suffix */
664 } insn;
666 enum geninfo { GI_SWITCH };
668 * ------------------------------------------------------------
669 * The data structure defining an output format driver, and the
670 * interfaces to the functions therein.
671 * ------------------------------------------------------------
674 struct ofmt {
676 * This is a short (one-liner) description of the type of
677 * output generated by the driver.
679 const char *fullname;
682 * This is a single keyword used to select the driver.
684 const char *shortname;
688 * this is reserved for out module specific help.
689 * It is set to NULL in all the out modules and is not implemented
690 * in the main program
692 const char *helpstring;
695 * this is a pointer to the first element of the debug information
697 struct dfmt **debug_formats;
700 * and a pointer to the element that is being used
701 * note: this is set to the default at compile time and changed if the
702 * -F option is selected. If developing a set of new debug formats for
703 * an output format, be sure to set this to whatever default you want
706 struct dfmt *current_dfmt;
709 * This, if non-NULL, is a NULL-terminated list of `char *'s
710 * pointing to extra standard macros supplied by the object
711 * format (e.g. a sensible initial default value of __SECT__,
712 * and user-level equivalents for any format-specific
713 * directives).
715 const char **stdmac;
718 * This procedure is called at the start of an output session.
719 * It tells the output format what file it will be writing to,
720 * what routine to report errors through, and how to interface
721 * to the label manager and expression evaluator if necessary.
722 * It also gives it a chance to do other initialisation.
724 void (*init) (FILE * fp, efunc error, ldfunc ldef, evalfunc eval);
727 * This procedure is called to pass generic information to the
728 * object file. The first parameter gives the information type
729 * (currently only command line switches)
730 * and the second parameter gives the value. This function returns
731 * 1 if recognized, 0 if unrecognized
733 int (*setinfo) (enum geninfo type, char **string);
736 * This procedure is called by assemble() to write actual
737 * generated code or data to the object file. Typically it
738 * doesn't have to actually _write_ it, just store it for
739 * later.
741 * The `type' argument specifies the type of output data, and
742 * usually the size as well: its contents are described below.
744 void (*output) (int32_t segto, const void *data,
745 enum out_type type, uint64_t size,
746 int32_t segment, int32_t wrt);
749 * This procedure is called once for every symbol defined in
750 * the module being assembled. It gives the name and value of
751 * the symbol, in NASM's terms, and indicates whether it has
752 * been declared to be global. Note that the parameter "name",
753 * when passed, will point to a piece of static storage
754 * allocated inside the label manager - it's safe to keep using
755 * that pointer, because the label manager doesn't clean up
756 * until after the output driver has.
758 * Values of `is_global' are: 0 means the symbol is local; 1
759 * means the symbol is global; 2 means the symbol is common (in
760 * which case `offset' holds the _size_ of the variable).
761 * Anything else is available for the output driver to use
762 * internally.
764 * This routine explicitly _is_ allowed to call the label
765 * manager to define further symbols, if it wants to, even
766 * though it's been called _from_ the label manager. That much
767 * re-entrancy is guaranteed in the label manager. However, the
768 * label manager will in turn call this routine, so it should
769 * be prepared to be re-entrant itself.
771 * The `special' parameter contains special information passed
772 * through from the command that defined the label: it may have
773 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
774 * be obvious to the output format from the other parameters.
776 void (*symdef) (char *name, int32_t segment, int64_t offset,
777 int is_global, char *special);
780 * This procedure is called when the source code requests a
781 * segment change. It should return the corresponding segment
782 * _number_ for the name, or NO_SEG if the name is not a valid
783 * segment name.
785 * It may also be called with NULL, in which case it is to
786 * return the _default_ section number for starting assembly in.
788 * It is allowed to modify the string it is given a pointer to.
790 * It is also allowed to specify a default instruction size for
791 * the segment, by setting `*bits' to 16 or 32. Or, if it
792 * doesn't wish to define a default, it can leave `bits' alone.
794 int32_t (*section) (char *name, int pass, int *bits);
797 * This procedure is called to modify the segment base values
798 * returned from the SEG operator. It is given a segment base
799 * value (i.e. a segment value with the low bit set), and is
800 * required to produce in return a segment value which may be
801 * different. It can map segment bases to absolute numbers by
802 * means of returning SEG_ABS types.
804 * It should return NO_SEG if the segment base cannot be
805 * determined; the evaluator (which calls this routine) is
806 * responsible for throwing an error condition if that occurs
807 * in pass two or in a critical expression.
809 int32_t (*segbase) (int32_t segment);
812 * This procedure is called to allow the output driver to
813 * process its own specific directives. When called, it has the
814 * directive word in `directive' and the parameter string in
815 * `value'. It is called in both assembly passes, and `pass'
816 * will be either 1 or 2.
818 * This procedure should return zero if it does not _recognise_
819 * the directive, so that the main program can report an error.
820 * If it recognises the directive but then has its own errors,
821 * it should report them itself and then return non-zero. It
822 * should also return non-zero if it correctly processes the
823 * directive.
825 int (*directive) (char *directive, char *value, int pass);
828 * This procedure is called before anything else - even before
829 * the "init" routine - and is passed the name of the input
830 * file from which this output file is being generated. It
831 * should return its preferred name for the output file in
832 * `outname', if outname[0] is not '\0', and do nothing to
833 * `outname' otherwise. Since it is called before the driver is
834 * properly initialized, it has to be passed its error handler
835 * separately.
837 * This procedure may also take its own copy of the input file
838 * name for use in writing the output file: it is _guaranteed_
839 * that it will be called before the "init" routine.
841 * The parameter `outname' points to an area of storage
842 * guaranteed to be at least FILENAME_MAX in size.
844 void (*filename) (char *inname, char *outname, efunc error);
847 * This procedure is called after assembly finishes, to allow
848 * the output driver to clean itself up and free its memory.
849 * Typically, it will also be the point at which the object
850 * file actually gets _written_.
852 * One thing the cleanup routine should always do is to close
853 * the output file pointer.
855 void (*cleanup) (int debuginfo);
860 * ------------------------------------------------------------
861 * The data structure defining a debug format driver, and the
862 * interfaces to the functions therein.
863 * ------------------------------------------------------------
866 struct dfmt {
869 * This is a short (one-liner) description of the type of
870 * output generated by the driver.
872 const char *fullname;
875 * This is a single keyword used to select the driver.
877 const char *shortname;
880 * init - called initially to set up local pointer to object format,
881 * void pointer to implementation defined data, file pointer (which
882 * probably won't be used, but who knows?), and error function.
884 void (*init) (struct ofmt * of, void *id, FILE * fp, efunc error);
887 * linenum - called any time there is output with a change of
888 * line number or file.
890 void (*linenum) (const char *filename, int32_t linenumber, int32_t segto);
893 * debug_deflabel - called whenever a label is defined. Parameters
894 * are the same as to 'symdef()' in the output format. This function
895 * would be called before the output format version.
898 void (*debug_deflabel) (char *name, int32_t segment, int64_t offset,
899 int is_global, char *special);
901 * debug_directive - called whenever a DEBUG directive other than 'LINE'
902 * is encountered. 'directive' contains the first parameter to the
903 * DEBUG directive, and params contains the rest. For example,
904 * 'DEBUG VAR _somevar:int' would translate to a call to this
905 * function with 'directive' equal to "VAR" and 'params' equal to
906 * "_somevar:int".
908 void (*debug_directive) (const char *directive, const char *params);
911 * typevalue - called whenever the assembler wishes to register a type
912 * for the last defined label. This routine MUST detect if a type was
913 * already registered and not re-register it.
915 void (*debug_typevalue) (int32_t type);
918 * debug_output - called whenever output is required
919 * 'type' is the type of info required, and this is format-specific
921 void (*debug_output) (int type, void *param);
924 * cleanup - called after processing of file is complete
926 void (*cleanup) (void);
930 * The type definition macros
931 * for debugging
933 * low 3 bits: reserved
934 * next 5 bits: type
935 * next 24 bits: number of elements for arrays (0 for labels)
938 #define TY_UNKNOWN 0x00
939 #define TY_LABEL 0x08
940 #define TY_BYTE 0x10
941 #define TY_WORD 0x18
942 #define TY_DWORD 0x20
943 #define TY_FLOAT 0x28
944 #define TY_QWORD 0x30
945 #define TY_TBYTE 0x38
946 #define TY_OWORD 0x40
947 #define TY_COMMON 0xE0
948 #define TY_SEG 0xE8
949 #define TY_EXTERN 0xF0
950 #define TY_EQU 0xF8
952 #define TYM_TYPE(x) ((x) & 0xF8)
953 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
955 #define TYS_ELEMENTS(x) ((x) << 8)
958 * -----
959 * Special tokens
960 * -----
963 enum special_tokens {
964 SPECIAL_ENUM_START = PREFIX_ENUM_LIMIT,
965 S_ABS = SPECIAL_ENUM_START,
966 S_BYTE, S_DWORD, S_FAR, S_LONG, S_NEAR, S_NOSPLIT,
967 S_OWORD, S_QWORD, S_REL, S_SHORT, S_STRICT, S_TO, S_TWORD, S_WORD,
968 SPECIAL_ENUM_LIMIT
972 * -----
973 * Global modes
974 * -----
978 * This declaration passes the "pass" number to all other modules
979 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
980 * where 0 = optimizing pass
981 * 1 = pass 1
982 * 2 = pass 2
985 extern int pass0;
987 extern bool tasm_compatible_mode;
988 extern int optimizing;
989 extern int globalbits; /* 16, 32 or 64-bit mode */
990 extern int globalrel; /* default to relative addressing? */
991 extern int maxbits; /* max bits supported by output */
993 #endif