nasm.h

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