nasm.h

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2013 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 <inttypes.h>
  45 #include "nasmlib.h"
  46 #include "preproc.h"
  47 #include "insnsi.h"     /* For enum opcode */
  48 #include "directiv.h"   /* For enum directive */
  49 #include "opflags.h"
  50 #include "regs.h"
  51
  52 #define NO_SEG -1L              /* null segment value */
  53 #define SEG_ABS 0x40000000L     /* mask for far-absolute segments */
  54
  55 #ifndef FILENAME_MAX
  56 #define FILENAME_MAX 256
  57 #endif
  58
  59 #ifndef PREFIX_MAX
  60 #define PREFIX_MAX 10
  61 #endif
  62
  63 #ifndef POSTFIX_MAX
  64 #define POSTFIX_MAX 10
  65 #endif
  66
  67 #define IDLEN_MAX 4096
  68
  69 /*
  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.
  73  */
  74 #ifdef R_SP
  75 #undef R_SP
  76 #endif
  77
  78 /*
  79  * We must declare the existence of this structure type up here,
  80  * since we have to reference it before we define it...
  81  */
  82 struct ofmt;
  83
  84 /*
  85  * Values for the `type' parameter to an output function.
  86  *
  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.
  92  *
  93  * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
  94  * and the contents of the "data" parameter is irrelevant.
  95  *
  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"
  99  * array.
 100  */
 101 enum out_type {
 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 */
 109 };
 110
 111 /*
 112  * A label-lookup function.
 113  */
 114 typedef bool (*lfunc)(char *label, int32_t *segment, int64_t *offset);
 115
 116 /*
 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.
 121  */
 122 typedef void (*ldfunc)(char *label, int32_t segment, int64_t offset,
 123                        char *special, bool is_norm, bool isextrn);
 124
 125 void define_label(char *label, int32_t segment, int64_t offset,
 126                   char *special, bool is_norm, bool isextrn);
 127
 128 /*
 129  * List-file generators should look like this:
 130  */
 131 typedef struct {
 132     /*
 133      * Called to initialize the listing file generator. Before this
 134      * is called, the other routines will silently do nothing when
 135      * called. The `char *' parameter is the file name to write the
 136      * listing to.
 137      */
 138     void (*init)(char *fname, efunc error);
 139
 140     /*
 141      * Called to clear stuff up and close the listing file.
 142      */
 143     void (*cleanup)(void);
 144
 145     /*
 146      * Called to output binary data. Parameters are: the offset;
 147      * the data; the data type. Data types are similar to the
 148      * output-format interface, only OUT_ADDRESS will _always_ be
 149      * displayed as if it's relocatable, so ensure that any non-
 150      * relocatable address has been converted to OUT_RAWDATA by
 151      * then. Note that OUT_RAWDATA,0 is a valid data type, and is a
 152      * dummy call used to give the listing generator an offset to
 153      * work with when doing things like uplevel(LIST_TIMES) or
 154      * uplevel(LIST_INCBIN).
 155      */
 156     void (*output)(int32_t offset, const void *data, enum out_type type, uint64_t size);
 157
 158     /*
 159      * Called to send a text line to the listing generator. The
 160      * `int' parameter is LIST_READ or LIST_MACRO depending on
 161      * whether the line came directly from an input file or is the
 162      * result of a multi-line macro expansion.
 163      */
 164     void (*line)(int type, char *line);
 165
 166     /*
 167      * Called to change one of the various levelled mechanisms in
 168      * the listing generator. LIST_INCLUDE and LIST_MACRO can be
 169      * used to increase the nesting level of include files and
 170      * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
 171      * two binary-output-suppression mechanisms for large-scale
 172      * pseudo-instructions.
 173      *
 174      * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
 175      * it indicates the beginning of the expansion of a `nolist'
 176      * macro, so anything under that level won't be expanded unless
 177      * it includes another file.
 178      */
 179     void (*uplevel)(int type);
 180
 181     /*
 182      * Reverse the effects of uplevel.
 183      */
 184     void (*downlevel)(int type);
 185
 186     /*
 187      * Called on a warning or error, with the error message.
 188      */
 189     void (*error)(int severity, const char *pfx, const char *msg);
 190 } ListGen;
 191
 192 /*
 193  * Token types returned by the scanner, in addition to ordinary
 194  * ASCII character values, and zero for end-of-string.
 195  */
 196 enum token_type { /* token types, other than chars */
 197     TOKEN_INVALID = -1, /* a placeholder value */
 198     TOKEN_EOS = 0,      /* end of string */
 199     TOKEN_EQ = '=',
 200     TOKEN_GT = '>',
 201     TOKEN_LT = '<',     /* aliases */
 202     TOKEN_ID = 256,     /* identifier */
 203     TOKEN_NUM,          /* numeric constant */
 204     TOKEN_ERRNUM,       /* malformed numeric constant */
 205     TOKEN_STR,          /* string constant */
 206     TOKEN_ERRSTR,       /* unterminated string constant */
 207     TOKEN_FLOAT,        /* floating-point constant */
 208     TOKEN_REG,          /* register name */
 209     TOKEN_INSN,         /* instruction name */
 210     TOKEN_HERE,         /* $ */
 211     TOKEN_BASE,         /* $$ */
 212     TOKEN_SPECIAL,      /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
 213     TOKEN_PREFIX,       /* A32, O16, LOCK, REPNZ, TIMES, etc */
 214     TOKEN_SHL,          /* << */
 215     TOKEN_SHR,          /* >> */
 216     TOKEN_SDIV,         /* // */
 217     TOKEN_SMOD,         /* %% */
 218     TOKEN_GE,           /* >= */
 219     TOKEN_LE,           /* <= */
 220     TOKEN_NE,           /* <> (!= is same as <>) */
 221     TOKEN_DBL_AND,      /* && */
 222     TOKEN_DBL_OR,       /* || */
 223     TOKEN_DBL_XOR,      /* ^^ */
 224     TOKEN_SEG,          /* SEG */
 225     TOKEN_WRT,          /* WRT */
 226     TOKEN_FLOATIZE,     /* __floatX__ */
 227     TOKEN_STRFUNC,      /* __utf16*__, __utf32*__ */
 228     TOKEN_IFUNC,        /* __ilog2*__ */
 229     TOKEN_DECORATOR,    /* decorators such as {...} */
 230     TOKEN_OPMASK,       /* translated token for opmask registers */
 231 };
 232
 233 enum floatize {
 234     FLOAT_8,
 235     FLOAT_16,
 236     FLOAT_32,
 237     FLOAT_64,
 238     FLOAT_80M,
 239     FLOAT_80E,
 240     FLOAT_128L,
 241     FLOAT_128H,
 242 };
 243
 244 /* Must match the list in string_transform(), in strfunc.c */
 245 enum strfunc {
 246     STRFUNC_UTF16,
 247     STRFUNC_UTF16LE,
 248     STRFUNC_UTF16BE,
 249     STRFUNC_UTF32,
 250     STRFUNC_UTF32LE,
 251     STRFUNC_UTF32BE,
 252 };
 253
 254 enum ifunc {
 255     IFUNC_ILOG2E,
 256     IFUNC_ILOG2W,
 257     IFUNC_ILOG2F,
 258     IFUNC_ILOG2C,
 259 };
 260
 261 size_t string_transform(char *, size_t, char **, enum strfunc);
 262
 263 /*
 264  * The expression evaluator must be passed a scanner function; a
 265  * standard scanner is provided as part of nasmlib.c. The
 266  * preprocessor will use a different one. Scanners, and the
 267  * token-value structures they return, look like this.
 268  *
 269  * The return value from the scanner is always a copy of the
 270  * `t_type' field in the structure.
 271  */
 272 struct tokenval {
 273     char                *t_charptr;
 274     int64_t             t_integer;
 275     int64_t             t_inttwo;
 276     enum token_type     t_type;
 277     int8_t              t_flag;
 278 };
 279 typedef int (*scanner)(void *private_data, struct tokenval *tv);
 280
 281 struct location {
 282     int64_t offset;
 283     int32_t segment;
 284     int     known;
 285 };
 286
 287 /*
 288  * Expression-evaluator datatype. Expressions, within the
 289  * evaluator, are stored as an array of these beasts, terminated by
 290  * a record with type==0. Mostly, it's a vector type: each type
 291  * denotes some kind of a component, and the value denotes the
 292  * multiple of that component present in the expression. The
 293  * exception is the WRT type, whose `value' field denotes the
 294  * segment to which the expression is relative. These segments will
 295  * be segment-base types, i.e. either odd segment values or SEG_ABS
 296  * types. So it is still valid to assume that anything with a
 297  * `value' field of zero is insignificant.
 298  */
 299 typedef struct {
 300     int32_t type;                  /* a register, or EXPR_xxx */
 301     int64_t value;                 /* must be >= 32 bits */
 302 } expr;
 303
 304 /*
 305  * Library routines to manipulate expression data types.
 306  */
 307 int is_reloc(expr *vect);
 308 int is_simple(expr *vect);
 309 int is_really_simple(expr *vect);
 310 int is_unknown(expr *vect);
 311 int is_just_unknown(expr *vect);
 312 int64_t reloc_value(expr *vect);
 313 int32_t reloc_seg(expr *vect);
 314 int32_t reloc_wrt(expr *vect);
 315
 316 /*
 317  * The evaluator can also return hints about which of two registers
 318  * used in an expression should be the base register. See also the
 319  * `operand' structure.
 320  */
 321 struct eval_hints {
 322     int64_t base;
 323     int     type;
 324 };
 325
 326 /*
 327  * The actual expression evaluator function looks like this. When
 328  * called, it expects the first token of its expression to already
 329  * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
 330  * it will start by calling the scanner.
 331  *
 332  * If a forward reference happens during evaluation, the evaluator
 333  * must set `*fwref' to true if `fwref' is non-NULL.
 334  *
 335  * `critical' is non-zero if the expression may not contain forward
 336  * references. The evaluator will report its own error if this
 337  * occurs; if `critical' is 1, the error will be "symbol not
 338  * defined before use", whereas if `critical' is 2, the error will
 339  * be "symbol undefined".
 340  *
 341  * If `critical' has bit 8 set (in addition to its main value: 0x101
 342  * and 0x102 correspond to 1 and 2) then an extended expression
 343  * syntax is recognised, in which relational operators such as =, <
 344  * and >= are accepted, as well as low-precedence logical operators
 345  * &&, ^^ and ||.
 346  *
 347  * If `hints' is non-NULL, it gets filled in with some hints as to
 348  * the base register in complex effective addresses.
 349  */
 350 #define CRITICAL 0x100
 351 typedef expr *(*evalfunc)(scanner sc, void *scprivate,
 352                           struct tokenval *tv, int *fwref, int critical,
 353                           efunc error, struct eval_hints *hints);
 354
 355 /*
 356  * Special values for expr->type.
 357  * These come after EXPR_REG_END as defined in regs.h.
 358  * Expr types : 0 ~ EXPR_REG_END, EXPR_UNKNOWN, EXPR_...., EXPR_RDSAE,
 359  *              EXPR_SEGBASE ~ EXPR_SEGBASE + SEG_ABS, ...
 360  */
 361 #define EXPR_UNKNOWN    (EXPR_REG_END+1) /* forward references */
 362 #define EXPR_SIMPLE     (EXPR_REG_END+2)
 363 #define EXPR_WRT        (EXPR_REG_END+3)
 364 #define EXPR_RDSAE      (EXPR_REG_END+4)
 365 #define EXPR_SEGBASE    (EXPR_REG_END+5)
 366
 367 /*
 368  * Linked list of strings
 369  */
 370 typedef struct string_list {
 371     struct string_list  *next;
 372     char                str[1];
 373 } StrList;
 374
 375 /*
 376  * preprocessors ought to look like this:
 377  */
 378 struct preproc_ops {
 379     /*
 380      * Called at the start of a pass; given a file name, the number
 381      * of the pass, an error reporting function, an evaluator
 382      * function, and a listing generator to talk to.
 383      */
 384     void (*reset)(char *file, int pass, ListGen *listgen, StrList **deplist);
 385
 386     /*
 387      * Called to fetch a line of preprocessed source. The line
 388      * returned has been malloc'ed, and so should be freed after
 389      * use.
 390      */
 391     char *(*getline)(void);
 392
 393     /* Called at the end of a pass */
 394     void (*cleanup)(int pass);
 395
 396     /* Additional macros specific to output format */
 397     void (*extra_stdmac)(macros_t *macros);
 398
 399     /* Early definitions and undefinitions for macros */
 400     void (*pre_define)(char *definition);
 401     void (*pre_undefine)(char *definition);
 402
 403     /* Include file from command line */
 404     void (*pre_include)(char *fname);
 405
 406     /* Include path from command line */
 407     void (*include_path)(char *path);
 408 };
 409
 410 extern struct preproc_ops nasmpp;
 411 extern struct preproc_ops preproc_nop;
 412
 413 /*
 414  * Some lexical properties of the NASM source language, included
 415  * here because they are shared between the parser and preprocessor.
 416  */
 417
 418 /*
 419  * isidstart matches any character that may start an identifier, and isidchar
 420  * matches any character that may appear at places other than the start of an
 421  * identifier. E.g. a period may only appear at the start of an identifier
 422  * (for local labels), whereas a number may appear anywhere *but* at the
 423  * start.
 424  */
 425
 426 #define isidstart(c) (nasm_isalpha(c)   ||  \
 427                       (c) == '_'        ||  \
 428                       (c) == '.'        ||  \
 429                       (c) == '?'        ||  \
 430                       (c) == '@')
 431
 432 #define isidchar(c) (isidstart(c)       ||  \
 433                      nasm_isdigit(c)    ||  \
 434                      (c) == '$'         ||  \
 435                      (c) == '#'         ||  \
 436                      (c) == '~')
 437
 438 /* Ditto for numeric constants. */
 439
 440 #define isnumstart(c)  (nasm_isdigit(c) || (c) == '$')
 441 #define isnumchar(c)   (nasm_isalnum(c) || (c) == '_')
 442
 443 /*
 444  * Data-type flags that get passed to listing-file routines.
 445  */
 446 enum {
 447     LIST_READ,
 448     LIST_MACRO,
 449     LIST_MACRO_NOLIST,
 450     LIST_INCLUDE,
 451     LIST_INCBIN,
 452     LIST_TIMES
 453 };
 454
 455 /*
 456  * -----------------------------------------------------------
 457  * Format of the `insn' structure returned from `parser.c' and
 458  * passed into `assemble.c'
 459  * -----------------------------------------------------------
 460  */
 461
 462 /* Verify value to be a valid register */
 463 static inline bool is_register(int reg)
 464 {
 465     return reg >= EXPR_REG_START && reg < REG_ENUM_LIMIT;
 466 }
 467
 468 enum ccode { /* condition code names */
 469     C_A, C_AE, C_B, C_BE, C_C, C_E, C_G, C_GE, C_L, C_LE, C_NA, C_NAE,
 470     C_NB, C_NBE, C_NC, C_NE, C_NG, C_NGE, C_NL, C_NLE, C_NO, C_NP,
 471     C_NS, C_NZ, C_O, C_P, C_PE, C_PO, C_S, C_Z,
 472     C_none = -1
 473 };
 474
 475 /*
 476  * token flags
 477  */
 478 #define TFLAG_BRC       (1 << 0)    /* valid only with braces. {1to8}, {rd-sae}, ...*/
 479 #define TFLAG_BRC_OPT   (1 << 1)    /* may or may not have braces. opmasks {k1} */
 480 #define TFLAG_BRC_ANY   (TFLAG_BRC | TFLAG_BRC_OPT)
 481 #define TFLAG_BRDCAST   (1 << 2)    /* broadcasting decorator */
 482
 483 static inline uint8_t get_cond_opcode(enum ccode c)
 484 {
 485     static const uint8_t ccode_opcodes[] = {
 486         0x7, 0x3, 0x2, 0x6, 0x2, 0x4, 0xf, 0xd, 0xc, 0xe, 0x6, 0x2,
 487         0x3, 0x7, 0x3, 0x5, 0xe, 0xc, 0xd, 0xf, 0x1, 0xb, 0x9, 0x5,
 488         0x0, 0xa, 0xa, 0xb, 0x8, 0x4
 489     };
 490
 491         return ccode_opcodes[(int)c];
 492 }
 493
 494 /*
 495  * REX flags
 496  */
 497 #define REX_REAL    0x4f    /* Actual REX prefix bits */
 498 #define REX_B       0x01    /* ModRM r/m extension */
 499 #define REX_X       0x02    /* SIB index extension */
 500 #define REX_R       0x04    /* ModRM reg extension */
 501 #define REX_W       0x08    /* 64-bit operand size */
 502 #define REX_L       0x20    /* Use LOCK prefix instead of REX.R */
 503 #define REX_P       0x40    /* REX prefix present/required */
 504 #define REX_H       0x80    /* High register present, REX forbidden */
 505 #define REX_V       0x0100  /* Instruction uses VEX/XOP instead of REX */
 506 #define REX_NH      0x0200  /* Instruction which doesn't use high regs */
 507 #define REX_EV      0x0400  /* Instruction uses EVEX instead of REX */
 508
 509 /*
 510  * EVEX bit field
 511  */
 512 #define EVEX_P0RP       0x10        /* EVEX P[4] : High-16 reg            */
 513 #define EVEX_P0X        0x40        /* EVEX P[6] : High-16 rm             */
 514 #define EVEX_P2AAA      0x07        /* EVEX P[18:16] : Embedded opmask    */
 515 #define EVEX_P2VP       0x08        /* EVEX P[19] : High-16 NDS reg       */
 516 #define EVEX_P2B        0x10        /* EVEX P[20] : Broadcast / RC / SAE  */
 517 #define EVEX_P2LL       0x60        /* EVEX P[22:21] : Vector length      */
 518 #define EVEX_P2RC       EVEX_P2LL   /* EVEX P[22:21] : Rounding control   */
 519 #define EVEX_P2Z        0x80        /* EVEX P[23] : Zeroing/Merging       */
 520
 521 /*
 522  * REX_V "classes" (prefixes which behave like VEX)
 523  */
 524 enum vex_class {
 525     RV_VEX      = 0,    /* C4/C5 */
 526     RV_XOP      = 1     /* 8F */
 527 };
 528
 529 /*
 530  * Note that because segment registers may be used as instruction
 531  * prefixes, we must ensure the enumerations for prefixes and
 532  * register names do not overlap.
 533  */
 534 enum prefixes { /* instruction prefixes */
 535     P_none = 0,
 536     PREFIX_ENUM_START = REG_ENUM_LIMIT,
 537     P_A16 = PREFIX_ENUM_START,
 538     P_A32,
 539     P_A64,
 540     P_ASP,
 541     P_LOCK,
 542     P_O16,
 543     P_O32,
 544     P_O64,
 545     P_OSP,
 546     P_REP,
 547     P_REPE,
 548     P_REPNE,
 549     P_REPNZ,
 550     P_REPZ,
 551     P_TIMES,
 552     P_WAIT,
 553     P_XACQUIRE,
 554     P_XRELEASE,
 555     P_BND,
 556     PREFIX_ENUM_LIMIT
 557 };
 558
 559 enum extop_type { /* extended operand types */
 560     EOT_NOTHING,
 561     EOT_DB_STRING,      /* Byte string */
 562     EOT_DB_STRING_FREE, /* Byte string which should be nasm_free'd*/
 563     EOT_DB_NUMBER,      /* Integer */
 564 };
 565
 566 enum ea_flags { /* special EA flags */
 567     EAF_BYTEOFFS    =  1,   /* force offset part to byte size */
 568     EAF_WORDOFFS    =  2,   /* force offset part to [d]word size */
 569     EAF_TIMESTWO    =  4,   /* really do EAX*2 not EAX+EAX */
 570     EAF_REL         =  8,   /* IP-relative addressing */
 571     EAF_ABS         = 16,   /* non-IP-relative addressing */
 572     EAF_FSGS        = 32    /* fs/gs segment override present */
 573 };
 574
 575 enum eval_hint { /* values for `hinttype' */
 576     EAH_NOHINT   = 0,       /* no hint at all - our discretion */
 577     EAH_MAKEBASE = 1,       /* try to make given reg the base */
 578     EAH_NOTBASE  = 2        /* try _not_ to make reg the base */
 579 };
 580
 581 typedef struct operand { /* operand to an instruction */
 582     opflags_t       type;       /* type of operand */
 583     int             disp_size;  /* 0 means default; 16; 32; 64 */
 584     enum reg_enum   basereg;
 585     enum reg_enum   indexreg;   /* address registers */
 586     int             scale;      /* index scale */
 587     int             hintbase;
 588     enum eval_hint  hinttype;   /* hint as to real base register */
 589     int32_t         segment;    /* immediate segment, if needed */
 590     int64_t         offset;     /* any immediate number */
 591     int32_t         wrt;        /* segment base it's relative to */
 592     int             eaflags;    /* special EA flags */
 593     int             opflags;    /* see OPFLAG_* defines below */
 594     decoflags_t     decoflags;  /* decorator flags such as {...} */
 595 } operand;
 596
 597 #define OPFLAG_FORWARD      1   /* operand is a forward reference */
 598 #define OPFLAG_EXTERN       2   /* operand is an external reference */
 599 #define OPFLAG_UNKNOWN      4   /* operand is an unknown reference
 600                                  * (always a forward reference also)
 601                                  */
 602
 603 typedef struct extop { /* extended operand */
 604     struct extop    *next;      /* linked list */
 605     char            *stringval; /* if it's a string, then here it is */
 606     size_t          stringlen;  /* ... and here's how long it is */
 607     int64_t         offset;     /* ... it's given here ... */
 608     int32_t         segment;    /* if it's a number/address, then... */
 609     int32_t         wrt;        /* ... and here */
 610     enum extop_type type;       /* defined above */
 611 } extop;
 612
 613 enum ea_type {
 614     EA_INVALID,     /* Not a valid EA at all */
 615     EA_SCALAR,      /* Scalar EA */
 616     EA_XMMVSIB,     /* XMM vector EA */
 617     EA_YMMVSIB,     /* YMM vector EA */
 618     EA_ZMMVSIB,     /* ZMM vector EA */
 619 };
 620
 621 /*
 622  * Prefix positions: each type of prefix goes in a specific slot.
 623  * This affects the final ordering of the assembled output, which
 624  * shouldn't matter to the processor, but if you have stylistic
 625  * preferences, you can change this.  REX prefixes are handled
 626  * differently for the time being.
 627  *
 628  * LOCK and REP used to be one slot; this is no longer the case since
 629  * the introduction of HLE.
 630  */
 631 enum prefix_pos {
 632     PPS_WAIT,   /* WAIT (technically not a prefix!) */
 633     PPS_REP,    /* REP/HLE prefix */
 634     PPS_LOCK,   /* LOCK prefix */
 635     PPS_SEG,    /* Segment override prefix */
 636     PPS_OSIZE,  /* Operand size prefix */
 637     PPS_ASIZE,  /* Address size prefix */
 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     int             rex;                    /* Special REX Prefix */
 688     int             vexreg;                 /* Register encoded in VEX prefix */
 689     int             vex_cm;                 /* Class and M field for VEX prefix */
 690     int             vex_wlp;                /* W, P and L information for VEX prefix */
 691     uint8_t         evex_p[3];              /* EVEX.P0: [RXB,R',00,mm], P1: [W,vvvv,1,pp] */
 692                                             /* EVEX.P2: [z,L'L,b,V',aaa] */
 693     enum ttypes     evex_tuple;             /* Tuple type for compressed Disp8*N */
 694     int             evex_rm;                /* static rounding mode for AVX512 (EVEX) */
 695     int8_t          evex_brerop;            /* BR/ER/SAE operand position */
 696 } insn;
 697
 698 enum geninfo { GI_SWITCH };
 699
 700 /* Instruction flags type: IF_* flags are defined in insns.h */
 701 typedef uint64_t iflags_t;
 702
 703 /*
 704  * The data structure defining an output format driver, and the
 705  * interfaces to the functions therein.
 706  */
 707 struct ofmt {
 708     /*
 709      * This is a short (one-liner) description of the type of
 710      * output generated by the driver.
 711      */
 712     const char *fullname;
 713
 714     /*
 715      * This is a single keyword used to select the driver.
 716      */
 717     const char *shortname;
 718
 719     /*
 720      * Output format flags.
 721      */
 722 #define OFMT_TEXT   1   /* Text file format */
 723     unsigned int flags;
 724
 725     /*
 726      * this is a pointer to the first element of the debug information
 727      */
 728     struct dfmt **debug_formats;
 729
 730     /*
 731      * and a pointer to the element that is being used
 732      * note: this is set to the default at compile time and changed if the
 733      * -F option is selected.  If developing a set of new debug formats for
 734      * an output format, be sure to set this to whatever default you want
 735      *
 736      */
 737     const struct dfmt *current_dfmt;
 738
 739     /*
 740      * This, if non-NULL, is a NULL-terminated list of `char *'s
 741      * pointing to extra standard macros supplied by the object
 742      * format (e.g. a sensible initial default value of __SECT__,
 743      * and user-level equivalents for any format-specific
 744      * directives).
 745      */
 746     macros_t *stdmac;
 747
 748     /*
 749      * This procedure is called at the start of an output session to set
 750      * up internal parameters.
 751      */
 752     void (*init)(void);
 753
 754     /*
 755      * This procedure is called to pass generic information to the
 756      * object file.  The first parameter gives the information type
 757      * (currently only command line switches)
 758      * and the second parameter gives the value.  This function returns
 759      * 1 if recognized, 0 if unrecognized
 760      */
 761     int (*setinfo)(enum geninfo type, char **string);
 762
 763     /*
 764      * This procedure is called by assemble() to write actual
 765      * generated code or data to the object file. Typically it
 766      * doesn't have to actually _write_ it, just store it for
 767      * later.
 768      *
 769      * The `type' argument specifies the type of output data, and
 770      * usually the size as well: its contents are described below.
 771      */
 772     void (*output)(int32_t segto, const void *data,
 773                    enum out_type type, uint64_t size,
 774                    int32_t segment, int32_t wrt);
 775
 776     /*
 777      * This procedure is called once for every symbol defined in
 778      * the module being assembled. It gives the name and value of
 779      * the symbol, in NASM's terms, and indicates whether it has
 780      * been declared to be global. Note that the parameter "name",
 781      * when passed, will point to a piece of static storage
 782      * allocated inside the label manager - it's safe to keep using
 783      * that pointer, because the label manager doesn't clean up
 784      * until after the output driver has.
 785      *
 786      * Values of `is_global' are: 0 means the symbol is local; 1
 787      * means the symbol is global; 2 means the symbol is common (in
 788      * which case `offset' holds the _size_ of the variable).
 789      * Anything else is available for the output driver to use
 790      * internally.
 791      *
 792      * This routine explicitly _is_ allowed to call the label
 793      * manager to define further symbols, if it wants to, even
 794      * though it's been called _from_ the label manager. That much
 795      * re-entrancy is guaranteed in the label manager. However, the
 796      * label manager will in turn call this routine, so it should
 797      * be prepared to be re-entrant itself.
 798      *
 799      * The `special' parameter contains special information passed
 800      * through from the command that defined the label: it may have
 801      * been an EXTERN, a COMMON or a GLOBAL. The distinction should
 802      * be obvious to the output format from the other parameters.
 803      */
 804     void (*symdef)(char *name, int32_t segment, int64_t offset,
 805                    int is_global, char *special);
 806
 807     /*
 808      * This procedure is called when the source code requests a
 809      * segment change. It should return the corresponding segment
 810      * _number_ for the name, or NO_SEG if the name is not a valid
 811      * segment name.
 812      *
 813      * It may also be called with NULL, in which case it is to
 814      * return the _default_ section number for starting assembly in.
 815      *
 816      * It is allowed to modify the string it is given a pointer to.
 817      *
 818      * It is also allowed to specify a default instruction size for
 819      * the segment, by setting `*bits' to 16 or 32. Or, if it
 820      * doesn't wish to define a default, it can leave `bits' alone.
 821      */
 822     int32_t (*section)(char *name, int pass, int *bits);
 823
 824     /*
 825      * This procedure is called to modify section alignment,
 826      * note there is a trick, the alignment can only increase
 827      */
 828     void (*sectalign)(int32_t seg, unsigned int value);
 829
 830     /*
 831      * This procedure is called to modify the segment base values
 832      * returned from the SEG operator. It is given a segment base
 833      * value (i.e. a segment value with the low bit set), and is
 834      * required to produce in return a segment value which may be
 835      * different. It can map segment bases to absolute numbers by
 836      * means of returning SEG_ABS types.
 837      *
 838      * It should return NO_SEG if the segment base cannot be
 839      * determined; the evaluator (which calls this routine) is
 840      * responsible for throwing an error condition if that occurs
 841      * in pass two or in a critical expression.
 842      */
 843     int32_t (*segbase)(int32_t segment);
 844
 845     /*
 846      * This procedure is called to allow the output driver to
 847      * process its own specific directives. When called, it has the
 848      * directive word in `directive' and the parameter string in
 849      * `value'. It is called in both assembly passes, and `pass'
 850      * will be either 1 or 2.
 851      *
 852      * This procedure should return zero if it does not _recognise_
 853      * the directive, so that the main program can report an error.
 854      * If it recognises the directive but then has its own errors,
 855      * it should report them itself and then return non-zero. It
 856      * should also return non-zero if it correctly processes the
 857      * directive.
 858      */
 859     int (*directive)(enum directives directive, char *value, int pass);
 860
 861     /*
 862      * This procedure is called before anything else - even before
 863      * the "init" routine - and is passed the name of the input
 864      * file from which this output file is being generated. It
 865      * should return its preferred name for the output file in
 866      * `outname', if outname[0] is not '\0', and do nothing to
 867      * `outname' otherwise. Since it is called before the driver is
 868      * properly initialized, it has to be passed its error handler
 869      * separately.
 870      *
 871      * This procedure may also take its own copy of the input file
 872      * name for use in writing the output file: it is _guaranteed_
 873      * that it will be called before the "init" routine.
 874      *
 875      * The parameter `outname' points to an area of storage
 876      * guaranteed to be at least FILENAME_MAX in size.
 877      */
 878     void (*filename)(char *inname, char *outname);
 879
 880     /*
 881      * This procedure is called after assembly finishes, to allow
 882      * the output driver to clean itself up and free its memory.
 883      * Typically, it will also be the point at which the object
 884      * file actually gets _written_.
 885      *
 886      * One thing the cleanup routine should always do is to close
 887      * the output file pointer.
 888      */
 889     void (*cleanup)(int debuginfo);
 890 };
 891
 892 /*
 893  * Output format driver alias
 894  */
 895 struct ofmt_alias {
 896     const char  *shortname;
 897     const char  *fullname;
 898     struct ofmt *ofmt;
 899 };
 900
 901 extern struct ofmt *ofmt;
 902 extern FILE *ofile;
 903
 904 /*
 905  * ------------------------------------------------------------
 906  * The data structure defining a debug format driver, and the
 907  * interfaces to the functions therein.
 908  * ------------------------------------------------------------
 909  */
 910
 911 struct dfmt {
 912     /*
 913      * This is a short (one-liner) description of the type of
 914      * output generated by the driver.
 915      */
 916     const char *fullname;
 917
 918     /*
 919      * This is a single keyword used to select the driver.
 920      */
 921     const char *shortname;
 922
 923     /*
 924      * init - called initially to set up local pointer to object format.
 925      */
 926     void (*init)(void);
 927
 928     /*
 929      * linenum - called any time there is output with a change of
 930      * line number or file.
 931      */
 932     void (*linenum)(const char *filename, int32_t linenumber, int32_t segto);
 933
 934     /*
 935      * debug_deflabel - called whenever a label is defined. Parameters
 936      * are the same as to 'symdef()' in the output format. This function
 937      * would be called before the output format version.
 938      */
 939
 940     void (*debug_deflabel)(char *name, int32_t segment, int64_t offset,
 941                            int is_global, char *special);
 942     /*
 943      * debug_directive - called whenever a DEBUG directive other than 'LINE'
 944      * is encountered. 'directive' contains the first parameter to the
 945      * DEBUG directive, and params contains the rest. For example,
 946      * 'DEBUG VAR _somevar:int' would translate to a call to this
 947      * function with 'directive' equal to "VAR" and 'params' equal to
 948      * "_somevar:int".
 949      */
 950     void (*debug_directive)(const char *directive, const char *params);
 951
 952     /*
 953      * typevalue - called whenever the assembler wishes to register a type
 954      * for the last defined label.  This routine MUST detect if a type was
 955      * already registered and not re-register it.
 956      */
 957     void (*debug_typevalue)(int32_t type);
 958
 959     /*
 960      * debug_output - called whenever output is required
 961      * 'type' is the type of info required, and this is format-specific
 962      */
 963     void (*debug_output)(int type, void *param);
 964
 965     /*
 966      * cleanup - called after processing of file is complete
 967      */
 968     void (*cleanup)(void);
 969 };
 970
 971 extern const struct dfmt *dfmt;
 972
 973 /*
 974  * The type definition macros
 975  * for debugging
 976  *
 977  * low 3 bits: reserved
 978  * next 5 bits: type
 979  * next 24 bits: number of elements for arrays (0 for labels)
 980  */
 981
 982 #define TY_UNKNOWN 0x00
 983 #define TY_LABEL   0x08
 984 #define TY_BYTE    0x10
 985 #define TY_WORD    0x18
 986 #define TY_DWORD   0x20
 987 #define TY_FLOAT   0x28
 988 #define TY_QWORD   0x30
 989 #define TY_TBYTE   0x38
 990 #define TY_OWORD   0x40
 991 #define TY_YWORD   0x48
 992 #define TY_COMMON  0xE0
 993 #define TY_SEG     0xE8
 994 #define TY_EXTERN  0xF0
 995 #define TY_EQU     0xF8
 996
 997 #define TYM_TYPE(x)     ((x) & 0xF8)
 998 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
 999
