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