1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2016 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * nasm.h main header file for the Netwide Assembler: inter-module interface
46 #include "insnsi.h" /* For enum opcode */
47 #include "directiv.h" /* For enum directive */
51 #define NO_SEG -1L /* null segment value */
52 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
55 #define FILENAME_MAX 256
63 #define POSTFIX_MAX 10
66 #define IDLEN_MAX 4096
67 #define DECOLEN_MAX 32
70 * Name pollution problems: <time.h> on Digital UNIX pulls in some
71 * strange hardware header file which sees fit to define R_SP. We
72 * undefine it here so as not to break the enum below.
79 * We must declare the existence of this structure type up here,
80 * since we have to reference it before we define it...
85 * Values for the `type' parameter to an output function.
87 * Exceptions are OUT_RELxADR, which denote an x-byte relocation
88 * which will be a relative jump. For this we need to know the
89 * distance in bytes from the start of the relocated record until
90 * the end of the containing instruction. _This_ is what is stored
91 * in the size part of the parameter, in this case.
93 * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
94 * and the contents of the "data" parameter is irrelevant.
96 * The "data" parameter for the output function points to a "int32_t",
97 * containing the address in question, unless the type is
98 * OUT_RAWDATA, in which case it points to an "uint8_t"
102 OUT_RAWDATA
, /* Plain bytes */
103 OUT_ADDRESS
, /* An address (symbol value) */
104 OUT_RESERVE
, /* Reserved bytes (RESB et al) */
105 OUT_REL1ADR
, /* 1-byte relative address */
106 OUT_REL2ADR
, /* 2-byte relative address */
107 OUT_REL4ADR
, /* 4-byte relative address */
108 OUT_REL8ADR
/* 8-byte relative address */
112 * A label-lookup function.
114 typedef bool (*lfunc
)(char *label
, int32_t *segment
, int64_t *offset
);
117 * And a label-definition function. The boolean parameter
118 * `is_norm' states whether the label is a `normal' label (which
119 * should affect the local-label system), or something odder like
120 * an EQU or a segment-base symbol, which shouldn't.
122 typedef void (*ldfunc
)(char *label
, int32_t segment
, int64_t offset
,
123 char *special
, bool is_norm
, bool isextrn
);
125 void define_label(char *label
, int32_t segment
, int64_t offset
,
126 char *special
, bool is_norm
, bool isextrn
);
129 * Token types returned by the scanner, in addition to ordinary
130 * ASCII character values, and zero for end-of-string.
132 enum token_type
{ /* token types, other than chars */
133 TOKEN_INVALID
= -1, /* a placeholder value */
134 TOKEN_EOS
= 0, /* end of string */
137 TOKEN_LT
= '<', /* aliases */
138 TOKEN_ID
= 256, /* identifier */
139 TOKEN_NUM
, /* numeric constant */
140 TOKEN_ERRNUM
, /* malformed numeric constant */
141 TOKEN_STR
, /* string constant */
142 TOKEN_ERRSTR
, /* unterminated string constant */
143 TOKEN_FLOAT
, /* floating-point constant */
144 TOKEN_REG
, /* register name */
145 TOKEN_INSN
, /* instruction name */
148 TOKEN_SPECIAL
, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
149 TOKEN_PREFIX
, /* A32, O16, LOCK, REPNZ, TIMES, etc */
156 TOKEN_NE
, /* <> (!= is same as <>) */
157 TOKEN_DBL_AND
, /* && */
158 TOKEN_DBL_OR
, /* || */
159 TOKEN_DBL_XOR
, /* ^^ */
162 TOKEN_FLOATIZE
, /* __floatX__ */
163 TOKEN_STRFUNC
, /* __utf16*__, __utf32*__ */
164 TOKEN_IFUNC
, /* __ilog2*__ */
165 TOKEN_DECORATOR
, /* decorators such as {...} */
166 TOKEN_OPMASK
/* translated token for opmask registers */
180 /* Must match the list in string_transform(), in strfunc.c */
197 size_t string_transform(char *, size_t, char **, enum strfunc
);
200 * The expression evaluator must be passed a scanner function; a
201 * standard scanner is provided as part of nasmlib.c. The
202 * preprocessor will use a different one. Scanners, and the
203 * token-value structures they return, look like this.
205 * The return value from the scanner is always a copy of the
206 * `t_type' field in the structure.
212 enum token_type t_type
;
215 typedef int (*scanner
)(void *private_data
, struct tokenval
*tv
);
222 extern struct location location
;
225 * Expression-evaluator datatype. Expressions, within the
226 * evaluator, are stored as an array of these beasts, terminated by
227 * a record with type==0. Mostly, it's a vector type: each type
228 * denotes some kind of a component, and the value denotes the
229 * multiple of that component present in the expression. The
230 * exception is the WRT type, whose `value' field denotes the
231 * segment to which the expression is relative. These segments will
232 * be segment-base types, i.e. either odd segment values or SEG_ABS
233 * types. So it is still valid to assume that anything with a
234 * `value' field of zero is insignificant.
237 int32_t type
; /* a register, or EXPR_xxx */
238 int64_t value
; /* must be >= 32 bits */
242 * Library routines to manipulate expression data types.
244 int is_reloc(expr
*vect
);
245 int is_simple(expr
*vect
);
246 int is_really_simple(expr
*vect
);
247 int is_unknown(expr
*vect
);
248 int is_just_unknown(expr
*vect
);
249 int64_t reloc_value(expr
*vect
);
250 int32_t reloc_seg(expr
*vect
);
251 int32_t reloc_wrt(expr
*vect
);
254 * The evaluator can also return hints about which of two registers
255 * used in an expression should be the base register. See also the
256 * `operand' structure.
264 * The actual expression evaluator function looks like this. When
265 * called, it expects the first token of its expression to already
266 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
267 * it will start by calling the scanner.
269 * If a forward reference happens during evaluation, the evaluator
270 * must set `*fwref' to true if `fwref' is non-NULL.
272 * `critical' is non-zero if the expression may not contain forward
273 * references. The evaluator will report its own error if this
274 * occurs; if `critical' is 1, the error will be "symbol not
275 * defined before use", whereas if `critical' is 2, the error will
276 * be "symbol undefined".
278 * If `critical' has bit 8 set (in addition to its main value: 0x101
279 * and 0x102 correspond to 1 and 2) then an extended expression
280 * syntax is recognised, in which relational operators such as =, <
281 * and >= are accepted, as well as low-precedence logical operators
284 * If `hints' is non-NULL, it gets filled in with some hints as to
285 * the base register in complex effective addresses.
287 #define CRITICAL 0x100
288 typedef expr
*(*evalfunc
)(scanner sc
, void *scprivate
,
289 struct tokenval
*tv
, int *fwref
, int critical
,
290 struct eval_hints
*hints
);
293 * Special values for expr->type.
294 * These come after EXPR_REG_END as defined in regs.h.
295 * Expr types : 0 ~ EXPR_REG_END, EXPR_UNKNOWN, EXPR_...., EXPR_RDSAE,
296 * EXPR_SEGBASE ~ EXPR_SEGBASE + SEG_ABS, ...
298 #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */
299 #define EXPR_SIMPLE (EXPR_REG_END+2)
300 #define EXPR_WRT (EXPR_REG_END+3)
301 #define EXPR_RDSAE (EXPR_REG_END+4)
302 #define EXPR_SEGBASE (EXPR_REG_END+5)
305 * Linked list of strings
307 typedef struct string_list
{
308 struct string_list
*next
;
313 * preprocessors ought to look like this:
317 * Called at the start of a pass; given a file name, the number
318 * of the pass, an error reporting function, an evaluator
319 * function, and a listing generator to talk to.
321 void (*reset
)(char *file
, int pass
, StrList
**deplist
);
324 * Called to fetch a line of preprocessed source. The line
325 * returned has been malloc'ed, and so should be freed after
328 char *(*getline
)(void);
330 /* Called at the end of a pass */
331 void (*cleanup
)(int pass
);
333 /* Additional macros specific to output format */
334 void (*extra_stdmac
)(macros_t
*macros
);
336 /* Early definitions and undefinitions for macros */
337 void (*pre_define
)(char *definition
);
338 void (*pre_undefine
)(char *definition
);
340 /* Include file from command line */
341 void (*pre_include
)(char *fname
);
343 /* Include path from command line */
344 void (*include_path
)(char *path
);
347 extern const struct preproc_ops nasmpp
;
348 extern const struct preproc_ops preproc_nop
;
351 * Some lexical properties of the NASM source language, included
352 * here because they are shared between the parser and preprocessor.
356 * isidstart matches any character that may start an identifier, and isidchar
357 * matches any character that may appear at places other than the start of an
358 * identifier. E.g. a period may only appear at the start of an identifier
359 * (for local labels), whereas a number may appear anywhere *but* at the
361 * isbrcchar matches any character that may placed inside curly braces as a
362 * decorator. E.g. {rn-sae}, {1to8}, {k1}{z}
365 #define isidstart(c) (nasm_isalpha(c) || \
371 #define isidchar(c) (isidstart(c) || \
377 #define isbrcchar(c) (isidchar(c) || \
380 /* Ditto for numeric constants. */
382 #define isnumstart(c) (nasm_isdigit(c) || (c) == '$')
383 #define isnumchar(c) (nasm_isalnum(c) || (c) == '_')
386 * Data-type flags that get passed to listing-file routines.
398 * -----------------------------------------------------------
399 * Format of the `insn' structure returned from `parser.c' and
400 * passed into `assemble.c'
401 * -----------------------------------------------------------
404 /* Verify value to be a valid register */
405 static inline bool is_register(int reg
)
407 return reg
>= EXPR_REG_START
&& reg
< REG_ENUM_LIMIT
;
410 enum ccode
{ /* condition code names */
411 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
412 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
413 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
,
420 #define TFLAG_BRC (1 << 0) /* valid only with braces. {1to8}, {rd-sae}, ...*/
421 #define TFLAG_BRC_OPT (1 << 1) /* may or may not have braces. opmasks {k1} */
422 #define TFLAG_BRC_ANY (TFLAG_BRC | TFLAG_BRC_OPT)
423 #define TFLAG_BRDCAST (1 << 2) /* broadcasting decorator */
425 static inline uint8_t get_cond_opcode(enum ccode c
)
427 static const uint8_t ccode_opcodes
[] = {
428 0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xf, 0xd, 0xc, 0xe, 0x6, 0x2,
429 0x3, 0x7, 0x3, 0x5, 0xe, 0xc, 0xd, 0xf, 0x1, 0xb, 0x9, 0x5,
430 0x0, 0xa, 0xa, 0xb, 0x8, 0x4
433 return ccode_opcodes
[(int)c
];
439 #define REX_MASK 0x4f /* Actual REX prefix bits */
440 #define REX_B 0x01 /* ModRM r/m extension */
441 #define REX_X 0x02 /* SIB index extension */
442 #define REX_R 0x04 /* ModRM reg extension */
443 #define REX_W 0x08 /* 64-bit operand size */
444 #define REX_L 0x20 /* Use LOCK prefix instead of REX.R */
445 #define REX_P 0x40 /* REX prefix present/required */
446 #define REX_H 0x80 /* High register present, REX forbidden */
447 #define REX_V 0x0100 /* Instruction uses VEX/XOP instead of REX */
448 #define REX_NH 0x0200 /* Instruction which doesn't use high regs */
449 #define REX_EV 0x0400 /* Instruction uses EVEX instead of REX */
454 #define EVEX_P0MM 0x03 /* EVEX P[1:0] : Legacy escape */
455 #define EVEX_P0RP 0x10 /* EVEX P[4] : High-16 reg */
456 #define EVEX_P0X 0x40 /* EVEX P[6] : High-16 rm */
457 #define EVEX_P1PP 0x03 /* EVEX P[9:8] : Legacy prefix */
458 #define EVEX_P1VVVV 0x78 /* EVEX P[14:11] : NDS register */
459 #define EVEX_P1W 0x80 /* EVEX P[15] : Osize extension */
460 #define EVEX_P2AAA 0x07 /* EVEX P[18:16] : Embedded opmask */
461 #define EVEX_P2VP 0x08 /* EVEX P[19] : High-16 NDS reg */
462 #define EVEX_P2B 0x10 /* EVEX P[20] : Broadcast / RC / SAE */
463 #define EVEX_P2LL 0x60 /* EVEX P[22:21] : Vector length */
464 #define EVEX_P2RC EVEX_P2LL /* EVEX P[22:21] : Rounding control */
465 #define EVEX_P2Z 0x80 /* EVEX P[23] : Zeroing/Merging */
468 * REX_V "classes" (prefixes which behave like VEX)
471 RV_VEX
= 0, /* C4/C5 */
477 * Note that because segment registers may be used as instruction
478 * prefixes, we must ensure the enumerations for prefixes and
479 * register names do not overlap.
481 enum prefixes
{ /* instruction prefixes */
483 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
484 P_A16
= PREFIX_ENUM_START
,
510 enum extop_type
{ /* extended operand types */
512 EOT_DB_STRING
, /* Byte string */
513 EOT_DB_STRING_FREE
, /* Byte string which should be nasm_free'd*/
514 EOT_DB_NUMBER
/* Integer */
517 enum ea_flags
{ /* special EA flags */
518 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
519 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
520 EAF_TIMESTWO
= 4, /* really do EAX*2 not EAX+EAX */
521 EAF_REL
= 8, /* IP-relative addressing */
522 EAF_ABS
= 16, /* non-IP-relative addressing */
523 EAF_FSGS
= 32, /* fs/gs segment override present */
524 EAF_MIB
= 64 /* mib operand */
527 enum eval_hint
{ /* values for `hinttype' */
528 EAH_NOHINT
= 0, /* no hint at all - our discretion */
529 EAH_MAKEBASE
= 1, /* try to make given reg the base */
530 EAH_NOTBASE
= 2, /* try _not_ to make reg the base */
531 EAH_SUMMED
= 3 /* base and index are summed into index */
534 typedef struct operand
{ /* operand to an instruction */
535 opflags_t type
; /* type of operand */
536 int disp_size
; /* 0 means default; 16; 32; 64 */
537 enum reg_enum basereg
;
538 enum reg_enum indexreg
; /* address registers */
539 int scale
; /* index scale */
541 enum eval_hint hinttype
; /* hint as to real base register */
542 int32_t segment
; /* immediate segment, if needed */
543 int64_t offset
; /* any immediate number */
544 int32_t wrt
; /* segment base it's relative to */
545 int eaflags
; /* special EA flags */
546 int opflags
; /* see OPFLAG_* defines below */
547 decoflags_t decoflags
; /* decorator flags such as {...} */
550 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
551 #define OPFLAG_EXTERN 2 /* operand is an external reference */
552 #define OPFLAG_UNKNOWN 4 /* operand is an unknown reference
553 * (always a forward reference also)
556 typedef struct extop
{ /* extended operand */
557 struct extop
*next
; /* linked list */
558 char *stringval
; /* if it's a string, then here it is */
559 size_t stringlen
; /* ... and here's how long it is */
560 int64_t offset
; /* ... it's given here ... */
561 int32_t segment
; /* if it's a number/address, then... */
562 int32_t wrt
; /* ... and here */
563 enum extop_type type
; /* defined above */
567 EA_INVALID
, /* Not a valid EA at all */
568 EA_SCALAR
, /* Scalar EA */
569 EA_XMMVSIB
, /* XMM vector EA */
570 EA_YMMVSIB
, /* YMM vector EA */
571 EA_ZMMVSIB
/* ZMM vector EA */
575 * Prefix positions: each type of prefix goes in a specific slot.
576 * This affects the final ordering of the assembled output, which
577 * shouldn't matter to the processor, but if you have stylistic
578 * preferences, you can change this. REX prefixes are handled
579 * differently for the time being.
581 * LOCK and REP used to be one slot; this is no longer the case since
582 * the introduction of HLE.
585 PPS_WAIT
, /* WAIT (technically not a prefix!) */
586 PPS_REP
, /* REP/HLE prefix */
587 PPS_LOCK
, /* LOCK prefix */
588 PPS_SEG
, /* Segment override prefix */
589 PPS_OSIZE
, /* Operand size prefix */
590 PPS_ASIZE
, /* Address size prefix */
591 PPS_VEX
, /* VEX type */
592 MAXPREFIX
/* Total number of prefix slots */
596 * Tuple types that are used when determining Disp8*N eligibility
597 * The order must match with a hash %tuple_codes in insns.pl
618 /* EVEX.L'L : Vector length on vector insns */
626 /* If you need to change this, also change it in insns.pl */
627 #define MAX_OPERANDS 5
629 typedef struct insn
{ /* an instruction itself */
630 char *label
; /* the label defined, or NULL */
631 int prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
632 enum opcode opcode
; /* the opcode - not just the string */
633 enum ccode condition
; /* the condition code, if Jcc/SETcc */
634 int operands
; /* how many operands? 0-3 (more if db et al) */
635 int addr_size
; /* address size */
636 operand oprs
[MAX_OPERANDS
]; /* the operands, defined as above */
637 extop
*eops
; /* extended operands */
638 int eops_float
; /* true if DD and floating */
639 int32_t times
; /* repeat count (TIMES prefix) */
640 bool forw_ref
; /* is there a forward reference? */
641 bool rex_done
; /* REX prefix emitted? */
642 int rex
; /* Special REX Prefix */
643 int vexreg
; /* Register encoded in VEX prefix */
644 int vex_cm
; /* Class and M field for VEX prefix */
645 int vex_wlp
; /* W, P and L information for VEX prefix */
646 uint8_t evex_p
[3]; /* EVEX.P0: [RXB,R',00,mm], P1: [W,vvvv,1,pp] */
647 /* EVEX.P2: [z,L'L,b,V',aaa] */
648 enum ttypes evex_tuple
; /* Tuple type for compressed Disp8*N */
649 int evex_rm
; /* static rounding mode for AVX512 (EVEX) */
650 int8_t evex_brerop
; /* BR/ER/SAE operand position */
653 enum geninfo
{ GI_SWITCH
};
655 /* Instruction flags type: IF_* flags are defined in insns.h */
656 typedef uint64_t iflags_t
;
659 * The data structure defining an output format driver, and the
660 * interfaces to the functions therein.
664 * This is a short (one-liner) description of the type of
665 * output generated by the driver.
667 const char *fullname
;
670 * This is a single keyword used to select the driver.
672 const char *shortname
;
675 * Output format flags.
677 #define OFMT_TEXT 1 /* Text file format */
680 int maxbits
; /* Maximum segment bits supported */
683 * this is a pointer to the first element of the debug information
685 const struct dfmt
* const *debug_formats
;
688 * the default debugging format if -F is not specified
690 const struct dfmt
*default_dfmt
;
693 * This, if non-NULL, is a NULL-terminated list of `char *'s
694 * pointing to extra standard macros supplied by the object
695 * format (e.g. a sensible initial default value of __SECT__,
696 * and user-level equivalents for any format-specific
702 * This procedure is called at the start of an output session to set
703 * up internal parameters.
708 * This procedure is called to pass generic information to the
709 * object file. The first parameter gives the information type
710 * (currently only command line switches)
711 * and the second parameter gives the value. This function returns
712 * 1 if recognized, 0 if unrecognized
714 int (*setinfo
)(enum geninfo type
, char **string
);
717 * This procedure is called by assemble() to write actual
718 * generated code or data to the object file. Typically it
719 * doesn't have to actually _write_ it, just store it for
722 * The `type' argument specifies the type of output data, and
723 * usually the size as well: its contents are described below.
725 void (*output
)(int32_t segto
, const void *data
,
726 enum out_type type
, uint64_t size
,
727 int32_t segment
, int32_t wrt
);
730 * This procedure is called once for every symbol defined in
731 * the module being assembled. It gives the name and value of
732 * the symbol, in NASM's terms, and indicates whether it has
733 * been declared to be global. Note that the parameter "name",
734 * when passed, will point to a piece of static storage
735 * allocated inside the label manager - it's safe to keep using
736 * that pointer, because the label manager doesn't clean up
737 * until after the output driver has.
739 * Values of `is_global' are: 0 means the symbol is local; 1
740 * means the symbol is global; 2 means the symbol is common (in
741 * which case `offset' holds the _size_ of the variable).
742 * Anything else is available for the output driver to use
745 * This routine explicitly _is_ allowed to call the label
746 * manager to define further symbols, if it wants to, even
747 * though it's been called _from_ the label manager. That much
748 * re-entrancy is guaranteed in the label manager. However, the
749 * label manager will in turn call this routine, so it should
750 * be prepared to be re-entrant itself.
752 * The `special' parameter contains special information passed
753 * through from the command that defined the label: it may have
754 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
755 * be obvious to the output format from the other parameters.
757 void (*symdef
)(char *name
, int32_t segment
, int64_t offset
,
758 int is_global
, char *special
);
761 * This procedure is called when the source code requests a
762 * segment change. It should return the corresponding segment
763 * _number_ for the name, or NO_SEG if the name is not a valid
766 * It may also be called with NULL, in which case it is to
767 * return the _default_ section number for starting assembly in.
769 * It is allowed to modify the string it is given a pointer to.
771 * It is also allowed to specify a default instruction size for
772 * the segment, by setting `*bits' to 16 or 32. Or, if it
773 * doesn't wish to define a default, it can leave `bits' alone.
775 int32_t (*section
)(char *name
, int pass
, int *bits
);
778 * This procedure is called to modify section alignment,
779 * note there is a trick, the alignment can only increase
781 void (*sectalign
)(int32_t seg
, unsigned int value
);
784 * This procedure is called to modify the segment base values
785 * returned from the SEG operator. It is given a segment base
786 * value (i.e. a segment value with the low bit set), and is
787 * required to produce in return a segment value which may be
788 * different. It can map segment bases to absolute numbers by
789 * means of returning SEG_ABS types.
791 * It should return NO_SEG if the segment base cannot be
792 * determined; the evaluator (which calls this routine) is
793 * responsible for throwing an error condition if that occurs
794 * in pass two or in a critical expression.
796 int32_t (*segbase
)(int32_t segment
);
799 * This procedure is called to allow the output driver to
800 * process its own specific directives. When called, it has the
801 * directive word in `directive' and the parameter string in
802 * `value'. It is called in both assembly passes, and `pass'
803 * will be either 1 or 2.
805 * This procedure should return zero if it does not _recognise_
806 * the directive, so that the main program can report an error.
807 * If it recognises the directive but then has its own errors,
808 * it should report them itself and then return non-zero. It
809 * should also return non-zero if it correctly processes the
812 int (*directive
)(enum directives directive
, char *value
, int pass
);
815 * This procedure is called before anything else - even before
816 * the "init" routine - and is passed the name of the input
817 * file from which this output file is being generated. It
818 * should return its preferred name for the output file in
819 * `outname', if outname[0] is not '\0', and do nothing to
820 * `outname' otherwise. Since it is called before the driver is
821 * properly initialized, it has to be passed its error handler
824 * This procedure may also take its own copy of the input file
825 * name for use in writing the output file: it is _guaranteed_
826 * that it will be called before the "init" routine.
828 * The parameter `outname' points to an area of storage
829 * guaranteed to be at least FILENAME_MAX in size.
831 void (*filename
)(char *inname
, char *outname
);
834 * This procedure is called after assembly finishes, to allow
835 * the output driver to clean itself up and free its memory.
836 * Typically, it will also be the point at which the object
837 * file actually gets _written_.
839 * One thing the cleanup routine should always do is to close
840 * the output file pointer.
842 void (*cleanup
)(void);
846 * Output format driver alias
849 const char *shortname
;
850 const char *fullname
;
851 const struct ofmt
*ofmt
;
854 extern const struct ofmt
*ofmt
;
858 * ------------------------------------------------------------
859 * The data structure defining a debug format driver, and the
860 * interfaces to the functions therein.
861 * ------------------------------------------------------------
866 * This is a short (one-liner) description of the type of
867 * output generated by the driver.
869 const char *fullname
;
872 * This is a single keyword used to select the driver.
874 const char *shortname
;
877 * init - called initially to set up local pointer to object format.
882 * linenum - called any time there is output with a change of
883 * line number or file.
885 void (*linenum
)(const char *filename
, int32_t linenumber
, int32_t segto
);
888 * debug_deflabel - called whenever a label is defined. Parameters
889 * are the same as to 'symdef()' in the output format. This function
890 * is called after the output format version.
893 void (*debug_deflabel
)(char *name
, int32_t segment
, int64_t offset
,
894 int is_global
, char *special
);
896 * debug_directive - called whenever a DEBUG directive other than 'LINE'
897 * is encountered. 'directive' contains the first parameter to the
898 * DEBUG directive, and params contains the rest. For example,
899 * 'DEBUG VAR _somevar:int' would translate to a call to this
900 * function with 'directive' equal to "VAR" and 'params' equal to
903 void (*debug_directive
)(const char *directive
, const char *params
);
906 * typevalue - called whenever the assembler wishes to register a type
907 * for the last defined label. This routine MUST detect if a type was
908 * already registered and not re-register it.
910 void (*debug_typevalue
)(int32_t type
);
913 * debug_output - called whenever output is required
914 * 'type' is the type of info required, and this is format-specific
916 void (*debug_output
)(int type
, void *param
);
919 * cleanup - called after processing of file is complete
921 void (*cleanup
)(void);
924 extern const struct dfmt
*dfmt
;
927 * The type definition macros
930 * low 3 bits: reserved
932 * next 24 bits: number of elements for arrays (0 for labels)
935 #define TY_UNKNOWN 0x00
936 #define TY_LABEL 0x08
939 #define TY_DWORD 0x20
940 #define TY_FLOAT 0x28
941 #define TY_QWORD 0x30
942 #define TY_TBYTE 0x38
943 #define TY_OWORD 0x40
944 #define TY_YWORD 0x48
945 #define TY_COMMON 0xE0
947 #define TY_EXTERN 0xF0
950 #define TYM_TYPE(x) ((x) & 0xF8)
951 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
953 #define TYS_ELEMENTS(x) ((x) << 8)
955 enum special_tokens
{
956 SPECIAL_ENUM_START
= PREFIX_ENUM_LIMIT
,
957 S_ABS
= SPECIAL_ENUM_START
,
977 enum decorator_tokens
{
978 DECORATOR_ENUM_START
= SPECIAL_ENUM_LIMIT
,
979 BRC_1TO2
= DECORATOR_ENUM_START
,
993 * AVX512 Decorator (decoflags_t) bits distribution (counted from 0)
995 * 10987654321098765432109876543210
998 * ............................1111 opmask
999 * ...........................1.... zeroing / merging
1000 * ..........................1..... broadcast
1001 * .........................1...... static rounding
1002 * ........................1....... SAE
1003 * ......................11........ broadcast element size
1004 * ....................11.......... number of broadcast elements
1006 #define OP_GENVAL(val, bits, shift) (((val) & ((UINT64_C(1) << (bits)) - 1)) << (shift))
1009 * Opmask register number
1010 * identical to EVEX.aaa
1014 #define OPMASK_SHIFT (0)
1015 #define OPMASK_BITS (4)
1016 #define OPMASK_MASK OP_GENMASK(OPMASK_BITS, OPMASK_SHIFT)
1017 #define GEN_OPMASK(bit) OP_GENBIT(bit, OPMASK_SHIFT)
1018 #define VAL_OPMASK(val) OP_GENVAL(val, OPMASK_BITS, OPMASK_SHIFT)
1021 * zeroing / merging control available
1022 * matching to EVEX.z
1028 #define Z_MASK OP_GENMASK(Z_BITS, Z_SHIFT)
1029 #define GEN_Z(bit) OP_GENBIT(bit, Z_SHIFT)
1032 * broadcast - Whether this operand can be broadcasted
1036 #define BRDCAST_SHIFT (5)
1037 #define BRDCAST_BITS (1)
1038 #define BRDCAST_MASK OP_GENMASK(BRDCAST_BITS, BRDCAST_SHIFT)
1039 #define GEN_BRDCAST(bit) OP_GENBIT(bit, BRDCAST_SHIFT)
1042 * Whether this instruction can have a static rounding mode.
1043 * It goes with the last simd operand because the static rounding mode
1044 * decorator is located between the last simd operand and imm8 (if any).
1048 #define STATICRND_SHIFT (6)
1049 #define STATICRND_BITS (1)
1050 #define STATICRND_MASK OP_GENMASK(STATICRND_BITS, STATICRND_SHIFT)
1051 #define GEN_STATICRND(bit) OP_GENBIT(bit, STATICRND_SHIFT)
1054 * SAE(Suppress all exception) available
1058 #define SAE_SHIFT (7)
1059 #define SAE_BITS (1)
1060 #define SAE_MASK OP_GENMASK(SAE_BITS, SAE_SHIFT)
1061 #define GEN_SAE(bit) OP_GENBIT(bit, SAE_SHIFT)
1064 * Broadcasting element size.
1068 #define BRSIZE_SHIFT (8)
1069 #define BRSIZE_BITS (2)
1070 #define BRSIZE_MASK OP_GENMASK(BRSIZE_BITS, BRSIZE_SHIFT)
1071 #define GEN_BRSIZE(bit) OP_GENBIT(bit, BRSIZE_SHIFT)
1073 #define BR_BITS32 GEN_BRSIZE(0)
1074 #define BR_BITS64 GEN_BRSIZE(1)
1077 * Number of broadcasting elements
1081 #define BRNUM_SHIFT (10)
1082 #define BRNUM_BITS (2)
1083 #define BRNUM_MASK OP_GENMASK(BRNUM_BITS, BRNUM_SHIFT)
1084 #define VAL_BRNUM(val) OP_GENVAL(val, BRNUM_BITS, BRNUM_SHIFT)
1086 #define BR_1TO2 VAL_BRNUM(0)
1087 #define BR_1TO4 VAL_BRNUM(1)
1088 #define BR_1TO8 VAL_BRNUM(2)
1089 #define BR_1TO16 VAL_BRNUM(3)
1091 #define MASK OPMASK_MASK /* Opmask (k1 ~ 7) can be used */
1093 #define B32 (BRDCAST_MASK|BR_BITS32) /* {1to16} : broadcast 32b * 16 to zmm(512b) */
1094 #define B64 (BRDCAST_MASK|BR_BITS64) /* {1to8} : broadcast 64b * 8 to zmm(512b) */
1095 #define ER STATICRND_MASK /* ER(Embedded Rounding) == Static rounding mode */
1096 #define SAE SAE_MASK /* SAE(Suppress All Exception) */
1103 * This declaration passes the "pass" number to all other modules
1104 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
1105 * where 0 = optimizing pass
1111 extern int passn
; /* Actual pass number */
1113 extern bool tasm_compatible_mode
;
1114 extern int optimizing
;
1115 extern int globalbits
; /* 16, 32 or 64-bit mode */
1116 extern int globalrel
; /* default to relative addressing? */
1117 extern int globalbnd
; /* default to using bnd prefix? */