1000 #define TYS_ELEMENTS(x) ((x) << 8)
1001
1002 enum special_tokens {
1003     SPECIAL_ENUM_START  = PREFIX_ENUM_LIMIT,
1004     S_ABS               = SPECIAL_ENUM_START,
1005     S_BYTE,
1006     S_DWORD,
1007     S_FAR,
1008     S_LONG,
1009     S_NEAR,
1010     S_NOSPLIT,
1011     S_OWORD,
1012     S_QWORD,
1013     S_REL,
1014     S_SHORT,
1015     S_STRICT,
1016     S_TO,
1017     S_TWORD,
1018     S_WORD,
1019     S_YWORD,
1020     S_ZWORD,
1021     SPECIAL_ENUM_LIMIT
1022 };
1023
1024 enum decorator_tokens {
1025     DECORATOR_ENUM_START    = SPECIAL_ENUM_LIMIT,
1026     BRC_1TO8                = DECORATOR_ENUM_START,
1027     BRC_1TO16,
1028     BRC_RN,
1029     BRC_RD,
1030     BRC_RU,
1031     BRC_RZ,
1032     BRC_SAE,
1033     BRC_Z,
1034     DECORATOR_ENUM_LIMIT
1035 };
1036
1037 /*
1038  * AVX512 Decorator (decoflags_t) bits distribution (counted from 0)
1039  *  3         2         1
1040  * 10987654321098765432109876543210
1041  *                |
1042  *                | word boundary
1043  * ............................1111 opmask
1044  * ...........................1.... zeroing / merging
1045  * ..........................1..... broadcast
1046  * .........................1...... static rounding
1047  * ........................1....... SAE
1048  * ......................11........ broadcast element size
1049  */
1050 #define OP_GENVAL(val, bits, shift)     (((val) & ((UINT64_C(1) << (bits)) - 1)) << (shift))
1051
1052 /*
1053  * Opmask register number
1054  * identical to EVEX.aaa
1055  *
1056  * Bits: 0 - 3
1057  */
1058 #define OPMASK_SHIFT            (0)
1059 #define OPMASK_BITS             (4)
1060 #define OPMASK_MASK             OP_GENMASK(OPMASK_BITS, OPMASK_SHIFT)
1061 #define GEN_OPMASK(bit)         OP_GENBIT(bit, OPMASK_SHIFT)
1062 #define VAL_OPMASK(val)         OP_GENVAL(val, OPMASK_BITS, OPMASK_SHIFT)
1063
1064 /*
1065  * zeroing / merging control available
1066  * matching to EVEX.z
1067  *
1068  * Bits: 4
1069  */
1070 #define Z_SHIFT                 (4)
1071 #define Z_BITS                  (1)
1072 #define Z_MASK                  OP_GENMASK(Z_BITS, Z_SHIFT)
1073 #define GEN_Z(bit)              OP_GENBIT(bit, Z_SHIFT)
1074
1075 /*
1076  * broadcast - Whether this operand can be broadcasted
1077  *
1078  * Bits: 5
1079  */
1080 #define BRDCAST_SHIFT           (5)
1081 #define BRDCAST_BITS            (1)
1082 #define BRDCAST_MASK            OP_GENMASK(BRDCAST_BITS, BRDCAST_SHIFT)
1083 #define GEN_BRDCAST(bit)        OP_GENBIT(bit, BRDCAST_SHIFT)
1084
1085 /*
1086  * Whether this instruction can have a static rounding mode.
1087  * It goes with the last simd operand because the static rounding mode
1088  * decorator is located between the last simd operand and imm8 (if any).
1089  *
1090  * Bits: 6
1091  */
1092 #define STATICRND_SHIFT         (6)
1093 #define STATICRND_BITS          (1)
1094 #define STATICRND_MASK          OP_GENMASK(STATICRND_BITS, STATICRND_SHIFT)
1095 #define GEN_STATICRND(bit)      OP_GENBIT(bit, STATICRND_SHIFT)
1096
1097 /*
1098  * SAE(Suppress all exception) available
1099  *
1100  * Bits: 7
1101  */
1102 #define SAE_SHIFT               (7)
1103 #define SAE_BITS                (1)
1104 #define SAE_MASK                OP_GENMASK(SAE_BITS, SAE_SHIFT)
1105 #define GEN_SAE(bit)            OP_GENBIT(bit, SAE_SHIFT)
1106
1107 /*
1108  * Broadcasting element size.
1109  *
1110  * Bits: 8 - 9
1111  */
1112 #define BRSIZE_SHIFT            (8)
1113 #define BRSIZE_BITS             (2)
1114 #define BRSIZE_MASK             OP_GENMASK(BRSIZE_BITS, BRSIZE_SHIFT)
1115 #define GEN_BRSIZE(bit)         OP_GENBIT(bit, BRSIZE_SHIFT)
1116
1117 #define BR_BITS32               GEN_BRSIZE(0)
1118 #define BR_BITS64               GEN_BRSIZE(1)
1119
1120 #define MASK                    OPMASK_MASK             /* Opmask (k1 ~ 7) can be used */
1121 #define Z                       Z_MASK
1122 #define B32                     (BRDCAST_MASK|BR_BITS32) /* {1to16} : broadcast 32b * 16 to zmm(512b) */
1123 #define B64                     (BRDCAST_MASK|BR_BITS64) /* {1to8}  : broadcast 64b *  8 to zmm(512b) */
1124 #define ER                      STATICRND_MASK          /* ER(Embedded Rounding) == Static rounding mode */
1125 #define SAE                     SAE_MASK                /* SAE(Suppress All Exception) */
1126
1127 /*
1128  * Global modes
1129  */
1130
1131 /*
1132  * This declaration passes the "pass" number to all other modules
1133  * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
1134  * where 0 = optimizing pass
1135  *       1 = pass 1
1136  *       2 = pass 2
1137  */
1138
1139 extern int pass0;
1140 extern int passn;               /* Actual pass number */
1141
1142 extern bool tasm_compatible_mode;
1143 extern int optimizing;
1144 extern int globalbits;          /* 16, 32 or 64-bit mode */
1145 extern int globalrel;           /* default to relative addressing? */
1146 extern int maxbits;             /* max bits supported by output */
1147
1148 /*
1149  * NASM version strings, defined in ver.c
1150  */
1151 extern const char nasm_version[];
1152 extern const char nasm_date[];
1153 extern const char nasm_compile_options[];
1154 extern const char nasm_comment[];
1155 extern const char nasm_signature[];
1156
1157 #endif