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