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