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