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 #define NASM_MAJOR_VER 0
  15 #define NASM_MINOR_VER 97
  16 #define NASM_VER "0.97"
  17
  18 #ifndef NULL
  19 #define NULL 0
  20 #endif
  21
  22 #ifndef FALSE
  23 #define FALSE 0                        /* comes in handy */
  24 #endif
  25 #ifndef TRUE
  26 #define TRUE 1
  27 #endif
  28
  29 #define NO_SEG -1L                     /* null segment value */
  30 #define SEG_ABS 0x40000000L            /* mask for far-absolute segments */
  31
  32 #ifndef FILENAME_MAX
  33 #define FILENAME_MAX 256
  34 #endif
  35
  36 /*
  37  * Name pollution problems: <time.h> on Digital UNIX pulls in some
  38  * strange hardware header file which sees fit to define R_SP. We
  39  * undefine it here so as not to break the enum below.
  40  */
  41 #ifdef R_SP
  42 #undef R_SP
  43 #endif
  44
  45 /*
  46  * We must declare the existence of this structure type up here,
  47  * since we have to reference it before we define it...
  48  */
  49 struct ofmt;
  50
  51 /*
  52  * -------------------------
  53  * Error reporting functions
  54  * -------------------------
  55  */
  56
  57 /*
  58  * An error reporting function should look like this.
  59  */
  60 typedef void (*efunc) (int severity, char *fmt, ...);
  61
  62 /*
  63  * These are the error severity codes which get passed as the first
  64  * argument to an efunc.
  65  */
  66
  67 #define ERR_WARNING 0                  /* warn only: no further action */
  68 #define ERR_NONFATAL 1                 /* terminate assembly after phase */
  69 #define ERR_FATAL 2                    /* instantly fatal: exit with error */
  70 #define ERR_PANIC 3                    /* internal error: panic instantly
  71                                         * and dump core for reference */
  72 #define ERR_MASK 0x0F                  /* mask off the above codes */
  73 #define ERR_NOFILE 0x10                /* don't give source file name/line */
  74 #define ERR_USAGE 0x20                 /* print a usage message */
  75 #define ERR_OFFBY1 0x40                /* report error as being on the line
  76                                         * we're just _about_ to read, not
  77                                         * the one we've just read */
  78 #define ERR_PASS1 0x80                 /* only print this error on pass one */
  79
  80 /*
  81  * These codes define specific types of suppressible warning.
  82  */
  83 #define ERR_WARN_MNP  0x0100           /* macro-num-parameters warning */
  84 #define ERR_WARN_OL   0x0200           /* orphan label (no colon, and
  85                                         * alone on line) */
  86 #define ERR_WARN_NOV  0x0300           /* numeric overflow */
  87 #define ERR_WARN_MASK 0xFF00           /* the mask for this feature */
  88 #define ERR_WARN_SHR  8                /* how far to shift right */
  89 #define ERR_WARN_MAX  3                /* the highest numbered one */
  90
  91 /*
  92  * -----------------------
  93  * Other function typedefs
  94  * -----------------------
  95  */
  96
  97 /*
  98  * A label-lookup function should look like this.
  99  */
 100 typedef int (*lfunc) (char *label, long *segment, long *offset);
 101
 102 /*
 103  * And a label-definition function like this. The boolean parameter
 104  * `is_norm' states whether the label is a `normal' label (which
 105  * should affect the local-label system), or something odder like
 106  * an EQU or a segment-base symbol, which shouldn't.
 107  */
 108 typedef void (*ldfunc) (char *label, long segment, long offset, char *special,
 109                         int is_norm, int isextrn, struct ofmt *ofmt,
 110                         efunc error);
 111
 112 /*
 113  * List-file generators should look like this:
 114  */
 115 typedef struct {
 116     /*
 117      * Called to initialise the listing file generator. Before this
 118      * is called, the other routines will silently do nothing when
 119      * called. The `char *' parameter is the file name to write the
 120      * listing to.
 121      */
 122     void (*init) (char *, efunc);
 123
 124     /*
 125      * Called to clear stuff up and close the listing file.
 126      */
 127     void (*cleanup) (void);
 128
 129     /*
 130      * Called to output binary data. Parameters are: the offset;
 131      * the data; the data type. Data types are similar to the
 132      * output-format interface, only OUT_ADDRESS will _always_ be
 133      * displayed as if it's relocatable, so ensure that any non-
 134      * relocatable address has been converted to OUT_RAWDATA by
 135      * then. Note that OUT_RAWDATA+0 is a valid data type, and is a
 136      * dummy call used to give the listing generator an offset to
 137      * work with when doing things like uplevel(LIST_TIMES) or
 138      * uplevel(LIST_INCBIN).
 139      */
 140     void (*output) (long, void *, unsigned long);
 141
 142     /*
 143      * Called to send a text line to the listing generator. The
 144      * `int' parameter is LIST_READ or LIST_MACRO depending on
 145      * whether the line came directly from an input file or is the
 146      * result of a multi-line macro expansion.
 147      */
 148     void (*line) (int, char *);
 149
 150     /*
 151      * Called to change one of the various levelled mechanisms in
 152      * the listing generator. LIST_INCLUDE and LIST_MACRO can be
 153      * used to increase the nesting level of include files and
 154      * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
 155      * two binary-output-suppression mechanisms for large-scale
 156      * pseudo-instructions.
 157      *
 158      * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
 159      * it indicates the beginning of the expansion of a `nolist'
 160      * macro, so anything under that level won't be expanded unless
 161      * it includes another file.
 162      */
 163     void (*uplevel) (int);
 164
 165     /*
 166      * Reverse the effects of uplevel.
 167      */
 168     void (*downlevel) (int);
 169 } ListGen;
 170
 171 /*
 172  * The expression evaluator must be passed a scanner function; a
 173  * standard scanner is provided as part of nasmlib.c. The
 174  * preprocessor will use a different one. Scanners, and the
 175  * token-value structures they return, look like this.
 176  *
 177  * The return value from the scanner is always a copy of the
 178  * `t_type' field in the structure.
 179  */
 180 struct tokenval {
 181     int t_type;
 182     long t_integer, t_inttwo;
 183     char *t_charptr;
 184 };
 185 typedef int (*scanner) (void *private_data, struct tokenval *tv);
 186
 187 /*
 188  * Token types returned by the scanner, in addition to ordinary
 189  * ASCII character values, and zero for end-of-string.
 190  */
 191 enum {                                 /* token types, other than chars */
 192     TOKEN_INVALID = -1,                /* a placeholder value */
 193     TOKEN_EOS = 0,                     /* end of string */
 194     TOKEN_EQ = '=', TOKEN_GT = '>', TOKEN_LT = '<',   /* aliases */
 195     TOKEN_ID = 256, TOKEN_NUM, TOKEN_REG, TOKEN_INSN,  /* major token types */
 196     TOKEN_ERRNUM,                      /* numeric constant with error in */
 197     TOKEN_HERE, TOKEN_BASE,            /* $ and $$ */
 198     TOKEN_SPECIAL,                     /* BYTE, WORD, DWORD, FAR, NEAR, etc */
 199     TOKEN_PREFIX,                      /* A32, O16, LOCK, REPNZ, TIMES, etc */
 200     TOKEN_SHL, TOKEN_SHR,              /* << and >> */
 201     TOKEN_SDIV, TOKEN_SMOD,            /* // and %% */
 202     TOKEN_GE, TOKEN_LE, TOKEN_NE,      /* >=, <= and <> (!= is same as <>) */
 203     TOKEN_DBL_AND, TOKEN_DBL_OR, TOKEN_DBL_XOR,   /* &&, || and ^^ */
 204     TOKEN_SEG, TOKEN_WRT,              /* SEG and WRT */
 205     TOKEN_FLOAT                        /* floating-point constant */
 206 };
 207
 208 /*
 209  * Expression-evaluator datatype. Expressions, within the
 210  * evaluator, are stored as an array of these beasts, terminated by
 211  * a record with type==0. Mostly, it's a vector type: each type
 212  * denotes some kind of a component, and the value denotes the
 213  * multiple of that component present in the expression. The
 214  * exception is the WRT type, whose `value' field denotes the
 215  * segment to which the expression is relative. These segments will
 216  * be segment-base types, i.e. either odd segment values or SEG_ABS
 217  * types. So it is still valid to assume that anything with a
 218  * `value' field of zero is insignificant.
 219  */
 220 typedef struct {
 221     long type;                         /* a register, or EXPR_xxx */
 222     long value;                        /* must be >= 32 bits */
 223 } expr;
 224
 225 /*
 226  * The evaluator can also return hints about which of two registers
 227  * used in an expression should be the base register. See also the
 228  * `operand' structure.
 229  */
 230 struct eval_hints {
 231     int base;
 232     int type;
 233 };
 234
 235 /*
 236  * The actual expression evaluator function looks like this. When
 237  * called, it expects the first token of its expression to already
 238  * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
 239  * it will start by calling the scanner.
 240  *
 241  * If a forward reference happens during evaluation, the evaluator
 242  * must set `*fwref' to TRUE if `fwref' is non-NULL.
 243  *
 244  * `critical' is non-zero if the expression may not contain forward
 245  * references. The evaluator will report its own error if this
 246  * occurs; if `critical' is 1, the error will be "symbol not
 247  * defined before use", whereas if `critical' is 2, the error will
 248  * be "symbol undefined".
 249  *
 250  * If `critical' has bit 4 set (in addition to its main value: 0x11
 251  * and 0x12 correspond to 1 and 2) then an extended expression
 252  * syntax is recognised, in which relational operators such as =, <
 253  * and >= are accepted, as well as low-precedence logical operators
 254  * &&, ^^ and ||.
 255  *
 256  * If `hints' is non-NULL, it gets filled in with some hints as to
 257  * the base register in complex effective addresses.
 258  */
 259 typedef expr *(*evalfunc) (scanner sc, void *scprivate, struct tokenval *tv,
 260                            int *fwref, int critical, efunc error,
 261                            struct eval_hints *hints);
 262
 263 /*
 264  * There's also an auxiliary routine through which the evaluator
 265  * needs to hear about the value of $ and the label (if any)
 266  * defined on the current line.
 267  */
 268 typedef void (*evalinfofunc) (char *labelname, long segment, long offset);
 269
 270 /*
 271  * Special values for expr->type. ASSUMPTION MADE HERE: the number
 272  * of distinct register names (i.e. possible "type" fields for an
 273  * expr structure) does not exceed 124 (EXPR_REG_START through
 274  * EXPR_REG_END).
 275  */
 276 #define EXPR_REG_START 1
 277 #define EXPR_REG_END 124
 278 #define EXPR_UNKNOWN 125L              /* for forward references */
 279 #define EXPR_SIMPLE 126L
 280 #define EXPR_WRT 127L
 281 #define EXPR_SEGBASE 128L
 282
 283 /*
 284  * Preprocessors ought to look like this:
 285  */
 286 typedef struct {
 287     /*
 288      * Called at the start of a pass; given a file name, the number
 289      * of the pass, an error reporting function, an evaluator
 290      * function, and a listing generator to talk to.
 291      */
 292     void (*reset) (char *, int, efunc, evalfunc, ListGen *);
 293
 294     /*
 295      * Called to fetch a line of preprocessed source. The line
 296      * returned has been malloc'ed, and so should be freed after
 297      * use.
 298      */
 299     char *(*getline) (void);
 300
 301     /*
 302      * Called at the end of a pass.
 303      */
 304     void (*cleanup) (void);
 305 } Preproc;
 306
 307 /*
 308  * ----------------------------------------------------------------
 309  * Some lexical properties of the NASM source language, included
 310  * here because they are shared between the parser and preprocessor
 311  * ----------------------------------------------------------------
 312  */
 313
 314 /* isidstart matches any character that may start an identifier, and isidchar
 315  * matches any character that may appear at places other than the start of an
 316  * identifier. E.g. a period may only appear at the start of an identifier
 317  * (for local labels), whereas a number may appear anywhere *but* at the
 318  * start. */
 319
 320 #define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
 321                                   || (c)=='@' )
 322 #define isidchar(c)  ( isidstart(c) || isdigit(c) || (c)=='$' || (c)=='#' \
 323                                                   || (c)=='~' )
 324
 325 /* Ditto for numeric constants. */
 326
 327 #define isnumstart(c)  ( isdigit(c) || (c)=='$' )
 328 #define isnumchar(c)   ( isalnum(c) )
 329
 330 /* This returns the numeric value of a given 'digit'. */
 331
 332 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 333
 334 /*
 335  * Data-type flags that get passed to listing-file routines.
 336  */
 337 enum {
 338     LIST_READ, LIST_MACRO, LIST_MACRO_NOLIST, LIST_INCLUDE,
 339     LIST_INCBIN, LIST_TIMES
 340 };
 341
 342 /*
 343  * -----------------------------------------------------------
 344  * Format of the `insn' structure returned from `parser.c' and
 345  * passed into `assemble.c'
 346  * -----------------------------------------------------------
 347  */
 348
 349 /*
 350  * Here we define the operand types. These are implemented as bit
 351  * masks, since some are subsets of others; e.g. AX in a MOV
 352  * instruction is a special operand type, whereas AX in other
 353  * contexts is just another 16-bit register. (Also, consider CL in
 354  * shift instructions, DX in OUT, etc.)
 355  */
 356
 357 /* size, and other attributes, of the operand */
 358 #define BITS8     0x00000001L
 359 #define BITS16    0x00000002L
 360 #define BITS32    0x00000004L
 361 #define BITS64    0x00000008L          /* FPU only */
 362 #define BITS80    0x00000010L          /* FPU only */
 363 #define FAR       0x00000020L          /* grotty: this means 16:16 or */
 364                                        /* 16:32, like in CALL/JMP */
 365 #define NEAR      0x00000040L
 366 #define SHORT     0x00000080L          /* and this means what it says :) */
 367
 368 #define SIZE_MASK 0x000000FFL          /* all the size attributes */
 369 #define NON_SIZE  (~SIZE_MASK)
 370
 371 #define TO        0x00000100L          /* reverse effect in FADD, FSUB &c */
 372 #define COLON     0x00000200L          /* operand is followed by a colon */
 373
 374 /* type of operand: memory reference, register, etc. */
 375 #define MEMORY    0x00204000L
 376 #define REGISTER  0x00001000L          /* register number in 'basereg' */
 377 #define IMMEDIATE 0x00002000L
 378
 379 #define REGMEM    0x00200000L          /* for r/m, ie EA, operands */
 380 #define REGNORM   0x00201000L          /* 'normal' reg, qualifies as EA */
 381 #define REG8      0x00201001L
 382 #define REG16     0x00201002L
 383 #define REG32     0x00201004L
 384 #define MMXREG    0x00201008L          /* MMX registers */
 385 #define FPUREG    0x01000000L          /* floating point stack registers */
 386 #define FPU0      0x01000800L          /* FPU stack register zero */
 387
 388 /* special register operands: these may be treated differently */
 389 #define REG_SMASK 0x00070000L          /* a mask for the following */
 390 #define REG_ACCUM 0x00211000L          /* accumulator: AL, AX or EAX */
 391 #define REG_AL    0x00211001L          /* REG_ACCUM | BITSxx */
 392 #define REG_AX    0x00211002L          /* ditto */
 393 #define REG_EAX   0x00211004L          /* and again */
 394 #define REG_COUNT 0x00221000L          /* counter: CL, CX or ECX */
 395 #define REG_CL    0x00221001L          /* REG_COUNT | BITSxx */
 396 #define REG_CX    0x00221002L          /* ditto */
 397 #define REG_ECX   0x00221004L          /* another one */
 398 #define REG_DX    0x00241002L
 399 #define REG_SREG  0x00081002L          /* any segment register */
 400 #define REG_CS    0x01081002L          /* CS */
 401 #define REG_DESS  0x02081002L          /* DS, ES, SS (non-CS 86 registers) */
 402 #define REG_FSGS  0x04081002L          /* FS, GS (386 extended registers) */
 403 #define REG_CDT   0x00101004L          /* CRn, DRn and TRn */
 404 #define REG_CREG  0x08101004L          /* CRn */
 405 #define REG_CR4   0x08101404L          /* CR4 (Pentium only) */
 406 #define REG_DREG  0x10101004L          /* DRn */
 407 #define REG_TREG  0x20101004L          /* TRn */
 408
 409 /* special type of EA */
 410 #define MEM_OFFS  0x00604000L          /* simple [address] offset */
 411
 412 /* special type of immediate operand */
 413 #define ONENESS   0x00800000L          /* so UNITY == IMMEDIATE | ONENESS */
 414 #define UNITY     0x00802000L          /* for shift/rotate instructions */
 415
 416 /*
 417  * Next, the codes returned from the parser, for registers and
 418  * instructions.
 419  */
 420
 421 enum {                                 /* register names */
 422     R_AH = EXPR_REG_START, R_AL, R_AX, R_BH, R_BL, R_BP, R_BX, R_CH,
 423     R_CL, R_CR0, R_CR2, R_CR3, R_CR4, R_CS, R_CX, R_DH, R_DI, R_DL,
 424     R_DR0, R_DR1, R_DR2, R_DR3, R_DR6, R_DR7, R_DS, R_DX, R_EAX,
 425     R_EBP, R_EBX, R_ECX, R_EDI, R_EDX, R_ES, R_ESI, R_ESP, R_FS,
 426     R_GS, R_MM0, R_MM1, R_MM2, R_MM3, R_MM4, R_MM5, R_MM6, R_MM7,
 427     R_SI, R_SP, R_SS, R_ST0, R_ST1, R_ST2, R_ST3, R_ST4, R_ST5,
 428     R_ST6, R_ST7, R_TR3, R_TR4, R_TR5, R_TR6, R_TR7, REG_ENUM_LIMIT
 429 };
 430
 431 enum {                                 /* instruction names */
 432     I_AAA, I_AAD, I_AAM, I_AAS, I_ADC, I_ADD, I_AND, I_ARPL,
 433     I_BOUND, I_BSF, I_BSR, I_BSWAP, I_BT, I_BTC, I_BTR, I_BTS,
 434     I_CALL, I_CBW, I_CDQ, I_CLC, I_CLD, I_CLI, I_CLTS, I_CMC, I_CMP,
 435     I_CMPSB, I_CMPSD, I_CMPSW, I_CMPXCHG, I_CMPXCHG486, I_CMPXCHG8B,
 436     I_CPUID, I_CWD, I_CWDE, I_DAA, I_DAS, I_DB, I_DD, I_DEC, I_DIV,
 437     I_DQ, I_DT, I_DW, I_EMMS, I_ENTER, I_EQU, I_F2XM1, I_FABS,
 438     I_FADD, I_FADDP, I_FBLD, I_FBSTP, I_FCHS, I_FCLEX, I_FCMOVB,
 439     I_FCMOVBE, I_FCMOVE, I_FCMOVNB, I_FCMOVNBE, I_FCMOVNE,
 440     I_FCMOVNU, I_FCMOVU, I_FCOM, I_FCOMI, I_FCOMIP, I_FCOMP,
 441     I_FCOMPP, I_FCOS, I_FDECSTP, I_FDISI, I_FDIV, I_FDIVP, I_FDIVR,
 442     I_FDIVRP, I_FENI, I_FFREE, I_FIADD, I_FICOM, I_FICOMP, I_FIDIV,
 443     I_FIDIVR, I_FILD, I_FIMUL, I_FINCSTP, I_FINIT, I_FIST, I_FISTP,
 444     I_FISUB, I_FISUBR, I_FLD, I_FLD1, I_FLDCW, I_FLDENV, I_FLDL2E,
 445     I_FLDL2T, I_FLDLG2, I_FLDLN2, I_FLDPI, I_FLDZ, I_FMUL, I_FMULP,
 446     I_FNCLEX, I_FNDISI, I_FNENI, I_FNINIT, I_FNOP, I_FNSAVE,
 447     I_FNSTCW, I_FNSTENV, I_FNSTSW, I_FPATAN, I_FPREM, I_FPREM1,
 448     I_FPTAN, I_FRNDINT, I_FRSTOR, I_FSAVE, I_FSCALE, I_FSETPM,
 449     I_FSIN, I_FSINCOS, I_FSQRT, I_FST, I_FSTCW, I_FSTENV, I_FSTP,
 450     I_FSTSW, I_FSUB, I_FSUBP, I_FSUBR, I_FSUBRP, I_FTST, I_FUCOM,
 451     I_FUCOMI, I_FUCOMIP, I_FUCOMP, I_FUCOMPP, I_FXAM, I_FXCH,
 452     I_FXTRACT, I_FYL2X, I_FYL2XP1, I_HLT, I_IBTS, I_ICEBP, I_IDIV,
 453     I_IMUL, I_IN, I_INC, I_INCBIN, I_INSB, I_INSD, I_INSW, I_INT,
 454     I_INT1, I_INT01, I_INT3, I_INTO, I_INVD, I_INVLPG, I_IRET,
 455     I_IRETD, I_IRETW, I_JCXZ, I_JECXZ, I_JMP, I_LAHF, I_LAR, I_LDS,
 456     I_LEA, I_LEAVE, I_LES, I_LFS, I_LGDT, I_LGS, I_LIDT, I_LLDT,
 457     I_LMSW, I_LOADALL, I_LOADALL286, I_LODSB, I_LODSD, I_LODSW,
 458     I_LOOP, I_LOOPE, I_LOOPNE, I_LOOPNZ, I_LOOPZ, I_LSL, I_LSS,
 459     I_LTR, I_MOV, I_MOVD, I_MOVQ, I_MOVSB, I_MOVSD, I_MOVSW,
 460     I_MOVSX, I_MOVZX, I_MUL, I_NEG, I_NOP, I_NOT, I_OR, I_OUT,
 461     I_OUTSB, I_OUTSD, I_OUTSW, I_PACKSSDW, I_PACKSSWB, I_PACKUSWB,
 462     I_PADDB, I_PADDD, I_PADDSB, I_PADDSIW, I_PADDSW, I_PADDUSB,
 463     I_PADDUSW, I_PADDW, I_PAND, I_PANDN, I_PAVEB, I_PCMPEQB,
 464     I_PCMPEQD, I_PCMPEQW, I_PCMPGTB, I_PCMPGTD, I_PCMPGTW,
 465     I_PDISTIB, I_PMACHRIW, I_PMADDWD, I_PMAGW, I_PMULHRW,
 466     I_PMULHRIW, I_PMULHW, I_PMULLW, I_PMVGEZB, I_PMVLZB, I_PMVNZB,
 467     I_PMVZB, I_POP, I_POPA, I_POPAD, I_POPAW, I_POPF, I_POPFD,
 468     I_POPFW, I_POR, I_PSLLD, I_PSLLQ, I_PSLLW, I_PSRAD, I_PSRAW,
 469     I_PSRLD, I_PSRLQ, I_PSRLW, I_PSUBB, I_PSUBD, I_PSUBSB,
 470     I_PSUBSIW, I_PSUBSW, I_PSUBUSB, I_PSUBUSW, I_PSUBW, I_PUNPCKHBW,
 471     I_PUNPCKHDQ, I_PUNPCKHWD, I_PUNPCKLBW, I_PUNPCKLDQ, I_PUNPCKLWD,
 472     I_PUSH, I_PUSHA, I_PUSHAD, I_PUSHAW, I_PUSHF, I_PUSHFD,
 473     I_PUSHFW, I_PXOR, I_RCL, I_RCR, I_RDMSR, I_RDPMC, I_RDTSC,
 474     I_RESB, I_RESD, I_RESQ, I_REST, I_RESW, I_RET, I_RETF, I_RETN,
 475     I_ROL, I_ROR, I_RSM, I_SAHF, I_SAL, I_SALC, I_SAR, I_SBB,
 476     I_SCASB, I_SCASD, I_SCASW, I_SGDT, I_SHL, I_SHLD, I_SHR, I_SHRD,
 477     I_SIDT, I_SLDT, I_SMI, I_SMSW, I_STC, I_STD, I_STI, I_STOSB,
 478     I_STOSD, I_STOSW, I_STR, I_SUB, I_TEST, I_UMOV, I_VERR, I_VERW,
 479     I_WAIT, I_WBINVD, I_WRMSR, I_XADD, I_XBTS, I_XCHG, I_XLATB,
 480     I_XOR, I_CMOVcc, I_Jcc, I_SETcc
 481 };
 482
 483 enum {                                 /* condition code names */
 484     C_A, C_AE, C_B, C_BE, C_C, C_E, C_G, C_GE, C_L, C_LE, C_NA, C_NAE,
 485     C_NB, C_NBE, C_NC, C_NE, C_NG, C_NGE, C_NL, C_NLE, C_NO, C_NP,
 486     C_NS, C_NZ, C_O, C_P, C_PE, C_PO, C_S, C_Z
 487 };
 488
 489 /*
 490  * Note that because segment registers may be used as instruction
 491  * prefixes, we must ensure the enumerations for prefixes and
 492  * register names do not overlap.
 493  */
 494 enum {                                 /* instruction prefixes */
 495     PREFIX_ENUM_START = REG_ENUM_LIMIT,
 496     P_A16 = PREFIX_ENUM_START, P_A32, P_LOCK, P_O16, P_O32, P_REP, P_REPE,
 497     P_REPNE, P_REPNZ, P_REPZ, P_TIMES
 498 };
 499
 500 enum {                                 /* extended operand types */
 501     EOT_NOTHING, EOT_DB_STRING, EOT_DB_NUMBER
 502 };
 503
 504 enum {                                 /* special EA flags */
 505     EAF_BYTEOFFS = 1,                  /* force offset part to byte size */
 506     EAF_WORDOFFS = 2,                  /* force offset part to [d]word size */
 507     EAF_TIMESTWO = 4                   /* really do EAX*2 not EAX+EAX */
 508 };
 509
 510 enum {                                 /* values for `hinttype' */
 511     EAH_NOHINT = 0,                    /* no hint at all - our discretion */
 512     EAH_MAKEBASE = 1,                  /* try to make given reg the base */
 513     EAH_NOTBASE = 2                    /* try _not_ to make reg the base */
 514 };
 515
 516 typedef struct {                       /* operand to an instruction */
 517     long type;                         /* type of operand */
 518     int addr_size;                     /* 0 means default; 16; 32 */
 519     int basereg, indexreg, scale;      /* registers and scale involved */
 520     int hintbase, hinttype;            /* hint as to real base register */
 521     long segment;                      /* immediate segment, if needed */
 522     long offset;                       /* any immediate number */
 523     long wrt;                          /* segment base it's relative to */
 524     int eaflags;                       /* special EA flags */
 525 } operand;
 526
 527 typedef struct extop {                 /* extended operand */
 528     struct extop *next;                /* linked list */
 529     long type;                         /* defined above */
 530     char *stringval;                   /* if it's a string, then here it is */
 531     int stringlen;                     /* ... and here's how long it is */
 532     long segment;                      /* if it's a number/address, then... */
 533     long offset;                       /* ... it's given here ... */
 534     long wrt;                          /* ... and here */
 535 } extop;
 536
 537 #define MAXPREFIX 4
 538
 539 typedef struct {                       /* an instruction itself */
 540     char *label;                       /* the label defined, or NULL */
 541     int prefixes[MAXPREFIX];           /* instruction prefixes, if any */
 542     int nprefix;                       /* number of entries in above */
 543     int opcode;                        /* the opcode - not just the string */
 544     int condition;                     /* the condition code, if Jcc/SETcc */
 545     int operands;                      /* how many operands? 0-3 */
 546     operand oprs[3];                   /* the operands, defined as above */
 547     extop *eops;                       /* extended operands */
 548     long times;                        /* repeat count (TIMES prefix) */
 549     int forw_ref;                      /* is there a forward reference? */
 550 } insn;
 551
 552 /*
 553  * ------------------------------------------------------------
 554  * The data structure defining an output format driver, and the
 555  * interfaces to the functions therein.
 556  * ------------------------------------------------------------
 557  */
 558
 559 struct ofmt {
 560     /*
 561      * This is a short (one-liner) description of the type of
 562      * output generated by the driver.
 563      */
 564     char *fullname;
 565
 566     /*
 567      * This is a single keyword used to select the driver.
 568      */
 569     char *shortname;
 570
 571     /*
 572      * This, if non-NULL, is a NULL-terminated list of `char *'s
 573      * pointing to extra standard macros supplied by the object
 574      * format (e.g. a sensible initial default value of __SECT__,
 575      * and user-level equivalents for any format-specific
 576      * directives).
 577      */
 578     char **stdmac;
 579
 580     /*
 581      * This procedure is called at the start of an output session.
 582      * It tells the output format what file it will be writing to,
 583      * what routine to report errors through, and how to interface
 584      * to the label manager and expression evaluator if necessary.
 585      * It also gives it a chance to do other initialisation.
 586      */
 587     void (*init) (FILE *fp, efunc error, ldfunc ldef, evalfunc eval);
 588
 589     /*
 590      * This procedure is called by assemble() to write actual
 591      * generated code or data to the object file. Typically it
 592      * doesn't have to actually _write_ it, just store it for
 593      * later.
 594      *
 595      * The `type' argument specifies the type of output data, and
 596      * usually the size as well: its contents are described below.
 597      */
 598     void (*output) (long segto, void *data, unsigned long type,
 599                     long segment, long wrt);
 600
 601     /*
 602      * This procedure is called once for every symbol defined in
 603      * the module being assembled. It gives the name and value of
 604      * the symbol, in NASM's terms, and indicates whether it has
 605      * been declared to be global. Note that the parameter "name",
 606      * when passed, will point to a piece of static storage
 607      * allocated inside the label manager - it's safe to keep using
 608      * that pointer, because the label manager doesn't clean up
 609      * until after the output driver has.
 610      *
 611      * Values of `is_global' are: 0 means the symbol is local; 1
 612      * means the symbol is global; 2 means the symbol is common (in
 613      * which case `offset' holds the _size_ of the variable).
 614      * Anything else is available for the output driver to use
 615      * internally.
 616      *
 617      * This routine explicitly _is_ allowed to call the label
 618      * manager to define further symbols, if it wants to, even
 619      * though it's been called _from_ the label manager. That much
 620      * re-entrancy is guaranteed in the label manager. However, the
 621      * label manager will in turn call this routine, so it should
 622      * be prepared to be re-entrant itself.
 623      *
 624      * The `special' parameter contains special information passed
 625      * through from the command that defined the label: it may have
 626      * been an EXTERN, a COMMON or a GLOBAL. The distinction should
 627      * be obvious to the output format from the other parameters.
 628      */
 629     void (*symdef) (char *name, long segment, long offset, int is_global,
 630                     char *special);
 631
 632     /*
 633      * This procedure is called when the source code requests a
 634      * segment change. It should return the corresponding segment
 635      * _number_ for the name, or NO_SEG if the name is not a valid
 636      * segment name.
 637      *
 638      * It may also be called with NULL, in which case it is to
 639      * return the _default_ section number for starting assembly in.
 640      *
 641      * It is allowed to modify the string it is given a pointer to.
 642      *
 643      * It is also allowed to specify a default instruction size for
 644      * the segment, by setting `*bits' to 16 or 32. Or, if it
 645      * doesn't wish to define a default, it can leave `bits' alone.
 646      */
 647     long (*section) (char *name, int pass, int *bits);
 648
 649     /*
 650      * This procedure is called to modify the segment base values
 651      * returned from the SEG operator. It is given a segment base
 652      * value (i.e. a segment value with the low bit set), and is
 653      * required to produce in return a segment value which may be
 654      * different. It can map segment bases to absolute numbers by
 655      * means of returning SEG_ABS types.
 656      *
 657      * It should return NO_SEG if the segment base cannot be
 658      * determined; the evaluator (which calls this routine) is
 659      * responsible for throwing an error condition if that occurs
 660      * in pass two or in a critical expression.
 661      */
 662     long (*segbase) (long segment);
 663
 664     /*
 665      * This procedure is called to allow the output driver to
 666      * process its own specific directives. When called, it has the
 667      * directive word in `directive' and the parameter string in
 668      * `value'. It is called in both assembly passes, and `pass'
 669      * will be either 1 or 2.
 670      *
 671      * This procedure should return zero if it does not _recognise_
 672      * the directive, so that the main program can report an error.
 673      * If it recognises the directive but then has its own errors,
 674      * it should report them itself and then return non-zero. It
 675      * should also return non-zero if it correctly processes the
 676      * directive.
 677      */
 678     int (*directive) (char *directive, char *value, int pass);
 679
 680     /*
 681      * This procedure is called before anything else - even before
 682      * the "init" routine - and is passed the name of the input
 683      * file from which this output file is being generated. It
 684      * should return its preferred name for the output file in
 685      * `outname', if outname[0] is not '\0', and do nothing to
 686      * `outname' otherwise. Since it is called before the driver is
 687      * properly initialised, it has to be passed its error handler
 688      * separately.
 689      *
 690      * This procedure may also take its own copy of the input file
 691      * name for use in writing the output file: it is _guaranteed_
 692      * that it will be called before the "init" routine.
 693      *
 694      * The parameter `outname' points to an area of storage
 695      * guaranteed to be at least FILENAME_MAX in size.
 696      */
 697     void (*filename) (char *inname, char *outname, efunc error);
 698
 699     /*
 700      * This procedure is called after assembly finishes, to allow
 701      * the output driver to clean itself up and free its memory.
 702      * Typically, it will also be the point at which the object
 703      * file actually gets _written_.
 704      *
 705      * One thing the cleanup routine should always do is to close
 706      * the output file pointer.
 707      */
 708     void (*cleanup) (void);
 709 };
 710
 711 /*
 712  * values for the `type' parameter to an output function. Each one
 713  * must have the actual number of _bytes_ added to it.
 714  *
 715  * Exceptions are OUT_RELxADR, which denote an x-byte relocation
 716  * which will be a relative jump. For this we need to know the
 717  * distance in bytes from the start of the relocated record until
 718  * the end of the containing instruction. _This_ is what is stored
 719  * in the size part of the parameter, in this case.
 720  *
 721  * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
 722  * and the contents of the "data" parameter is irrelevant.
 723  *
 724  * The "data" parameter for the output function points to a "long",
 725  * containing the address in question, unless the type is
 726  * OUT_RAWDATA, in which case it points to an "unsigned char"
 727  * array.
 728  */
 729 #define OUT_RAWDATA 0x00000000UL
 730 #define OUT_ADDRESS 0x10000000UL
 731 #define OUT_REL2ADR 0x20000000UL
 732 #define OUT_REL4ADR 0x30000000UL
 733 #define OUT_RESERVE 0x40000000UL
 734 #define OUT_TYPMASK 0xF0000000UL
 735 #define OUT_SIZMASK 0x0FFFFFFFUL
 736
 737 /*
 738  * -----
 739  * Other
 740  * -----
 741  */
 742
 743 /*
 744  * This is a useful #define which I keep meaning to use more often:
 745  * the number of elements of a statically defined array.
 746  */
 747
 748 #define elements(x)     ( sizeof(x) / sizeof(*(x)) )
 749
 750 #endif