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