1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2017 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
47 #include "insnsi.h" /* For enum opcode */
48 #include "directiv.h" /* For enum directive */
52 #define NO_SEG -1L /* null segment value */
53 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
56 #define FILENAME_MAX 256
64 #define POSTFIX_MAX 10
67 #define IDLEN_MAX 4096
68 #define DECOLEN_MAX 32
71 * Name pollution problems: <time.h> on Digital UNIX pulls in some
72 * strange hardware header file which sees fit to define R_SP. We
73 * undefine it here so as not to break the enum below.
80 * We must declare the existence of this structure type up here,
81 * since we have to reference it before we define it...
86 * Values for the `type' parameter to an output function.
89 OUT_RAWDATA
, /* Plain bytes */
90 OUT_RESERVE
, /* Reserved bytes (RESB et al) */
91 OUT_ADDRESS
, /* An address (symbol value) */
92 OUT_RELADDR
, /* A relative address */
93 OUT_SEGMENT
, /* A segment number */
96 * These values are used by the legacy backend interface only;
97 * see output/legacy.c for more information. These should never
98 * be used otherwise. Once all backends have been migrated to the
99 * new interface they should be removed.
108 OUT_WRAP
, /* Undefined signedness (wraps) */
109 OUT_SIGNED
, /* Value is signed */
110 OUT_UNSIGNED
/* Value is unsigned */
114 * The data we send down to the backend.
115 * XXX: We still want to push down the base address symbol if
116 * available, and replace the segment numbers with a structure.
119 int64_t offset
; /* Offset within segment */
120 int32_t segment
; /* Segment written to */
121 enum out_type type
; /* See above */
122 enum out_sign sign
; /* See above */
123 int inslen
; /* Length of instruction */
124 int insoffs
; /* Offset inside instruction */
125 int bits
; /* Bits mode of compilation */
126 uint64_t size
; /* Size of output */
127 const struct itemplate
*itemp
; /* Instruction template */
128 const void *data
; /* Data for OUT_RAWDATA */
129 uint64_t toffset
; /* Target address offset for relocation */
130 int32_t tsegment
; /* Target segment for relocation */
131 int32_t twrt
; /* Relocation with respect to */
132 int64_t relbase
; /* Relative base for OUT_RELADDR */
136 * A label-lookup function.
138 typedef bool (*lfunc
)(char *label
, int32_t *segment
, int64_t *offset
);
141 * And a label-definition function. The boolean parameter
142 * `is_norm' states whether the label is a `normal' label (which
143 * should affect the local-label system), or something odder like
144 * an EQU or a segment-base symbol, which shouldn't.
146 typedef void (*ldfunc
)(char *label
, int32_t segment
, int64_t offset
,
147 char *special
, bool is_norm
, bool isextrn
);
149 void define_label(char *label
, int32_t segment
, int64_t offset
,
150 char *special
, bool is_norm
, bool isextrn
);
153 * Token types returned by the scanner, in addition to ordinary
154 * ASCII character values, and zero for end-of-string.
156 enum token_type
{ /* token types, other than chars */
157 TOKEN_INVALID
= -1, /* a placeholder value */
158 TOKEN_EOS
= 0, /* end of string */
161 TOKEN_LT
= '<', /* aliases */
162 TOKEN_ID
= 256, /* identifier */
163 TOKEN_NUM
, /* numeric constant */
164 TOKEN_ERRNUM
, /* malformed numeric constant */
165 TOKEN_STR
, /* string constant */
166 TOKEN_ERRSTR
, /* unterminated string constant */
167 TOKEN_FLOAT
, /* floating-point constant */
168 TOKEN_REG
, /* register name */
169 TOKEN_INSN
, /* instruction name */
172 TOKEN_SPECIAL
, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
173 TOKEN_PREFIX
, /* A32, O16, LOCK, REPNZ, TIMES, etc */
180 TOKEN_NE
, /* <> (!= is same as <>) */
181 TOKEN_DBL_AND
, /* && */
182 TOKEN_DBL_OR
, /* || */
183 TOKEN_DBL_XOR
, /* ^^ */
186 TOKEN_FLOATIZE
, /* __floatX__ */
187 TOKEN_STRFUNC
, /* __utf16*__, __utf32*__ */
188 TOKEN_IFUNC
, /* __ilog2*__ */
189 TOKEN_DECORATOR
, /* decorators such as {...} */
190 TOKEN_OPMASK
/* translated token for opmask registers */
204 /* Must match the list in string_transform(), in strfunc.c */
221 size_t string_transform(char *, size_t, char **, enum strfunc
);
224 * The expression evaluator must be passed a scanner function; a
225 * standard scanner is provided as part of nasmlib.c. The
226 * preprocessor will use a different one. Scanners, and the
227 * token-value structures they return, look like this.
229 * The return value from the scanner is always a copy of the
230 * `t_type' field in the structure.
236 enum token_type t_type
;
239 typedef int (*scanner
)(void *private_data
, struct tokenval
*tv
);
246 extern struct location location
;
249 * Expression-evaluator datatype. Expressions, within the
250 * evaluator, are stored as an array of these beasts, terminated by
251 * a record with type==0. Mostly, it's a vector type: each type
252 * denotes some kind of a component, and the value denotes the
253 * multiple of that component present in the expression. The
254 * exception is the WRT type, whose `value' field denotes the
255 * segment to which the expression is relative. These segments will
256 * be segment-base types, i.e. either odd segment values or SEG_ABS
257 * types. So it is still valid to assume that anything with a
258 * `value' field of zero is insignificant.
261 int32_t type
; /* a register, or EXPR_xxx */
262 int64_t value
; /* must be >= 32 bits */
266 * Library routines to manipulate expression data types.
268 bool is_reloc(const expr
*vect
);
269 bool is_simple(const expr
*vect
);
270 bool is_really_simple(const expr
*vect
);
271 bool is_unknown(const expr
*vect
);
272 bool is_just_unknown(const expr
*vect
);
273 int64_t reloc_value(const expr
*vect
);
274 int32_t reloc_seg(const expr
*vect
);
275 int32_t reloc_wrt(const expr
*vect
);
276 bool is_self_relative(const expr
*vect
);
277 void dump_expr(const expr
*vect
);
280 * The evaluator can also return hints about which of two registers
281 * used in an expression should be the base register. See also the
282 * `operand' structure.
290 * The actual expression evaluator function looks like this. When
291 * called, it expects the first token of its expression to already
292 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
293 * it will start by calling the scanner.
295 * If a forward reference happens during evaluation, the evaluator
296 * must set `*fwref' to true if `fwref' is non-NULL.
298 * `critical' is non-zero if the expression may not contain forward
299 * references. The evaluator will report its own error if this
300 * occurs; if `critical' is 1, the error will be "symbol not
301 * defined before use", whereas if `critical' is 2, the error will
302 * be "symbol undefined".
304 * If `critical' has bit 8 set (in addition to its main value: 0x101
305 * and 0x102 correspond to 1 and 2) then an extended expression
306 * syntax is recognised, in which relational operators such as =, <
307 * and >= are accepted, as well as low-precedence logical operators
310 * If `hints' is non-NULL, it gets filled in with some hints as to
311 * the base register in complex effective addresses.
313 #define CRITICAL 0x100
314 typedef expr
*(*evalfunc
)(scanner sc
, void *scprivate
,
315 struct tokenval
*tv
, int *fwref
, int critical
,
316 struct eval_hints
*hints
);
319 * Special values for expr->type.
320 * These come after EXPR_REG_END as defined in regs.h.
321 * Expr types : 0 ~ EXPR_REG_END, EXPR_UNKNOWN, EXPR_...., EXPR_RDSAE,
322 * EXPR_SEGBASE ~ EXPR_SEGBASE + SEG_ABS, ...
324 #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */
325 #define EXPR_SIMPLE (EXPR_REG_END+2)
326 #define EXPR_WRT (EXPR_REG_END+3)
327 #define EXPR_RDSAE (EXPR_REG_END+4)
328 #define EXPR_SEGBASE (EXPR_REG_END+5)
331 * preprocessors ought to look like this:
335 * Called once at the very start of assembly.
340 * Called at the start of a pass; given a file name, the number
341 * of the pass, an error reporting function, an evaluator
342 * function, and a listing generator to talk to.
344 void (*reset
)(char *file
, int pass
, StrList
**deplist
);
347 * Called to fetch a line of preprocessed source. The line
348 * returned has been malloc'ed, and so should be freed after
351 char *(*getline
)(void);
353 /* Called at the end of a pass */
354 void (*cleanup
)(int pass
);
356 /* Additional macros specific to output format */
357 void (*extra_stdmac
)(macros_t
*macros
);
359 /* Early definitions and undefinitions for macros */
360 void (*pre_define
)(char *definition
);
361 void (*pre_undefine
)(char *definition
);
363 /* Include file from command line */
364 void (*pre_include
)(char *fname
);
366 /* Include path from command line */
367 void (*include_path
)(char *path
);
369 /* Unwind the macro stack when printing an error message */
370 void (*error_list_macros
)(int severity
);
373 extern const struct preproc_ops nasmpp
;
374 extern const struct preproc_ops preproc_nop
;
377 * Some lexical properties of the NASM source language, included
378 * here because they are shared between the parser and preprocessor.
382 * isidstart matches any character that may start an identifier, and isidchar
383 * matches any character that may appear at places other than the start of an
384 * identifier. E.g. a period may only appear at the start of an identifier
385 * (for local labels), whereas a number may appear anywhere *but* at the
387 * isbrcchar matches any character that may placed inside curly braces as a
388 * decorator. E.g. {rn-sae}, {1to8}, {k1}{z}
391 #define isidstart(c) (nasm_isalpha(c) || \
397 #define isidchar(c) (isidstart(c) || \
403 #define isbrcchar(c) (isidchar(c) || \
406 /* Ditto for numeric constants. */
408 #define isnumstart(c) (nasm_isdigit(c) || (c) == '$')
409 #define isnumchar(c) (nasm_isalnum(c) || (c) == '_')
412 * inline function to skip past an identifier; returns the first character past
413 * the identifier if valid, otherwise NULL.
415 static inline char *nasm_skip_identifier(const char *str
)
419 if (!isidstart(*p
++)) {
422 while (isidchar(*p
++))
429 * Data-type flags that get passed to listing-file routines.
441 * -----------------------------------------------------------
442 * Format of the `insn' structure returned from `parser.c' and
443 * passed into `assemble.c'
444 * -----------------------------------------------------------
447 /* Verify value to be a valid register */
448 static inline bool is_register(int reg
)
450 return reg
>= EXPR_REG_START
&& reg
< REG_ENUM_LIMIT
;
453 enum ccode
{ /* condition code names */
454 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
455 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
456 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
,
463 #define TFLAG_BRC (1 << 0) /* valid only with braces. {1to8}, {rd-sae}, ...*/
464 #define TFLAG_BRC_OPT (1 << 1) /* may or may not have braces. opmasks {k1} */
465 #define TFLAG_BRC_ANY (TFLAG_BRC | TFLAG_BRC_OPT)
466 #define TFLAG_BRDCAST (1 << 2) /* broadcasting decorator */
467 #define TFLAG_WARN (1 << 3) /* warning only, treat as ID */
469 static inline uint8_t get_cond_opcode(enum ccode c
)
471 static const uint8_t ccode_opcodes
[] = {
472 0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xf, 0xd, 0xc, 0xe, 0x6, 0x2,
473 0x3, 0x7, 0x3, 0x5, 0xe, 0xc, 0xd, 0xf, 0x1, 0xb, 0x9, 0x5,
474 0x0, 0xa, 0xa, 0xb, 0x8, 0x4
477 return ccode_opcodes
[(int)c
];
483 #define REX_MASK 0x4f /* Actual REX prefix bits */
484 #define REX_B 0x01 /* ModRM r/m extension */
485 #define REX_X 0x02 /* SIB index extension */
486 #define REX_R 0x04 /* ModRM reg extension */
487 #define REX_W 0x08 /* 64-bit operand size */
488 #define REX_L 0x20 /* Use LOCK prefix instead of REX.R */
489 #define REX_P 0x40 /* REX prefix present/required */
490 #define REX_H 0x80 /* High register present, REX forbidden */
491 #define REX_V 0x0100 /* Instruction uses VEX/XOP instead of REX */
492 #define REX_NH 0x0200 /* Instruction which doesn't use high regs */
493 #define REX_EV 0x0400 /* Instruction uses EVEX instead of REX */
498 #define EVEX_P0MM 0x0f /* EVEX P[3:0] : Opcode map */
499 #define EVEX_P0RP 0x10 /* EVEX P[4] : High-16 reg */
500 #define EVEX_P0X 0x40 /* EVEX P[6] : High-16 rm */
501 #define EVEX_P1PP 0x03 /* EVEX P[9:8] : Legacy prefix */
502 #define EVEX_P1VVVV 0x78 /* EVEX P[14:11] : NDS register */
503 #define EVEX_P1W 0x80 /* EVEX P[15] : Osize extension */
504 #define EVEX_P2AAA 0x07 /* EVEX P[18:16] : Embedded opmask */
505 #define EVEX_P2VP 0x08 /* EVEX P[19] : High-16 NDS reg */
506 #define EVEX_P2B 0x10 /* EVEX P[20] : Broadcast / RC / SAE */
507 #define EVEX_P2LL 0x60 /* EVEX P[22:21] : Vector length */
508 #define EVEX_P2RC EVEX_P2LL /* EVEX P[22:21] : Rounding control */
509 #define EVEX_P2Z 0x80 /* EVEX P[23] : Zeroing/Merging */
512 * REX_V "classes" (prefixes which behave like VEX)
515 RV_VEX
= 0, /* C4/C5 */
521 * Note that because segment registers may be used as instruction
522 * prefixes, we must ensure the enumerations for prefixes and
523 * register names do not overlap.
525 enum prefixes
{ /* instruction prefixes */
527 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
528 P_A16
= PREFIX_ENUM_START
,
554 enum extop_type
{ /* extended operand types */
556 EOT_DB_STRING
, /* Byte string */
557 EOT_DB_STRING_FREE
, /* Byte string which should be nasm_free'd*/
558 EOT_DB_NUMBER
/* Integer */
561 enum ea_flags
{ /* special EA flags */
562 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
563 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
564 EAF_TIMESTWO
= 4, /* really do EAX*2 not EAX+EAX */
565 EAF_REL
= 8, /* IP-relative addressing */
566 EAF_ABS
= 16, /* non-IP-relative addressing */
567 EAF_FSGS
= 32, /* fs/gs segment override present */
568 EAF_MIB
= 64 /* mib operand */
571 enum eval_hint
{ /* values for `hinttype' */
572 EAH_NOHINT
= 0, /* no hint at all - our discretion */
573 EAH_MAKEBASE
= 1, /* try to make given reg the base */
574 EAH_NOTBASE
= 2, /* try _not_ to make reg the base */
575 EAH_SUMMED
= 3 /* base and index are summed into index */
578 typedef struct operand
{ /* operand to an instruction */
579 opflags_t type
; /* type of operand */
580 int disp_size
; /* 0 means default; 16; 32; 64 */
581 enum reg_enum basereg
;
582 enum reg_enum indexreg
; /* address registers */
583 int scale
; /* index scale */
585 enum eval_hint hinttype
; /* hint as to real base register */
586 int32_t segment
; /* immediate segment, if needed */
587 int64_t offset
; /* any immediate number */
588 int32_t wrt
; /* segment base it's relative to */
589 int eaflags
; /* special EA flags */
590 int opflags
; /* see OPFLAG_* defines below */
591 decoflags_t decoflags
; /* decorator flags such as {...} */
594 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
595 #define OPFLAG_EXTERN 2 /* operand is an external reference */
596 #define OPFLAG_UNKNOWN 4 /* operand is an unknown reference
597 (always a forward reference also) */
598 #define OPFLAG_RELATIVE 8 /* operand is self-relative, e.g. [foo - $]
599 where foo is not in the current segment */
601 typedef struct extop
{ /* extended operand */
602 struct extop
*next
; /* linked list */
603 char *stringval
; /* if it's a string, then here it is */
604 size_t stringlen
; /* ... and here's how long it is */
605 int64_t offset
; /* ... it's given here ... */
606 int32_t segment
; /* if it's a number/address, then... */
607 int32_t wrt
; /* ... and here */
608 bool relative
; /* self-relative expression */
609 enum extop_type type
; /* defined above */
613 EA_INVALID
, /* Not a valid EA at all */
614 EA_SCALAR
, /* Scalar EA */
615 EA_XMMVSIB
, /* XMM vector EA */
616 EA_YMMVSIB
, /* YMM vector EA */
617 EA_ZMMVSIB
/* ZMM vector EA */
621 * Prefix positions: each type of prefix goes in a specific slot.
622 * This affects the final ordering of the assembled output, which
623 * shouldn't matter to the processor, but if you have stylistic
624 * preferences, you can change this. REX prefixes are handled
625 * differently for the time being.
627 * LOCK and REP used to be one slot; this is no longer the case since
628 * the introduction of HLE.
631 PPS_WAIT
, /* WAIT (technically not a prefix!) */
632 PPS_REP
, /* REP/HLE prefix */
633 PPS_LOCK
, /* LOCK prefix */
634 PPS_SEG
, /* Segment override prefix */
635 PPS_OSIZE
, /* Operand size prefix */
636 PPS_ASIZE
, /* Address size prefix */
637 PPS_VEX
, /* VEX type */
638 MAXPREFIX
/* Total number of prefix slots */
642 * Tuple types that are used when determining Disp8*N eligibility
643 * The order must match with a hash %tuple_codes in insns.pl
664 /* EVEX.L'L : Vector length on vector insns */
672 /* If you need to change this, also change it in insns.pl */
673 #define MAX_OPERANDS 5
675 typedef struct insn
{ /* an instruction itself */
676 char *label
; /* the label defined, or NULL */
677 int prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
678 enum opcode opcode
; /* the opcode - not just the string */
679 enum ccode condition
; /* the condition code, if Jcc/SETcc */
680 int operands
; /* how many operands? 0-3 (more if db et al) */
681 int addr_size
; /* address size */
682 operand oprs
[MAX_OPERANDS
]; /* the operands, defined as above */
683 extop
*eops
; /* extended operands */
684 int eops_float
; /* true if DD and floating */
685 int32_t times
; /* repeat count (TIMES prefix) */
686 bool forw_ref
; /* is there a forward reference? */
687 bool rex_done
; /* REX prefix emitted? */
688 int rex
; /* Special REX Prefix */
689 int vexreg
; /* Register encoded in VEX prefix */
690 int vex_cm
; /* Class and M field for VEX prefix */
691 int vex_wlp
; /* W, P and L information for VEX prefix */
692 uint8_t evex_p
[3]; /* EVEX.P0: [RXB,R',00,mm], P1: [W,vvvv,1,pp] */
693 /* EVEX.P2: [z,L'L,b,V',aaa] */
694 enum ttypes evex_tuple
; /* Tuple type for compressed Disp8*N */
695 int evex_rm
; /* static rounding mode for AVX512 (EVEX) */
696 int8_t evex_brerop
; /* BR/ER/SAE operand position */
699 /* Instruction flags type: IF_* flags are defined in insns.h */
700 typedef uint64_t iflags_t
;
703 * What to return from a directive- or pragma-handling function.
704 * Currently DIRR_OK and DIRR_ERROR are treated the same way;
705 * in both cases the backend is expected to produce the appropriate
706 * error message on its own.
708 * DIRR_BADPARAM causes a generic error message to be printed. Note
709 * that it is an error, not a warning, even in the case of pragmas;
710 * don't use it where forward compatiblity would be compromised
711 * (instead consider adding a DIRR_WARNPARAM.)
713 enum directive_result
{
714 DIRR_UNKNOWN
, /* Directive not handled by backend */
715 DIRR_OK
, /* Directive processed */
716 DIRR_ERROR
, /* Directive processed unsuccessfully */
717 DIRR_BADPARAM
/* Print bad argument error message */
721 * A pragma facility: this structure is used to request passing a
722 * parsed pragma directive for a specific facility. If the handler is
723 * NULL then this pragma facility is recognized but ignored; pragma
724 * processing stops at that point.
726 * Note that the handler is passed a pointer to the facility structure
727 * as part of the struct pragma.
731 struct pragma_facility
{
733 enum directive_result (*handler
)(const struct pragma
*);
737 * This structure defines how a pragma directive is passed to a
738 * facility. This structure may be augmented in the future.
740 * Any facility MAY, but is not required to, add its operations
741 * keywords or a subset thereof into asm/directiv.dat, in which case
742 * the "opcode" field will be set to the corresponding D_ constant
743 * from directiv.h; otherwise it will be D_unknown.
746 const struct pragma_facility
*facility
;
747 const char *facility_name
; /* Facility name exactly as entered by user */
748 const char *opname
; /* First word after the facility name */
749 const char *tail
; /* Anything after the operation */
750 enum directive opcode
; /* Operation as a D_ directives constant */
754 * The data structure defining an output format driver, and the
755 * interfaces to the functions therein.
759 * This is a short (one-liner) description of the type of
760 * output generated by the driver.
762 const char *fullname
;
765 * This is a single keyword used to select the driver.
767 const char *shortname
;
770 * Output format flags.
772 #define OFMT_TEXT 1 /* Text file format */
775 int maxbits
; /* Maximum segment bits supported */
778 * this is a pointer to the first element of the debug information
780 const struct dfmt
* const *debug_formats
;
783 * the default debugging format if -F is not specified
785 const struct dfmt
*default_dfmt
;
788 * This, if non-NULL, is a NULL-terminated list of `char *'s
789 * pointing to extra standard macros supplied by the object
790 * format (e.g. a sensible initial default value of __SECT__,
791 * and user-level equivalents for any format-specific
797 * This procedure is called at the start of an output session to set
798 * up internal parameters.
803 * This is the modern output function, which gets passed
804 * a struct out_data with much more information. See the
805 * definition of struct out_data.
807 void (*output
)(const struct out_data
*data
);
810 * This procedure is called by assemble() to write actual
811 * generated code or data to the object file. Typically it
812 * doesn't have to actually _write_ it, just store it for
815 * The `type' argument specifies the type of output data, and
816 * usually the size as well: its contents are described below.
818 * This is used for backends which have not yet been ported to
819 * the new interface, and should be NULL on ported backends.
820 * To use this entry point, set the output pointer to
821 * nasm_do_legacy_output.
823 void (*legacy_output
)(int32_t segto
, const void *data
,
824 enum out_type type
, uint64_t size
,
825 int32_t segment
, int32_t wrt
);
828 * This procedure is called once for every symbol defined in
829 * the module being assembled. It gives the name and value of
830 * the symbol, in NASM's terms, and indicates whether it has
831 * been declared to be global. Note that the parameter "name",
832 * when passed, will point to a piece of static storage
833 * allocated inside the label manager - it's safe to keep using
834 * that pointer, because the label manager doesn't clean up
835 * until after the output driver has.
837 * Values of `is_global' are: 0 means the symbol is local; 1
838 * means the symbol is global; 2 means the symbol is common (in
839 * which case `offset' holds the _size_ of the variable).
840 * Anything else is available for the output driver to use
843 * This routine explicitly _is_ allowed to call the label
844 * manager to define further symbols, if it wants to, even
845 * though it's been called _from_ the label manager. That much
846 * re-entrancy is guaranteed in the label manager. However, the
847 * label manager will in turn call this routine, so it should
848 * be prepared to be re-entrant itself.
850 * The `special' parameter contains special information passed
851 * through from the command that defined the label: it may have
852 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
853 * be obvious to the output format from the other parameters.
855 void (*symdef
)(char *name
, int32_t segment
, int64_t offset
,
856 int is_global
, char *special
);
859 * This procedure is called when the source code requests a
860 * segment change. It should return the corresponding segment
861 * _number_ for the name, or NO_SEG if the name is not a valid
864 * It may also be called with NULL, in which case it is to
865 * return the _default_ section number for starting assembly in.
867 * It is allowed to modify the string it is given a pointer to.
869 * It is also allowed to specify a default instruction size for
870 * the segment, by setting `*bits' to 16 or 32. Or, if it
871 * doesn't wish to define a default, it can leave `bits' alone.
873 int32_t (*section
)(char *name
, int pass
, int *bits
);
876 * This procedure is called to modify section alignment,
877 * note there is a trick, the alignment can only increase
879 void (*sectalign
)(int32_t seg
, unsigned int value
);
882 * This procedure is called to modify the segment base values
883 * returned from the SEG operator. It is given a segment base
884 * value (i.e. a segment value with the low bit set), and is
885 * required to produce in return a segment value which may be
886 * different. It can map segment bases to absolute numbers by
887 * means of returning SEG_ABS types.
889 * It should return NO_SEG if the segment base cannot be
890 * determined; the evaluator (which calls this routine) is
891 * responsible for throwing an error condition if that occurs
892 * in pass two or in a critical expression.
894 int32_t (*segbase
)(int32_t segment
);
897 * This procedure is called to allow the output driver to
898 * process its own specific directives. When called, it has the
899 * directive word in `directive' and the parameter string in
900 * `value'. It is called in both assembly passes, and `pass'
901 * will be either 1 or 2.
903 * The following values are (currently) possible for
906 * 0 - DIRR_UNKNOWN - directive not recognized by backend
907 * 1 - DIRR_OK - directive processed ok
908 * 2 - DIRR_ERROR - backend printed its own error message
909 * 3 - DIRR_BADPARAM - print the generic message
910 * "invalid parameter to [*] directive"
912 enum directive_result
913 (*directive
)(enum directive directive
, char *value
, int pass
);
916 * This procedure is called before anything else - even before
917 * the "init" routine - and is passed the name of the input
918 * file from which this output file is being generated. It
919 * should return its preferred name for the output file in
920 * `outname', if outname[0] is not '\0', and do nothing to
921 * `outname' otherwise. Since it is called before the driver is
922 * properly initialized, it has to be passed its error handler
925 * This procedure may also take its own copy of the input file
926 * name for use in writing the output file: it is _guaranteed_
927 * that it will be called before the "init" routine.
929 * The parameter `outname' points to an area of storage
930 * guaranteed to be at least FILENAME_MAX in size.
932 void (*filename
)(char *inname
, char *outname
);
935 * This procedure is called after assembly finishes, to allow
936 * the output driver to clean itself up and free its memory.
937 * Typically, it will also be the point at which the object
938 * file actually gets _written_.
940 * One thing the cleanup routine should always do is to close
941 * the output file pointer.
943 void (*cleanup
)(void);
946 * List of pragma facility names that apply to this backend.
948 const struct pragma_facility
*pragmas
;
952 * Output format driver alias
955 const char *shortname
;
956 const char *fullname
;
957 const struct ofmt
*ofmt
;
960 extern const struct ofmt
*ofmt
;
964 * ------------------------------------------------------------
965 * The data structure defining a debug format driver, and the
966 * interfaces to the functions therein.
967 * ------------------------------------------------------------
972 * This is a short (one-liner) description of the type of
973 * output generated by the driver.
975 const char *fullname
;
978 * This is a single keyword used to select the driver.
980 const char *shortname
;
983 * init - called initially to set up local pointer to object format.
988 * linenum - called any time there is output with a change of
989 * line number or file.
991 void (*linenum
)(const char *filename
, int32_t linenumber
, int32_t segto
);
994 * debug_deflabel - called whenever a label is defined. Parameters
995 * are the same as to 'symdef()' in the output format. This function
996 * is called after the output format version.
999 void (*debug_deflabel
)(char *name
, int32_t segment
, int64_t offset
,
1000 int is_global
, char *special
);
1002 * debug_directive - called whenever a DEBUG directive other than 'LINE'
1003 * is encountered. 'directive' contains the first parameter to the
1004 * DEBUG directive, and params contains the rest. For example,
1005 * 'DEBUG VAR _somevar:int' would translate to a call to this
1006 * function with 'directive' equal to "VAR" and 'params' equal to
1009 void (*debug_directive
)(const char *directive
, const char *params
);
1012 * typevalue - called whenever the assembler wishes to register a type
1013 * for the last defined label. This routine MUST detect if a type was
1014 * already registered and not re-register it.
1016 void (*debug_typevalue
)(int32_t type
);
1019 * debug_output - called whenever output is required
1020 * 'type' is the type of info required, and this is format-specific
1022 void (*debug_output
)(int type
, void *param
);
1025 * cleanup - called after processing of file is complete
1027 void (*cleanup
)(void);
1030 * List of pragma facility names that apply to this backend.
1032 const struct pragma_facility
*pragmas
;
1035 extern const struct dfmt
*dfmt
;
1038 * The type definition macros
1041 * low 3 bits: reserved
1043 * next 24 bits: number of elements for arrays (0 for labels)
1046 #define TY_UNKNOWN 0x00
1047 #define TY_LABEL 0x08
1048 #define TY_BYTE 0x10
1049 #define TY_WORD 0x18
1050 #define TY_DWORD 0x20
1051 #define TY_FLOAT 0x28
1052 #define TY_QWORD 0x30
1053 #define TY_TBYTE 0x38
1054 #define TY_OWORD 0x40
1055 #define TY_YWORD 0x48
1056 #define TY_COMMON 0xE0
1058 #define TY_EXTERN 0xF0
1061 #define TYM_TYPE(x) ((x) & 0xF8)
1062 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
1064 #define TYS_ELEMENTS(x) ((x) << 8)
1066 enum special_tokens
{
1067 SPECIAL_ENUM_START
= PREFIX_ENUM_LIMIT
,
1068 S_ABS
= SPECIAL_ENUM_START
,
1088 enum decorator_tokens
{
1089 DECORATOR_ENUM_START
= SPECIAL_ENUM_LIMIT
,
1090 BRC_1TO2
= DECORATOR_ENUM_START
,
1100 DECORATOR_ENUM_LIMIT
1104 * AVX512 Decorator (decoflags_t) bits distribution (counted from 0)
1106 * 10987654321098765432109876543210
1109 * ............................1111 opmask
1110 * ...........................1.... zeroing / merging
1111 * ..........................1..... broadcast
1112 * .........................1...... static rounding
1113 * ........................1....... SAE
1114 * ......................11........ broadcast element size
1115 * ....................11.......... number of broadcast elements
1117 #define OP_GENVAL(val, bits, shift) (((val) & ((UINT64_C(1) << (bits)) - 1)) << (shift))
1120 * Opmask register number
1121 * identical to EVEX.aaa
1125 #define OPMASK_SHIFT (0)
1126 #define OPMASK_BITS (4)
1127 #define OPMASK_MASK OP_GENMASK(OPMASK_BITS, OPMASK_SHIFT)
1128 #define GEN_OPMASK(bit) OP_GENBIT(bit, OPMASK_SHIFT)
1129 #define VAL_OPMASK(val) OP_GENVAL(val, OPMASK_BITS, OPMASK_SHIFT)
1132 * zeroing / merging control available
1133 * matching to EVEX.z
1139 #define Z_MASK OP_GENMASK(Z_BITS, Z_SHIFT)
1140 #define GEN_Z(bit) OP_GENBIT(bit, Z_SHIFT)
1143 * broadcast - Whether this operand can be broadcasted
1147 #define BRDCAST_SHIFT (5)
1148 #define BRDCAST_BITS (1)
1149 #define BRDCAST_MASK OP_GENMASK(BRDCAST_BITS, BRDCAST_SHIFT)
1150 #define GEN_BRDCAST(bit) OP_GENBIT(bit, BRDCAST_SHIFT)
1153 * Whether this instruction can have a static rounding mode.
1154 * It goes with the last simd operand because the static rounding mode
1155 * decorator is located between the last simd operand and imm8 (if any).
1159 #define STATICRND_SHIFT (6)
1160 #define STATICRND_BITS (1)
1161 #define STATICRND_MASK OP_GENMASK(STATICRND_BITS, STATICRND_SHIFT)
1162 #define GEN_STATICRND(bit) OP_GENBIT(bit, STATICRND_SHIFT)
1165 * SAE(Suppress all exception) available
1169 #define SAE_SHIFT (7)
1170 #define SAE_BITS (1)
1171 #define SAE_MASK OP_GENMASK(SAE_BITS, SAE_SHIFT)
1172 #define GEN_SAE(bit) OP_GENBIT(bit, SAE_SHIFT)
1175 * Broadcasting element size.
1179 #define BRSIZE_SHIFT (8)
1180 #define BRSIZE_BITS (2)
1181 #define BRSIZE_MASK OP_GENMASK(BRSIZE_BITS, BRSIZE_SHIFT)
1182 #define GEN_BRSIZE(bit) OP_GENBIT(bit, BRSIZE_SHIFT)
1184 #define BR_BITS32 GEN_BRSIZE(0)
1185 #define BR_BITS64 GEN_BRSIZE(1)
1188 * Number of broadcasting elements
1192 #define BRNUM_SHIFT (10)
1193 #define BRNUM_BITS (2)
1194 #define BRNUM_MASK OP_GENMASK(BRNUM_BITS, BRNUM_SHIFT)
1195 #define VAL_BRNUM(val) OP_GENVAL(val, BRNUM_BITS, BRNUM_SHIFT)
1197 #define BR_1TO2 VAL_BRNUM(0)
1198 #define BR_1TO4 VAL_BRNUM(1)
1199 #define BR_1TO8 VAL_BRNUM(2)
1200 #define BR_1TO16 VAL_BRNUM(3)
1202 #define MASK OPMASK_MASK /* Opmask (k1 ~ 7) can be used */
1204 #define B32 (BRDCAST_MASK|BR_BITS32) /* {1to16} : broadcast 32b * 16 to zmm(512b) */
1205 #define B64 (BRDCAST_MASK|BR_BITS64) /* {1to8} : broadcast 64b * 8 to zmm(512b) */
1206 #define ER STATICRND_MASK /* ER(Embedded Rounding) == Static rounding mode */
1207 #define SAE SAE_MASK /* SAE(Suppress All Exception) */
1214 * This declaration passes the "pass" number to all other modules
1215 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
1216 * where 0 = optimizing pass
1222 extern int passn
; /* Actual pass number */
1224 extern bool tasm_compatible_mode
;
1225 extern int optimizing
;
1226 extern int globalbits
; /* 16, 32 or 64-bit mode */
1227 extern int globalrel
; /* default to relative addressing? */
1228 extern int globalbnd
; /* default to using bnd prefix? */