1 | /* ----------------------------------------------------------------------- * |
2 | * |
3 | * Copyright 1996-2018 The NASM Authors - All Rights Reserved |
4 | * See the file AUTHORS included with the NASM distribution for |
5 | * the specific copyright holders. |
6 | * |
7 | * Redistribution and use in source and binary forms, with or without |
8 | * modification, are permitted provided that the following |
9 | * conditions are met: |
10 | * |
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. |
17 | * |
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. |
31 | * |
32 | * ----------------------------------------------------------------------- */ |
33 | |
34 | /* |
35 | * nasm.h main header file for the Netwide Assembler: inter-module interface |
36 | */ |
37 | |
38 | #ifndef NASM_NASM_H |
39 | #define NASM_NASM_H |
40 | |
41 | #include "compiler.h" |
42 | |
43 | #include <stdio.h> |
44 | #include <time.h> |
45 | |
46 | #include "nasmlib.h" |
47 | #include "strlist.h" |
48 | #include "preproc.h" |
49 | #include "insnsi.h" /* For enum opcode */ |
50 | #include "directiv.h" /* For enum directive */ |
51 | #include "labels.h" /* For enum mangle_index, enum label_type */ |
52 | #include "opflags.h" |
53 | #include "regs.h" |
54 | |
55 | /* Time stamp for the official start of compilation */ |
56 | struct compile_time { |
57 | time_t t; |
58 | bool have_local, have_gm, have_posix; |
59 | int64_t posix; |
60 | struct tm local; |
61 | struct tm gm; |
62 | }; |
63 | extern struct compile_time official_compile_time; |
64 | |
65 | #define NO_SEG INT32_C(-1) /* null segment value */ |
66 | #define SEG_ABS 0x40000000L /* mask for far-absolute segments */ |
67 | |
68 | #define IDLEN_MAX 4096 |
69 | #define DECOLEN_MAX 32 |
70 | |
71 | /* |
72 | * Name pollution problems: <time.h> on Digital UNIX pulls in some |
73 | * strange hardware header file which sees fit to define R_SP. We |
74 | * undefine it here so as not to break the enum below. |
75 | */ |
76 | #ifdef R_SP |
77 | #undef R_SP |
78 | #endif |
79 | |
80 | /* |
81 | * We must declare the existence of this structure type up here, |
82 | * since we have to reference it before we define it... |
83 | */ |
84 | struct ofmt; |
85 | |
86 | /* |
87 | * Values for the `type' parameter to an output function. |
88 | */ |
89 | enum out_type { |
90 | OUT_RAWDATA, /* Plain bytes */ |
91 | OUT_RESERVE, /* Reserved bytes (RESB et al) */ |
92 | OUT_ZERODATA, /* Initialized data, but all zero */ |
93 | OUT_ADDRESS, /* An address (symbol value) */ |
94 | OUT_RELADDR, /* A relative address */ |
95 | OUT_SEGMENT, /* A segment number */ |
96 | |
97 | /* |
98 | * These values are used by the legacy backend interface only; |
99 | * see output/legacy.c for more information. These should never |
100 | * be used otherwise. Once all backends have been migrated to the |
101 | * new interface they should be removed. |
102 | */ |
103 | OUT_REL1ADR, |
104 | OUT_REL2ADR, |
105 | OUT_REL4ADR, |
106 | OUT_REL8ADR |
107 | }; |
108 | |
109 | enum out_sign { |
110 | OUT_WRAP, /* Undefined signedness (wraps) */ |
111 | OUT_SIGNED, /* Value is signed */ |
112 | OUT_UNSIGNED /* Value is unsigned */ |
113 | }; |
114 | |
115 | /* |
116 | * The data we send down to the backend. |
117 | * XXX: We still want to push down the base address symbol if |
118 | * available, and replace the segment numbers with a structure. |
119 | */ |
120 | struct out_data { |
121 | int64_t offset; /* Offset within segment */ |
122 | int32_t segment; /* Segment written to */ |
123 | enum out_type type; /* See above */ |
124 | enum out_sign sign; /* See above */ |
125 | int inslen; /* Length of instruction */ |
126 | int insoffs; /* Offset inside instruction */ |
127 | int bits; /* Bits mode of compilation */ |
128 | uint64_t size; /* Size of output */ |
129 | const struct itemplate *itemp; /* Instruction template */ |
130 | const void *data; /* Data for OUT_RAWDATA */ |
131 | uint64_t toffset; /* Target address offset for relocation */ |
132 | int32_t tsegment; /* Target segment for relocation */ |
133 | int32_t twrt; /* Relocation with respect to */ |
134 | int64_t relbase; /* Relative base for OUT_RELADDR */ |
135 | }; |
136 | |
137 | /* |
138 | * And a label-definition function. The boolean parameter |
139 | * `is_norm' states whether the label is a `normal' label (which |
140 | * should affect the local-label system), or something odder like |
141 | * an EQU or a segment-base symbol, which shouldn't. |
142 | */ |
143 | typedef void (*ldfunc)(char *label, int32_t segment, int64_t offset, |
144 | char *special, bool is_norm); |
145 | |
146 | /* |
147 | * Token types returned by the scanner, in addition to ordinary |
148 | * ASCII character values, and zero for end-of-string. |
149 | */ |
150 | enum token_type { /* token types, other than chars */ |
151 | TOKEN_INVALID = -1, /* a placeholder value */ |
152 | TOKEN_EOS = 0, /* end of string */ |
153 | TOKEN_EQ = '=', |
154 | TOKEN_GT = '>', |
155 | TOKEN_LT = '<', /* aliases */ |
156 | TOKEN_ID = 256, /* identifier */ |
157 | TOKEN_NUM, /* numeric constant */ |
158 | TOKEN_ERRNUM, /* malformed numeric constant */ |
159 | TOKEN_STR, /* string constant */ |
160 | TOKEN_ERRSTR, /* unterminated string constant */ |
161 | TOKEN_FLOAT, /* floating-point constant */ |
162 | TOKEN_REG, /* register name */ |
163 | TOKEN_INSN, /* instruction name */ |
164 | TOKEN_HERE, /* $ */ |
165 | TOKEN_BASE, /* $$ */ |
166 | TOKEN_SPECIAL, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */ |
167 | TOKEN_PREFIX, /* A32, O16, LOCK, REPNZ, TIMES, etc */ |
168 | TOKEN_SHL, /* << */ |
169 | TOKEN_SHR, /* >> */ |
170 | TOKEN_SDIV, /* // */ |
171 | TOKEN_SMOD, /* %% */ |
172 | TOKEN_GE, /* >= */ |
173 | TOKEN_LE, /* <= */ |
174 | TOKEN_NE, /* <> (!= is same as <>) */ |
175 | TOKEN_DBL_AND, /* && */ |
176 | TOKEN_DBL_OR, /* || */ |
177 | TOKEN_DBL_XOR, /* ^^ */ |
178 | TOKEN_SEG, /* SEG */ |
179 | TOKEN_WRT, /* WRT */ |
180 | TOKEN_FLOATIZE, /* __floatX__ */ |
181 | TOKEN_STRFUNC, /* __utf16*__, __utf32*__ */ |
182 | TOKEN_IFUNC, /* __ilog2*__ */ |
183 | TOKEN_DECORATOR, /* decorators such as {...} */ |
184 | TOKEN_OPMASK /* translated token for opmask registers */ |
185 | }; |
186 | |
187 | enum floatize { |
188 | FLOAT_8, |
189 | FLOAT_16, |
190 | FLOAT_32, |
191 | FLOAT_64, |
192 | FLOAT_80M, |
193 | FLOAT_80E, |
194 | FLOAT_128L, |
195 | FLOAT_128H |
196 | }; |
197 | |
198 | /* Must match the list in string_transform(), in strfunc.c */ |
199 | enum strfunc { |
200 | STRFUNC_UTF16, |
201 | STRFUNC_UTF16LE, |
202 | STRFUNC_UTF16BE, |
203 | STRFUNC_UTF32, |
204 | STRFUNC_UTF32LE, |
205 | STRFUNC_UTF32BE |
206 | }; |
207 | |
208 | enum ifunc { |
209 | IFUNC_ILOG2E, |
210 | IFUNC_ILOG2W, |
211 | IFUNC_ILOG2F, |
212 | IFUNC_ILOG2C |
213 | }; |
214 | |
215 | size_t string_transform(char *, size_t, char **, enum strfunc); |
216 | |
217 | /* |
218 | * The expression evaluator must be passed a scanner function; a |
219 | * standard scanner is provided as part of nasmlib.c. The |
220 | * preprocessor will use a different one. Scanners, and the |
221 | * token-value structures they return, look like this. |
222 | * |
223 | * The return value from the scanner is always a copy of the |
224 | * `t_type' field in the structure. |
225 | */ |
226 | struct tokenval { |
227 | char *t_charptr; |
228 | int64_t t_integer; |
229 | int64_t t_inttwo; |
230 | enum token_type t_type; |
231 | int8_t t_flag; |
232 | }; |
233 | typedef int (*scanner)(void *private_data, struct tokenval *tv); |
234 | |
235 | struct location { |
236 | int64_t offset; |
237 | int32_t segment; |
238 | int known; |
239 | }; |
240 | extern struct location location; |
241 | |
242 | /* |
243 | * Expression-evaluator datatype. Expressions, within the |
244 | * evaluator, are stored as an array of these beasts, terminated by |
245 | * a record with type==0. Mostly, it's a vector type: each type |
246 | * denotes some kind of a component, and the value denotes the |
247 | * multiple of that component present in the expression. The |
248 | * exception is the WRT type, whose `value' field denotes the |
249 | * segment to which the expression is relative. These segments will |
250 | * be segment-base types, i.e. either odd segment values or SEG_ABS |
251 | * types. So it is still valid to assume that anything with a |
252 | * `value' field of zero is insignificant. |
253 | */ |
254 | typedef struct { |
255 | int32_t type; /* a register, or EXPR_xxx */ |
256 | int64_t value; /* must be >= 32 bits */ |
257 | } expr; |
258 | |
259 | /* |
260 | * Library routines to manipulate expression data types. |
261 | */ |
262 | bool is_reloc(const expr *vect); |
263 | bool is_simple(const expr *vect); |
264 | bool is_really_simple(const expr *vect); |
265 | bool is_unknown(const expr *vect); |
266 | bool is_just_unknown(const expr *vect); |
267 | int64_t reloc_value(const expr *vect); |
268 | int32_t reloc_seg(const expr *vect); |
269 | int32_t reloc_wrt(const expr *vect); |
270 | bool is_self_relative(const expr *vect); |
271 | void dump_expr(const expr *vect); |
272 | |
273 | /* |
274 | * The evaluator can also return hints about which of two registers |
275 | * used in an expression should be the base register. See also the |
276 | * `operand' structure. |
277 | */ |
278 | struct eval_hints { |
279 | int64_t base; |
280 | int type; |
281 | }; |
282 | |
283 | /* |
284 | * The actual expression evaluator function looks like this. When |
285 | * called, it expects the first token of its expression to already |
286 | * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and |
287 | * it will start by calling the scanner. |
288 | * |
289 | * If a forward reference happens during evaluation, the evaluator |
290 | * must set `*fwref' to true if `fwref' is non-NULL. |
291 | * |
292 | * `critical' is non-zero if the expression may not contain forward |
293 | * references. The evaluator will report its own error if this |
294 | * occurs; if `critical' is 1, the error will be "symbol not |
295 | * defined before use", whereas if `critical' is 2, the error will |
296 | * be "symbol undefined". |
297 | * |
298 | * If `critical' has bit 8 set (in addition to its main value: 0x101 |
299 | * and 0x102 correspond to 1 and 2) then an extended expression |
300 | * syntax is recognised, in which relational operators such as =, < |
301 | * and >= are accepted, as well as low-precedence logical operators |
302 | * &&, ^^ and ||. |
303 | * |
304 | * If `hints' is non-NULL, it gets filled in with some hints as to |
305 | * the base register in complex effective addresses. |
306 | */ |
307 | #define CRITICAL 0x100 |
308 | typedef expr *(*evalfunc)(scanner sc, void *scprivate, |
309 | struct tokenval *tv, int *fwref, int critical, |
310 | struct eval_hints *hints); |
311 | |
312 | /* |
313 | * Special values for expr->type. |
314 | * These come after EXPR_REG_END as defined in regs.h. |
315 | * Expr types : 0 ~ EXPR_REG_END, EXPR_UNKNOWN, EXPR_...., EXPR_RDSAE, |
316 | * EXPR_SEGBASE ~ EXPR_SEGBASE + SEG_ABS, ... |
317 | */ |
318 | #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */ |
319 | #define EXPR_SIMPLE (EXPR_REG_END+2) |
320 | #define EXPR_WRT (EXPR_REG_END+3) |
321 | #define EXPR_RDSAE (EXPR_REG_END+4) |
322 | #define EXPR_SEGBASE (EXPR_REG_END+5) |
323 | |
324 | /* |
325 | * preprocessors ought to look like this: |
326 | */ |
327 | struct preproc_ops { |
328 | /* |
329 | * Called once at the very start of assembly. |
330 | */ |
331 | void (*init)(void); |
332 | |
333 | /* |
334 | * Called at the start of a pass; given a file name, the number |
335 | * of the pass, an error reporting function, an evaluator |
336 | * function, and a listing generator to talk to. |
337 | */ |
338 | void (*reset)(const char *file, int pass, StrList **deplist); |
339 | |
340 | /* |
341 | * Called to fetch a line of preprocessed source. The line |
342 | * returned has been malloc'ed, and so should be freed after |
343 | * use. |
344 | */ |
345 | char *(*getline)(void); |
346 | |
347 | /* Called at the end of a pass */ |
348 | void (*cleanup)(int pass); |
349 | |
350 | /* Additional macros specific to output format */ |
351 | void (*)(macros_t *macros); |
352 | |
353 | /* Early definitions and undefinitions for macros */ |
354 | void (*pre_define)(char *definition); |
355 | void (*pre_undefine)(char *definition); |
356 | |
357 | /* Include file from command line */ |
358 | void (*pre_include)(char *fname); |
359 | |
360 | /* Add a command from the command line */ |
361 | void (*pre_command)(const char *what, char *str); |
362 | |
363 | /* Include path from command line */ |
364 | void (*include_path)(char *path); |
365 | |
366 | /* Unwind the macro stack when printing an error message */ |
367 | void (*error_list_macros)(int severity); |
368 | }; |
369 | |
370 | extern const struct preproc_ops nasmpp; |
371 | extern const struct preproc_ops preproc_nop; |
372 | |
373 | /* List of dependency files */ |
374 | extern StrList *depend_list; |
375 | |
376 | /* |
377 | * Some lexical properties of the NASM source language, included |
378 | * here because they are shared between the parser and preprocessor. |
379 | */ |
380 | |
381 | /* |
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 |
386 | * start. |
387 | * isbrcchar matches any character that may placed inside curly braces as a |
388 | * decorator. E.g. {rn-sae}, {1to8}, {k1}{z} |
389 | */ |
390 | |
391 | #define isidstart(c) (nasm_isalpha(c) || \ |
392 | (c) == '_' || \ |
393 | (c) == '.' || \ |
394 | (c) == '?' || \ |
395 | (c) == '@') |
396 | |
397 | #define isidchar(c) (isidstart(c) || \ |
398 | nasm_isdigit(c) || \ |
399 | (c) == '$' || \ |
400 | (c) == '#' || \ |
401 | (c) == '~') |
402 | |
403 | #define isbrcchar(c) (isidchar(c) || \ |
404 | (c) == '-') |
405 | |
406 | /* Ditto for numeric constants. */ |
407 | |
408 | #define isnumstart(c) (nasm_isdigit(c) || (c) == '$') |
409 | #define isnumchar(c) (nasm_isalnum(c) || (c) == '_') |
410 | |
411 | /* |
412 | * inline function to skip past an identifier; returns the first character past |
413 | * the identifier if valid, otherwise NULL. |
414 | */ |
415 | static inline char *nasm_skip_identifier(const char *str) |
416 | { |
417 | const char *p = str; |
418 | |
419 | if (!isidstart(*p++)) { |
420 | p = NULL; |
421 | } else { |
422 | while (isidchar(*p++)) |
423 | ; |
424 | } |
425 | return (char *)p; |
426 | } |
427 | |
428 | /* |
429 | * Data-type flags that get passed to listing-file routines. |
430 | */ |
431 | enum { |
432 | LIST_READ, |
433 | LIST_MACRO, |
434 | LIST_MACRO_NOLIST, |
435 | LIST_INCLUDE, |
436 | LIST_INCBIN, |
437 | LIST_TIMES |
438 | }; |
439 | |
440 | /* |
441 | * ----------------------------------------------------------- |
442 | * Format of the `insn' structure returned from `parser.c' and |
443 | * passed into `assemble.c' |
444 | * ----------------------------------------------------------- |
445 | */ |
446 | |
447 | /* Verify value to be a valid register */ |
448 | static inline bool is_register(int reg) |
449 | { |
450 | return reg >= EXPR_REG_START && reg < REG_ENUM_LIMIT; |
451 | } |
452 | |
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, |
457 | C_none = -1 |
458 | }; |
459 | |
460 | /* |
461 | * token flags |
462 | */ |
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 */ |
468 | |
469 | static inline uint8_t get_cond_opcode(enum ccode c) |
470 | { |
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 |
475 | }; |
476 | |
477 | return ccode_opcodes[(int)c]; |
478 | } |
479 | |
480 | /* |
481 | * REX flags |
482 | */ |
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 */ |
494 | |
495 | /* |
496 | * EVEX bit field |
497 | */ |
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 */ |
510 | |
511 | /* |
512 | * REX_V "classes" (prefixes which behave like VEX) |
513 | */ |
514 | enum vex_class { |
515 | RV_VEX = 0, /* C4/C5 */ |
516 | RV_XOP = 1, /* 8F */ |
517 | RV_EVEX = 2 /* 62 */ |
518 | }; |
519 | |
520 | /* |
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. |
524 | */ |
525 | enum prefixes { /* instruction prefixes */ |
526 | P_none = 0, |
527 | PREFIX_ENUM_START = REG_ENUM_LIMIT, |
528 | P_A16 = PREFIX_ENUM_START, |
529 | P_A32, |
530 | P_A64, |
531 | P_ASP, |
532 | P_LOCK, |
533 | P_O16, |
534 | P_O32, |
535 | P_O64, |
536 | P_OSP, |
537 | P_REP, |
538 | P_REPE, |
539 | P_REPNE, |
540 | P_REPNZ, |
541 | P_REPZ, |
542 | P_TIMES, |
543 | P_WAIT, |
544 | P_XACQUIRE, |
545 | P_XRELEASE, |
546 | P_BND, |
547 | P_NOBND, |
548 | P_EVEX, |
549 | P_VEX3, |
550 | P_VEX2, |
551 | PREFIX_ENUM_LIMIT |
552 | }; |
553 | |
554 | enum extop_type { /* extended operand types */ |
555 | EOT_NOTHING, |
556 | EOT_DB_STRING, /* Byte string */ |
557 | EOT_DB_STRING_FREE, /* Byte string which should be nasm_free'd*/ |
558 | EOT_DB_NUMBER /* Integer */ |
559 | }; |
560 | |
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 */ |
569 | }; |
570 | |
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 */ |
576 | }; |
577 | |
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 */ |
584 | int hintbase; |
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 {...} */ |
592 | } operand; |
593 | |
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 */ |
600 | |
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 */ |
610 | } extop; |
611 | |
612 | enum ea_type { |
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 */ |
618 | }; |
619 | |
620 | /* |
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. |
626 | * |
627 | * LOCK and REP used to be one slot; this is no longer the case since |
628 | * the introduction of HLE. |
629 | */ |
630 | enum prefix_pos { |
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 */ |
639 | }; |
640 | |
641 | /* |
642 | * Tuple types that are used when determining Disp8*N eligibility |
643 | * The order must match with a hash %tuple_codes in insns.pl |
644 | */ |
645 | enum ttypes { |
646 | FV = 001, |
647 | HV = 002, |
648 | FVM = 003, |
649 | T1S8 = 004, |
650 | T1S16 = 005, |
651 | T1S = 006, |
652 | T1F32 = 007, |
653 | T1F64 = 010, |
654 | T2 = 011, |
655 | T4 = 012, |
656 | T8 = 013, |
657 | HVM = 014, |
658 | QVM = 015, |
659 | OVM = 016, |
660 | M128 = 017, |
661 | DUP = 020 |
662 | }; |
663 | |
664 | /* EVEX.L'L : Vector length on vector insns */ |
665 | enum vectlens { |
666 | VL128 = 0, |
667 | VL256 = 1, |
668 | VL512 = 2, |
669 | VLMAX = 3 |
670 | }; |
671 | |
672 | /* If you need to change this, also change it in insns.pl */ |
673 | #define MAX_OPERANDS 5 |
674 | |
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 */ |
697 | } insn; |
698 | |
699 | /* Instruction flags type: IF_* flags are defined in insns.h */ |
700 | typedef uint64_t iflags_t; |
701 | |
702 | /* |
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. |
707 | * |
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.) |
712 | */ |
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 */ |
718 | }; |
719 | |
720 | /* |
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. |
725 | * |
726 | * Note that the handler is passed a pointer to the facility structure |
727 | * as part of the struct pragma. |
728 | */ |
729 | struct pragma; |
730 | typedef enum directive_result (*pragma_handler)(const struct pragma *); |
731 | |
732 | struct pragma_facility { |
733 | const char *name; |
734 | pragma_handler handler; |
735 | }; |
736 | |
737 | /* |
738 | * This structure defines how a pragma directive is passed to a |
739 | * facility. This structure may be augmented in the future. |
740 | * |
741 | * Any facility MAY, but is not required to, add its operations |
742 | * keywords or a subset thereof into asm/directiv.dat, in which case |
743 | * the "opcode" field will be set to the corresponding D_ constant |
744 | * from directiv.h; otherwise it will be D_unknown. |
745 | */ |
746 | struct pragma { |
747 | const struct pragma_facility *facility; |
748 | const char *facility_name; /* Facility name exactly as entered by user */ |
749 | const char *opname; /* First word after the facility name */ |
750 | const char *tail; /* Anything after the operation */ |
751 | enum directive opcode; /* Operation as a D_ directives constant */ |
752 | }; |
753 | |
754 | /* |
755 | * These are semi-arbitrary limits to keep the assembler from going |
756 | * into a black hole on certain kinds of bugs. They can be overridden |
757 | * by command-line options or %pragma. |
758 | */ |
759 | enum nasm_limit { |
760 | LIMIT_PASSES, |
761 | LIMIT_STALLED, |
762 | LIMIT_MACROS, |
763 | LIMIT_REP, |
764 | LIMIT_EVAL, |
765 | LIMIT_LINES |
766 | }; |
767 | #define LIMIT_MAX LIMIT_LINES |
768 | extern int64_t nasm_limit[LIMIT_MAX+1]; |
769 | extern enum directive_result nasm_set_limit(const char *, const char *); |
770 | |
771 | /* |
772 | * The data structure defining an output format driver, and the |
773 | * interfaces to the functions therein. |
774 | */ |
775 | struct ofmt { |
776 | /* |
777 | * This is a short (one-liner) description of the type of |
778 | * output generated by the driver. |
779 | */ |
780 | const char *fullname; |
781 | |
782 | /* |
783 | * This is a single keyword used to select the driver. |
784 | */ |
785 | const char *shortname; |
786 | |
787 | /* |
788 | * Default output filename extension, or a null string |
789 | */ |
790 | const char *extension; |
791 | |
792 | /* |
793 | * Output format flags. |
794 | */ |
795 | #define OFMT_TEXT 1 /* Text file format */ |
796 | #define OFMT_KEEP_ADDR 2 /* Keep addr; no conversion to data */ |
797 | |
798 | unsigned int flags; |
799 | |
800 | int maxbits; /* Maximum segment bits supported */ |
801 | |
802 | /* |
803 | * this is a pointer to the first element of the debug information |
804 | */ |
805 | const struct dfmt * const *debug_formats; |
806 | |
807 | /* |
808 | * the default debugging format if -F is not specified |
809 | */ |
810 | const struct dfmt *default_dfmt; |
811 | |
812 | /* |
813 | * This, if non-NULL, is a NULL-terminated list of `char *'s |
814 | * pointing to extra standard macros supplied by the object |
815 | * format (e.g. a sensible initial default value of __SECT__, |
816 | * and user-level equivalents for any format-specific |
817 | * directives). |
818 | */ |
819 | macros_t *stdmac; |
820 | |
821 | /* |
822 | * This procedure is called at the start of an output session to set |
823 | * up internal parameters. |
824 | */ |
825 | void (*init)(void); |
826 | |
827 | /* |
828 | * This procedure is called at the start of each pass. |
829 | */ |
830 | void (*reset)(void); |
831 | |
832 | /* |
833 | * This is the modern output function, which gets passed |
834 | * a struct out_data with much more information. See the |
835 | * definition of struct out_data. |
836 | */ |
837 | void (*output)(const struct out_data *data); |
838 | |
839 | /* |
840 | * This procedure is called by assemble() to write actual |
841 | * generated code or data to the object file. Typically it |
842 | * doesn't have to actually _write_ it, just store it for |
843 | * later. |
844 | * |
845 | * The `type' argument specifies the type of output data, and |
846 | * usually the size as well: its contents are described below. |
847 | * |
848 | * This is used for backends which have not yet been ported to |
849 | * the new interface, and should be NULL on ported backends. |
850 | * To use this entry point, set the output pointer to |
851 | * nasm_do_legacy_output. |
852 | */ |
853 | void (*legacy_output)(int32_t segto, const void *data, |
854 | enum out_type type, uint64_t size, |
855 | int32_t segment, int32_t wrt); |
856 | |
857 | /* |
858 | * This procedure is called once for every symbol defined in |
859 | * the module being assembled. It gives the name and value of |
860 | * the symbol, in NASM's terms, and indicates whether it has |
861 | * been declared to be global. Note that the parameter "name", |
862 | * when passed, will point to a piece of static storage |
863 | * allocated inside the label manager - it's safe to keep using |
864 | * that pointer, because the label manager doesn't clean up |
865 | * until after the output driver has. |
866 | * |
867 | * Values of `is_global' are: 0 means the symbol is local; 1 |
868 | * means the symbol is global; 2 means the symbol is common (in |
869 | * which case `offset' holds the _size_ of the variable). |
870 | * Anything else is available for the output driver to use |
871 | * internally. |
872 | * |
873 | * This routine explicitly _is_ allowed to call the label |
874 | * manager to define further symbols, if it wants to, even |
875 | * though it's been called _from_ the label manager. That much |
876 | * re-entrancy is guaranteed in the label manager. However, the |
877 | * label manager will in turn call this routine, so it should |
878 | * be prepared to be re-entrant itself. |
879 | * |
880 | * The `special' parameter contains special information passed |
881 | * through from the command that defined the label: it may have |
882 | * been an EXTERN, a COMMON or a GLOBAL. The distinction should |
883 | * be obvious to the output format from the other parameters. |
884 | */ |
885 | void (*symdef)(char *name, int32_t segment, int64_t offset, |
886 | int is_global, char *special); |
887 | |
888 | /* |
889 | * This procedure is called when the source code requests a |
890 | * segment change. It should return the corresponding segment |
891 | * _number_ for the name, or NO_SEG if the name is not a valid |
892 | * segment name. |
893 | * |
894 | * It may also be called with NULL, in which case it is to |
895 | * return the _default_ section number for starting assembly in. |
896 | * |
897 | * It is allowed to modify the string it is given a pointer to. |
898 | * |
899 | * It is also allowed to specify a default instruction size for |
900 | * the segment, by setting `*bits' to 16 or 32. Or, if it |
901 | * doesn't wish to define a default, it can leave `bits' alone. |
902 | */ |
903 | int32_t (*section)(char *name, int pass, int *bits); |
904 | |
905 | /* |
906 | * This function is called when a label is defined |
907 | * in the source code. It is allowed to change the section |
908 | * number as a result, but not the bits value. |
909 | * This is *only* called if the symbol defined is at the |
910 | * current offset, i.e. "foo:" or "foo equ $". |
911 | * The offset isn't passed; and may not be stable at this point. |
912 | * The subsection number is a field available for use by the |
913 | * backend. It is initialized to NO_SEG. |
914 | * |
915 | * If "copyoffset" is set by the backend then the offset is |
916 | * copied from the previous segment, otherwise the new segment |
917 | * is treated as a new segment the normal way. |
918 | */ |
919 | int32_t (*herelabel)(const char *name, enum label_type type, |
920 | int32_t seg, int32_t *subsection, |
921 | bool *copyoffset); |
922 | |
923 | /* |
924 | * This procedure is called to modify section alignment, |
925 | * note there is a trick, the alignment can only increase |
926 | */ |
927 | void (*sectalign)(int32_t seg, unsigned int value); |
928 | |
929 | /* |
930 | * This procedure is called to modify the segment base values |
931 | * returned from the SEG operator. It is given a segment base |
932 | * value (i.e. a segment value with the low bit set), and is |
933 | * required to produce in return a segment value which may be |
934 | * different. It can map segment bases to absolute numbers by |
935 | * means of returning SEG_ABS types. |
936 | * |
937 | * It should return NO_SEG if the segment base cannot be |
938 | * determined; the evaluator (which calls this routine) is |
939 | * responsible for throwing an error condition if that occurs |
940 | * in pass two or in a critical expression. |
941 | */ |
942 | int32_t (*segbase)(int32_t segment); |
943 | |
944 | /* |
945 | * This procedure is called to allow the output driver to |
946 | * process its own specific directives. When called, it has the |
947 | * directive word in `directive' and the parameter string in |
948 | * `value'. It is called in both assembly passes, and `pass' |
949 | * will be either 1 or 2. |
950 | * |
951 | * The following values are (currently) possible for |
952 | * directive_result: |
953 | * |
954 | * 0 - DIRR_UNKNOWN - directive not recognized by backend |
955 | * 1 - DIRR_OK - directive processed ok |
956 | * 2 - DIRR_ERROR - backend printed its own error message |
957 | * 3 - DIRR_BADPARAM - print the generic message |
958 | * "invalid parameter to [*] directive" |
959 | */ |
960 | enum directive_result |
961 | (*directive)(enum directive directive, char *value, int pass); |
962 | |
963 | /* |
964 | * This procedure is called after assembly finishes, to allow |
965 | * the output driver to clean itself up and free its memory. |
966 | * Typically, it will also be the point at which the object |
967 | * file actually gets _written_. |
968 | * |
969 | * One thing the cleanup routine should always do is to close |
970 | * the output file pointer. |
971 | */ |
972 | void (*cleanup)(void); |
973 | |
974 | /* |
975 | * List of pragma facility names that apply to this backend. |
976 | */ |
977 | const struct pragma_facility *pragmas; |
978 | }; |
979 | |
980 | /* |
981 | * Output format driver alias |
982 | */ |
983 | struct ofmt_alias { |
984 | const char *shortname; |
985 | const char *fullname; |
986 | const struct ofmt *ofmt; |
987 | }; |
988 | |
989 | extern const struct ofmt *ofmt; |
990 | extern FILE *ofile; |
991 | |
992 | /* |
993 | * ------------------------------------------------------------ |
994 | * The data structure defining a debug format driver, and the |
995 | * interfaces to the functions therein. |
996 | * ------------------------------------------------------------ |
997 | */ |
998 | |
999 | struct dfmt { |
1000 | /* |
1001 | * This is a short (one-liner) description of the type of |
1002 | * output generated by the driver. |
1003 | */ |
1004 | const char *fullname; |
1005 | |
1006 | /* |
1007 | * This is a single keyword used to select the driver. |
1008 | */ |
1009 | const char *shortname; |
1010 | |
1011 | /* |
1012 | * init - called initially to set up local pointer to object format. |
1013 | */ |
1014 | void (*init)(void); |
1015 | |
1016 | /* |
1017 | * linenum - called any time there is output with a change of |
1018 | * line number or file. |
1019 | */ |
1020 | void (*linenum)(const char *filename, int32_t linenumber, int32_t segto); |
1021 | |
1022 | /* |
1023 | * debug_deflabel - called whenever a label is defined. Parameters |
1024 | * are the same as to 'symdef()' in the output format. This function |
1025 | * is called after the output format version. |
1026 | */ |
1027 | |
1028 | void (*debug_deflabel)(char *name, int32_t segment, int64_t offset, |
1029 | int is_global, char *special); |
1030 | /* |
1031 | * debug_directive - called whenever a DEBUG directive other than 'LINE' |
1032 | * is encountered. 'directive' contains the first parameter to the |
1033 | * DEBUG directive, and params contains the rest. For example, |
1034 | * 'DEBUG VAR _somevar:int' would translate to a call to this |
1035 | * function with 'directive' equal to "VAR" and 'params' equal to |
1036 | * "_somevar:int". |
1037 | */ |
1038 | void (*debug_directive)(const char *directive, const char *params); |
1039 | |
1040 | /* |
1041 | * typevalue - called whenever the assembler wishes to register a type |
1042 | * for the last defined label. This routine MUST detect if a type was |
1043 | * already registered and not re-register it. |
1044 | */ |
1045 | void (*debug_typevalue)(int32_t type); |
1046 | |
1047 | /* |
1048 | * debug_output - called whenever output is required |
1049 | * 'type' is the type of info required, and this is format-specific |
1050 | */ |
1051 | void (*debug_output)(int type, void *param); |
1052 | |
1053 | /* |
1054 | * cleanup - called after processing of file is complete |
1055 | */ |
1056 | void (*cleanup)(void); |
1057 | |
1058 | /* |
1059 | * List of pragma facility names that apply to this backend. |
1060 | */ |
1061 | const struct pragma_facility *pragmas; |
1062 | }; |
1063 | |
1064 | extern const struct dfmt *dfmt; |
1065 | |
1066 | /* |
1067 | * The type definition macros |
1068 | * for debugging |
1069 | * |
1070 | * low 3 bits: reserved |
1071 | * next 5 bits: type |
1072 | * next 24 bits: number of elements for arrays (0 for labels) |
1073 | */ |
1074 | |
1075 | #define TY_UNKNOWN 0x00 |
1076 | #define TY_LABEL 0x08 |
1077 | #define TY_BYTE 0x10 |
1078 | #define TY_WORD 0x18 |
1079 | #define TY_DWORD 0x20 |
1080 | #define TY_FLOAT 0x28 |
1081 | #define TY_QWORD 0x30 |
1082 | #define TY_TBYTE 0x38 |
1083 | #define TY_OWORD 0x40 |
1084 | #define TY_YWORD 0x48 |
1085 | #define TY_ZWORD 0x50 |
1086 | #define TY_COMMON 0xE0 |
1087 | #define TY_SEG 0xE8 |
1088 | #define TY_EXTERN 0xF0 |
1089 | #define TY_EQU 0xF8 |
1090 | |
1091 | #define TYM_TYPE(x) ((x) & 0xF8) |
1092 | #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8) |
1093 | |
1094 | #define TYS_ELEMENTS(x) ((x) << 8) |
1095 | |
1096 | enum special_tokens { |
1097 | SPECIAL_ENUM_START = PREFIX_ENUM_LIMIT, |
1098 | S_ABS = SPECIAL_ENUM_START, |
1099 | S_BYTE, |
1100 | S_DWORD, |
1101 | S_FAR, |
1102 | S_LONG, |
1103 | S_NEAR, |
1104 | S_NOSPLIT, |
1105 | S_OWORD, |
1106 | S_QWORD, |
1107 | S_REL, |
1108 | S_SHORT, |
1109 | S_STRICT, |
1110 | S_TO, |
1111 | S_TWORD, |
1112 | S_WORD, |
1113 | S_YWORD, |
1114 | S_ZWORD, |
1115 | SPECIAL_ENUM_LIMIT |
1116 | }; |
1117 | |
1118 | enum decorator_tokens { |
1119 | DECORATOR_ENUM_START = SPECIAL_ENUM_LIMIT, |
1120 | BRC_1TO2 = DECORATOR_ENUM_START, |
1121 | BRC_1TO4, |
1122 | BRC_1TO8, |
1123 | BRC_1TO16, |
1124 | BRC_RN, |
1125 | BRC_RD, |
1126 | BRC_RU, |
1127 | BRC_RZ, |
1128 | BRC_SAE, |
1129 | BRC_Z, |
1130 | DECORATOR_ENUM_LIMIT |
1131 | }; |
1132 | |
1133 | /* |
1134 | * AVX512 Decorator (decoflags_t) bits distribution (counted from 0) |
1135 | * 3 2 1 |
1136 | * 10987654321098765432109876543210 |
1137 | * | |
1138 | * | word boundary |
1139 | * ............................1111 opmask |
1140 | * ...........................1.... zeroing / merging |
1141 | * ..........................1..... broadcast |
1142 | * .........................1...... static rounding |
1143 | * ........................1....... SAE |
1144 | * ......................11........ broadcast element size |
1145 | * ....................11.......... number of broadcast elements |
1146 | */ |
1147 | #define OP_GENVAL(val, bits, shift) (((val) & ((UINT64_C(1) << (bits)) - 1)) << (shift)) |
1148 | |
1149 | /* |
1150 | * Opmask register number |
1151 | * identical to EVEX.aaa |
1152 | * |
1153 | * Bits: 0 - 3 |
1154 | */ |
1155 | #define OPMASK_SHIFT (0) |
1156 | #define OPMASK_BITS (4) |
1157 | #define OPMASK_MASK OP_GENMASK(OPMASK_BITS, OPMASK_SHIFT) |
1158 | #define GEN_OPMASK(bit) OP_GENBIT(bit, OPMASK_SHIFT) |
1159 | #define VAL_OPMASK(val) OP_GENVAL(val, OPMASK_BITS, OPMASK_SHIFT) |
1160 | |
1161 | /* |
1162 | * zeroing / merging control available |
1163 | * matching to EVEX.z |
1164 | * |
1165 | * Bits: 4 |
1166 | */ |
1167 | #define Z_SHIFT (4) |
1168 | #define Z_BITS (1) |
1169 | #define Z_MASK OP_GENMASK(Z_BITS, Z_SHIFT) |
1170 | #define GEN_Z(bit) OP_GENBIT(bit, Z_SHIFT) |
1171 | |
1172 | /* |
1173 | * broadcast - Whether this operand can be broadcasted |
1174 | * |
1175 | * Bits: 5 |
1176 | */ |
1177 | #define BRDCAST_SHIFT (5) |
1178 | #define BRDCAST_BITS (1) |
1179 | #define BRDCAST_MASK OP_GENMASK(BRDCAST_BITS, BRDCAST_SHIFT) |
1180 | #define GEN_BRDCAST(bit) OP_GENBIT(bit, BRDCAST_SHIFT) |
1181 | |
1182 | /* |
1183 | * Whether this instruction can have a static rounding mode. |
1184 | * It goes with the last simd operand because the static rounding mode |
1185 | * decorator is located between the last simd operand and imm8 (if any). |
1186 | * |
1187 | * Bits: 6 |
1188 | */ |
1189 | #define STATICRND_SHIFT (6) |
1190 | #define STATICRND_BITS (1) |
1191 | #define STATICRND_MASK OP_GENMASK(STATICRND_BITS, STATICRND_SHIFT) |
1192 | #define GEN_STATICRND(bit) OP_GENBIT(bit, STATICRND_SHIFT) |
1193 | |
1194 | /* |
1195 | * SAE(Suppress all exception) available |
1196 | * |
1197 | * Bits: 7 |
1198 | */ |
1199 | #define SAE_SHIFT (7) |
1200 | #define SAE_BITS (1) |
1201 | #define SAE_MASK OP_GENMASK(SAE_BITS, SAE_SHIFT) |
1202 | #define GEN_SAE(bit) OP_GENBIT(bit, SAE_SHIFT) |
1203 | |
1204 | /* |
1205 | * Broadcasting element size. |
1206 | * |
1207 | * Bits: 8 - 9 |
1208 | */ |
1209 | #define BRSIZE_SHIFT (8) |
1210 | #define BRSIZE_BITS (2) |
1211 | #define BRSIZE_MASK OP_GENMASK(BRSIZE_BITS, BRSIZE_SHIFT) |
1212 | #define GEN_BRSIZE(bit) OP_GENBIT(bit, BRSIZE_SHIFT) |
1213 | |
1214 | #define BR_BITS32 GEN_BRSIZE(0) |
1215 | #define BR_BITS64 GEN_BRSIZE(1) |
1216 | |
1217 | /* |
1218 | * Number of broadcasting elements |
1219 | * |
1220 | * Bits: 10 - 11 |
1221 | */ |
1222 | #define BRNUM_SHIFT (10) |
1223 | #define BRNUM_BITS (2) |
1224 | #define BRNUM_MASK OP_GENMASK(BRNUM_BITS, BRNUM_SHIFT) |
1225 | #define VAL_BRNUM(val) OP_GENVAL(val, BRNUM_BITS, BRNUM_SHIFT) |
1226 | |
1227 | #define BR_1TO2 VAL_BRNUM(0) |
1228 | #define BR_1TO4 VAL_BRNUM(1) |
1229 | #define BR_1TO8 VAL_BRNUM(2) |
1230 | #define BR_1TO16 VAL_BRNUM(3) |
1231 | |
1232 | #define MASK OPMASK_MASK /* Opmask (k1 ~ 7) can be used */ |
1233 | #define Z Z_MASK |
1234 | #define B32 (BRDCAST_MASK|BR_BITS32) /* {1to16} : broadcast 32b * 16 to zmm(512b) */ |
1235 | #define B64 (BRDCAST_MASK|BR_BITS64) /* {1to8} : broadcast 64b * 8 to zmm(512b) */ |
1236 | #define ER STATICRND_MASK /* ER(Embedded Rounding) == Static rounding mode */ |
1237 | #define SAE SAE_MASK /* SAE(Suppress All Exception) */ |
1238 | |
1239 | /* |
1240 | * Global modes |
1241 | */ |
1242 | |
1243 | /* |
1244 | * This declaration passes the "pass" number to all other modules |
1245 | * "pass0" assumes the values: 0, 0, ..., 0, 1, 2 |
1246 | * where 0 = optimizing pass |
1247 | * 1 = pass 1 |
1248 | * 2 = pass 2 |
1249 | */ |
1250 | |
1251 | /* |
1252 | * flag to disable optimizations selectively |
1253 | * this is useful to turn-off certain optimizations |
1254 | */ |
1255 | enum optimization_disable_flag { |
1256 | OPTIM_ALL_ENABLED = 0, |
1257 | OPTIM_DISABLE_JMP_MATCH = 1 |
1258 | }; |
1259 | |
1260 | struct optimization { |
1261 | int level; |
1262 | int flag; |
1263 | }; |
1264 | |
1265 | extern int pass0; |
1266 | extern int64_t passn; /* Actual pass number */ |
1267 | |
1268 | extern bool tasm_compatible_mode; |
1269 | extern struct optimization optimizing; |
1270 | extern int globalbits; /* 16, 32 or 64-bit mode */ |
1271 | extern int globalrel; /* default to relative addressing? */ |
1272 | extern int globalbnd; /* default to using bnd prefix? */ |
1273 | |
1274 | extern const char *inname; /* primary input filename */ |
1275 | extern const char *outname; /* output filename */ |
1276 | |
1277 | /* |
1278 | * Switch to a different segment and return the current offset |
1279 | */ |
1280 | int64_t switch_segment(int32_t segment); |
1281 | |
1282 | #endif |
1283 | |