nasm.h

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as
   9  *   published by the Free Software Foundation, Inc.,
  10  *   51 Franklin St, Fifth Floor, Boston MA 02110-1301, USA; version 2.1,
  11  *   or, at your option, any later version, incorporated herein by
  12  *   reference.
  13  *
  14  *   Patches submitted to this file are required to be dual licensed
  15  *   under the LGPL 2.1+ and the 2-clause BSD license:
  16  *
  17  *   Copyright 1996-2009 the NASM Authors - All rights reserved.
  18  *
  19  *   Redistribution and use in source and binary forms, with or without
  20  *   modification, are permitted provided that the following
  21  *   conditions are met:
  22  *
  23  *   * Redistributions of source code must retain the above copyright
  24  *     notice, this list of conditions and the following disclaimer.
  25  *   * Redistributions in binary form must reproduce the above
  26  *     copyright notice, this list of conditions and the following
  27  *     disclaimer in the documentation and/or other materials provided
  28  *     with the distribution.
  29  *
  30  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  31  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  32  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  33  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  34  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  35  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  36  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  37  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  38  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  40  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  41  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  42  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  43  *
  44  * ----------------------------------------------------------------------- */
  45
  46 /*
  47  * nasm.h   main header file for the Netwide Assembler: inter-module interface
  48  */
  49
  50 #ifndef NASM_NASM_H
  51 #define NASM_NASM_H
  52
  53 #include "compiler.h"
  54
  55 #include <stdio.h>
  56 #include <inttypes.h>
  57 #include "nasmlib.h"
  58 #include "preproc.h"
  59 #include "insnsi.h"             /* For enum opcode */
  60
  61 #define NO_SEG -1L              /* null segment value */
  62 #define SEG_ABS 0x40000000L     /* mask for far-absolute segments */
  63
  64 #ifndef FILENAME_MAX
  65 #define FILENAME_MAX 256
  66 #endif
  67
  68 #ifndef PREFIX_MAX
  69 #define PREFIX_MAX 10
  70 #endif
  71
  72 #ifndef POSTFIX_MAX
  73 #define POSTFIX_MAX 10
  74 #endif
  75
  76 #define IDLEN_MAX 4096
  77
  78 /*
  79  * Name pollution problems: <time.h> on Digital UNIX pulls in some
  80  * strange hardware header file which sees fit to define R_SP. We
  81  * undefine it here so as not to break the enum below.
  82  */
  83 #ifdef R_SP
  84 #undef R_SP
  85 #endif
  86
  87 /*
  88  * We must declare the existence of this structure type up here,
  89  * since we have to reference it before we define it...
  90  */
  91 struct ofmt;
  92
  93 /*
  94  * values for the `type' parameter to an output function.
  95  *
  96  * Exceptions are OUT_RELxADR, which denote an x-byte relocation
  97  * which will be a relative jump. For this we need to know the
  98  * distance in bytes from the start of the relocated record until
  99  * the end of the containing instruction. _This_ is what is stored
 100  * in the size part of the parameter, in this case.
 101  *
 102  * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
 103  * and the contents of the "data" parameter is irrelevant.
 104  *
 105  * The "data" parameter for the output function points to a "int32_t",
 106  * containing the address in question, unless the type is
 107  * OUT_RAWDATA, in which case it points to an "uint8_t"
 108  * array.
 109  */
 110 enum out_type {
 111     OUT_RAWDATA,                /* Plain bytes */
 112     OUT_ADDRESS,                /* An address (symbol value) */
 113     OUT_RESERVE,                /* Reserved bytes (RESB et al) */
 114     OUT_REL2ADR,                /* 2-byte relative address */
 115     OUT_REL4ADR,                /* 4-byte relative address */
 116     OUT_REL8ADR,                /* 8-byte relative address */
 117 };
 118
 119 /*
 120  * -----------------------
 121  * Other function typedefs
 122  * -----------------------
 123  */
 124
 125 /*
 126  * A label-lookup function should look like this.
 127  */
 128 typedef bool (*lfunc) (char *label, int32_t *segment, int64_t *offset);
 129
 130 /*
 131  * And a label-definition function like this. The boolean parameter
 132  * `is_norm' states whether the label is a `normal' label (which
 133  * should affect the local-label system), or something odder like
 134  * an EQU or a segment-base symbol, which shouldn't.
 135  */
 136 typedef void (*ldfunc) (char *label, int32_t segment, int64_t offset,
 137                         char *special, bool is_norm, bool isextrn,
 138                         struct ofmt * ofmt, efunc error);
 139
 140 /*
 141  * List-file generators should look like this:
 142  */
 143 typedef struct {
 144     /*
 145      * Called to initialize the listing file generator. Before this
 146      * is called, the other routines will silently do nothing when
 147      * called. The `char *' parameter is the file name to write the
 148      * listing to.
 149      */
 150     void (*init) (char *, efunc);
 151
 152     /*
 153      * Called to clear stuff up and close the listing file.
 154      */
 155     void (*cleanup) (void);
 156
 157     /*
 158      * Called to output binary data. Parameters are: the offset;
 159      * the data; the data type. Data types are similar to the
 160      * output-format interface, only OUT_ADDRESS will _always_ be
 161      * displayed as if it's relocatable, so ensure that any non-
 162      * relocatable address has been converted to OUT_RAWDATA by
 163      * then. Note that OUT_RAWDATA,0 is a valid data type, and is a
 164      * dummy call used to give the listing generator an offset to
 165      * work with when doing things like uplevel(LIST_TIMES) or
 166      * uplevel(LIST_INCBIN).
 167      */
 168     void (*output) (int32_t, const void *, enum out_type, uint64_t);
 169
 170     /*
 171      * Called to send a text line to the listing generator. The
 172      * `int' parameter is LIST_READ or LIST_MACRO depending on
 173      * whether the line came directly from an input file or is the
 174      * result of a multi-line macro expansion.
 175      */
 176     void (*line) (int, char *);
 177
 178     /*
 179      * Called to change one of the various levelled mechanisms in
 180      * the listing generator. LIST_INCLUDE and LIST_MACRO can be
 181      * used to increase the nesting level of include files and
 182      * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
 183      * two binary-output-suppression mechanisms for large-scale
 184      * pseudo-instructions.
 185      *
 186      * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
 187      * it indicates the beginning of the expansion of a `nolist'
 188      * macro, so anything under that level won't be expanded unless
 189      * it includes another file.
 190      */
 191     void (*uplevel) (int);
 192
 193     /*
 194      * Reverse the effects of uplevel.
 195      */
 196     void (*downlevel) (int);
 197 } ListGen;
 198
 199 /*
 200  * Token types returned by the scanner, in addition to ordinary
 201  * ASCII character values, and zero for end-of-string.
 202  */
 203 enum token_type {               /* token types, other than chars */
 204     TOKEN_INVALID = -1,         /* a placeholder value */
 205     TOKEN_EOS = 0,              /* end of string */
 206     TOKEN_EQ = '=', TOKEN_GT = '>', TOKEN_LT = '<',     /* aliases */
 207     TOKEN_ID = 256,             /* identifier */
 208     TOKEN_NUM,                  /* numeric constant */
 209     TOKEN_ERRNUM,               /* malformed numeric constant */
 210     TOKEN_STR,                  /* string constant */
 211     TOKEN_ERRSTR,               /* unterminated string constant */
 212     TOKEN_FLOAT,                /* floating-point constant */
 213     TOKEN_REG,                  /* register name */
 214     TOKEN_INSN,                 /* instruction name */
 215     TOKEN_HERE, TOKEN_BASE,     /* $ and $$ */
 216     TOKEN_SPECIAL,              /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
 217     TOKEN_PREFIX,               /* A32, O16, LOCK, REPNZ, TIMES, etc */
 218     TOKEN_SHL, TOKEN_SHR,       /* << and >> */
 219     TOKEN_SDIV, TOKEN_SMOD,     /* // and %% */
 220     TOKEN_GE, TOKEN_LE, TOKEN_NE,       /* >=, <= and <> (!= is same as <>) */
 221     TOKEN_DBL_AND, TOKEN_DBL_OR, TOKEN_DBL_XOR, /* &&, || and ^^ */
 222     TOKEN_SEG, TOKEN_WRT,       /* SEG and WRT */
 223     TOKEN_FLOATIZE,             /* __floatX__ */
 224     TOKEN_STRFUNC,              /* __utf16__, __utf32__ */
 225 };
 226
 227 enum floatize {
 228     FLOAT_8,
 229     FLOAT_16,
 230     FLOAT_32,
 231     FLOAT_64,
 232     FLOAT_80M,
 233     FLOAT_80E,
 234     FLOAT_128L,
 235     FLOAT_128H,
 236 };
 237
 238 /* Must match the list in string_transform(), in strfunc.c */
 239 enum strfunc {
 240     STRFUNC_UTF16,
 241     STRFUNC_UTF32,
 242 };
 243
 244 size_t string_transform(char *, size_t, char **, enum strfunc);
 245
 246 /*
 247  * The expression evaluator must be passed a scanner function; a
 248  * standard scanner is provided as part of nasmlib.c. The
 249  * preprocessor will use a different one. Scanners, and the
 250  * token-value structures they return, look like this.
 251  *
 252  * The return value from the scanner is always a copy of the
 253  * `t_type' field in the structure.
 254  */
 255 struct tokenval {
 256     enum token_type t_type;
 257     char *t_charptr;
 258     int64_t t_integer, t_inttwo;
 259 };
 260 typedef int (*scanner) (void *private_data, struct tokenval * tv);
 261
 262 struct location {
 263     int64_t offset;
 264     int32_t segment;
 265     int known;
 266 };
 267
 268 /*
 269  * Expression-evaluator datatype. Expressions, within the
 270  * evaluator, are stored as an array of these beasts, terminated by
 271  * a record with type==0. Mostly, it's a vector type: each type
 272  * denotes some kind of a component, and the value denotes the
 273  * multiple of that component present in the expression. The
 274  * exception is the WRT type, whose `value' field denotes the
 275  * segment to which the expression is relative. These segments will
 276  * be segment-base types, i.e. either odd segment values or SEG_ABS
 277  * types. So it is still valid to assume that anything with a
 278  * `value' field of zero is insignificant.
 279  */
 280 typedef struct {
 281     int32_t type;                  /* a register, or EXPR_xxx */
 282     int64_t value;                 /* must be >= 32 bits */
 283 } expr;
 284
 285 /*
 286  * Library routines to manipulate expression data types.
 287  */
 288 int is_reloc(expr *);
 289 int is_simple(expr *);
 290 int is_really_simple(expr *);
 291 int is_unknown(expr *);
 292 int is_just_unknown(expr *);
 293 int64_t reloc_value(expr *);
 294 int32_t reloc_seg(expr *);
 295 int32_t reloc_wrt(expr *);
 296
 297 /*
 298  * The evaluator can also return hints about which of two registers
 299  * used in an expression should be the base register. See also the
 300  * `operand' structure.
 301  */
 302 struct eval_hints {
 303     int64_t base;
 304     int type;
 305 };
 306
 307 /*
 308  * The actual expression evaluator function looks like this. When
 309  * called, it expects the first token of its expression to already
 310  * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
 311  * it will start by calling the scanner.
 312  *
 313  * If a forward reference happens during evaluation, the evaluator
 314  * must set `*fwref' to true if `fwref' is non-NULL.
 315  *
 316  * `critical' is non-zero if the expression may not contain forward
 317  * references. The evaluator will report its own error if this
 318  * occurs; if `critical' is 1, the error will be "symbol not
 319  * defined before use", whereas if `critical' is 2, the error will
 320  * be "symbol undefined".
 321  *
 322  * If `critical' has bit 8 set (in addition to its main value: 0x101
 323  * and 0x102 correspond to 1 and 2) then an extended expression
 324  * syntax is recognised, in which relational operators such as =, <
 325  * and >= are accepted, as well as low-precedence logical operators
 326  * &&, ^^ and ||.
 327  *
 328  * If `hints' is non-NULL, it gets filled in with some hints as to
 329  * the base register in complex effective addresses.
 330  */
 331 #define CRITICAL 0x100
 332 typedef expr *(*evalfunc) (scanner sc, void *scprivate,
 333                            struct tokenval * tv, int *fwref, int critical,
 334                            efunc error, struct eval_hints * hints);
 335
 336 /*
 337  * Special values for expr->type.  These come after EXPR_REG_END
 338  * as defined in regs.h.
 339  */
 340
 341 #define EXPR_UNKNOWN    (EXPR_REG_END+1) /* forward references */
 342 #define EXPR_SIMPLE     (EXPR_REG_END+2)
 343 #define EXPR_WRT        (EXPR_REG_END+3)
 344 #define EXPR_SEGBASE    (EXPR_REG_END+4)
 345
 346 /*
 347  * Linked list of strings...
 348  */
 349 typedef struct string_list {
 350     struct string_list *next;
 351     char str[1];
 352 } StrList;
 353
 354 /*
 355  * preprocessors ought to look like this:
 356  */
 357 typedef struct preproc_ops {
 358     /*
 359      * Called at the start of a pass; given a file name, the number
 360      * of the pass, an error reporting function, an evaluator
 361      * function, and a listing generator to talk to.
 362      */
 363     void (*reset) (char *, int, efunc, evalfunc, ListGen *, StrList **);
 364
 365     /*
 366      * Called to fetch a line of preprocessed source. The line
 367      * returned has been malloc'ed, and so should be freed after
 368      * use.
 369      */
 370     char *(*getline) (void);
 371
 372     /*
 373      * Called at the end of a pass.
 374      */
 375     void (*cleanup) (int);
 376 } Preproc;
 377
 378 extern Preproc nasmpp;
 379
 380 /*
 381  * ----------------------------------------------------------------
 382  * Some lexical properties of the NASM source language, included
 383  * here because they are shared between the parser and preprocessor
 384  * ----------------------------------------------------------------
 385  */
 386
 387 /*
 388  * isidstart matches any character that may start an identifier, and isidchar
 389  * matches any character that may appear at places other than the start of an
 390  * identifier. E.g. a period may only appear at the start of an identifier
 391  * (for local labels), whereas a number may appear anywhere *but* at the
 392  * start.
 393  */
 394
 395 #define isidstart(c) ( nasm_isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
 396                                   || (c)=='@' )
 397 #define isidchar(c)  ( isidstart(c) || nasm_isdigit(c) || \
 398                        (c)=='$' || (c)=='#' || (c)=='~' )
 399
 400 /* Ditto for numeric constants. */
 401
 402 #define isnumstart(c)  ( nasm_isdigit(c) || (c)=='$' )
 403 #define isnumchar(c)   ( nasm_isalnum(c) || (c)=='_' )
 404
 405 /* This returns the numeric value of a given 'digit'. */
 406
 407 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 408
 409 /*
 410  * Data-type flags that get passed to listing-file routines.
 411  */
 412 enum {
 413     LIST_READ, LIST_MACRO, LIST_MACRO_NOLIST, LIST_INCLUDE,
 414     LIST_INCBIN, LIST_TIMES
 415 };
 416
 417 /*
 418  * -----------------------------------------------------------
 419  * Format of the `insn' structure returned from `parser.c' and
 420  * passed into `assemble.c'
 421  * -----------------------------------------------------------
 422  */
 423
 424 /*
 425  * Here we define the operand types. These are implemented as bit
 426  * masks, since some are subsets of others; e.g. AX in a MOV
 427  * instruction is a special operand type, whereas AX in other
 428  * contexts is just another 16-bit register. (Also, consider CL in
 429  * shift instructions, DX in OUT, etc.)
 430  *
 431  * The basic concept here is that
 432  *    (class & ~operand) == 0
 433  *
 434  * if and only if "operand" belongs to class type "class".
 435  *
 436  * The bits are assigned as follows:
 437  *
 438  * Bits 0-7, 23, 29: sizes
 439  *  0:  8 bits (BYTE)
 440  *  1: 16 bits (WORD)
 441  *  2: 32 bits (DWORD)
 442  *  3: 64 bits (QWORD)
 443  *  4: 80 bits (TWORD)
 444  *  5: FAR
 445  *  6: NEAR
 446  *  7: SHORT
 447  * 23: 256 bits (YWORD)
 448  * 29: 128 bits (OWORD)
 449  *
 450  * Bits 8-11 modifiers
 451  *  8: TO
 452  *  9: COLON
 453  * 10: STRICT
 454  * 11: (reserved)
 455  *
 456  * Bits 12-15: type of operand
 457  * 12: REGISTER
 458  * 13: IMMEDIATE
 459  * 14: MEMORY (always has REGMEM attribute as well)
 460  * 15: REGMEM (valid EA operand)
 461  *
 462  * Bits 16-19, 28: subclasses
 463  * With REG_CDT:
 464  * 16: REG_CREG (CRx)
 465  * 17: REG_DREG (DRx)
 466  * 18: REG_TREG (TRx)
 467
 468  * With REG_GPR:
 469  * 16: REG_ACCUM  (AL, AX, EAX, RAX)
 470  * 17: REG_COUNT  (CL, CX, ECX, RCX)
 471  * 18: REG_DATA   (DL, DX, EDX, RDX)
 472  * 19: REG_HIGH   (AH, CH, DH, BH)
 473  * 28: REG_NOTACC (not REG_ACCUM)
 474  *
 475  * With REG_SREG:
 476  * 16: REG_CS
 477  * 17: REG_DESS (DS, ES, SS)
 478  * 18: REG_FSGS
 479  * 19: REG_SEG67
 480  *
 481  * With FPUREG:
 482  * 16: FPU0
 483  *
 484  * With XMMREG:
 485  * 16: XMM0
 486  *
 487  * With YMMREG:
 488  * 16: YMM0
 489  *
 490  * With MEMORY:
 491  * 16: MEM_OFFS (this is a simple offset)
 492  * 17: IP_REL (IP-relative offset)
 493  *
 494  * With IMMEDIATE:
 495  * 16: UNITY (1)
 496  * 17: BYTENESS16 (-128..127)
 497  * 18: BYTENESS32 (-128..127)
 498  * 19: BYTENESS64 (-128..127)
 499  *
 500  * Bits 20-22, 24-27: register classes
 501  * 20: REG_CDT (CRx, DRx, TRx)
 502  * 21: RM_GPR (REG_GPR) (integer register)
 503  * 22: REG_SREG
 504  * 24: FPUREG
 505  * 25: RM_MMX (MMXREG)
 506  * 26: RM_XMM (XMMREG)
 507  * 27: RM_YMM (YMMREG)
 508  *
 509  * Bit 31 is currently unallocated.
 510  *
 511  * 30: SAME_AS
 512  * Special flag only used in instruction patterns; means this operand
 513  * has to be identical to another operand.  Currently only supported
 514  * for registers.
 515  */
 516
 517 typedef uint32_t opflags_t;
 518
 519 /* Size, and other attributes, of the operand */
 520 #define BITS8           0x00000001U
 521 #define BITS16          0x00000002U
 522 #define BITS32          0x00000004U
 523 #define BITS64          0x00000008U   /* x64 and FPU only */
 524 #define BITS80          0x00000010U   /* FPU only */
 525 #define BITS128         0x20000000U
 526 #define BITS256         0x00800000U
 527 #define FAR             0x00000020U   /* grotty: this means 16:16 or */
 528                                        /* 16:32, like in CALL/JMP */
 529 #define NEAR            0x00000040U
 530 #define SHORT           0x00000080U   /* and this means what it says :) */
 531
 532 #define SIZE_MASK       0x208000FFU   /* all the size attributes */
 533
 534 /* Modifiers */
 535 #define MODIFIER_MASK   0x00000f00U
 536 #define TO              0x00000100U   /* reverse effect in FADD, FSUB &c */
 537 #define COLON           0x00000200U   /* operand is followed by a colon */
 538 #define STRICT          0x00000400U   /* do not optimize this operand */
 539
 540 /* Type of operand: memory reference, register, etc. */
 541 #define OPTYPE_MASK     0x0000f000U
 542 #define REGISTER        0x00001000U   /* register number in 'basereg' */
 543 #define IMMEDIATE       0x00002000U
 544 #define MEMORY          0x0000c000U
 545 #define REGMEM          0x00008000U   /* for r/m, ie EA, operands */
 546
 547 /* Register classes */
 548 #define REG_EA          0x00009000U   /* 'normal' reg, qualifies as EA */
 549 #define RM_GPR          0x00208000U   /* integer operand */
 550 #define REG_GPR         0x00209000U   /* integer register */
 551 #define REG8            0x00209001U   /*  8-bit GPR  */
 552 #define REG16           0x00209002U   /* 16-bit GPR */
 553 #define REG32           0x00209004U   /* 32-bit GPR */
 554 #define REG64           0x00209008U   /* 64-bit GPR */
 555 #define FPUREG          0x01001000U   /* floating point stack registers */
 556 #define FPU0            0x01011000U   /* FPU stack register zero */
 557 #define RM_MMX          0x02008000U   /* MMX operand */
 558 #define MMXREG          0x02009000U   /* MMX register */
 559 #define RM_XMM          0x04008000U   /* XMM (SSE) operand */
 560 #define XMMREG          0x04009000U   /* XMM (SSE) register */
 561 #define XMM0            0x04019000U   /* XMM register zero */
 562 #define RM_YMM          0x08008000U   /* YMM (AVX) operand */
 563 #define YMMREG          0x08009000U   /* YMM (AVX) register */
 564 #define YMM0            0x08019000U   /* YMM register zero */
 565 #define REG_CDT         0x00101004U   /* CRn, DRn and TRn */
 566 #define REG_CREG        0x00111004U   /* CRn */
 567 #define REG_DREG        0x00121004U   /* DRn */
 568 #define REG_TREG        0x00141004U   /* TRn */
 569 #define REG_SREG        0x00401002U   /* any segment register */
 570 #define REG_CS          0x00411002U   /* CS */
 571 #define REG_DESS        0x00421002U   /* DS, ES, SS */
 572 #define REG_FSGS        0x00441002U   /* FS, GS */
 573 #define REG_SEG67       0x00481002U   /* Unimplemented segment registers */
 574
 575 #define REG_RIP         0x00801008U   /* RIP relative addressing */
 576 #define REG_EIP         0x00801004U   /* EIP relative addressing */
 577
 578 /* Special GPRs */
 579 #define REG_SMASK       0x100f0000U   /* a mask for the following */
 580 #define REG_ACCUM       0x00219000U   /* accumulator: AL, AX, EAX, RAX */
 581 #define REG_AL          0x00219001U
 582 #define REG_AX          0x00219002U
 583 #define REG_EAX         0x00219004U
 584 #define REG_RAX         0x00219008U
 585 #define REG_COUNT       0x10229000U   /* counter: CL, CX, ECX, RCX */
 586 #define REG_CL          0x10229001U
 587 #define REG_CX          0x10229002U
 588 #define REG_ECX         0x10229004U
 589 #define REG_RCX         0x10229008U
 590 #define REG_DL          0x10249001U   /* data: DL, DX, EDX, RDX */
 591 #define REG_DX          0x10249002U
 592 #define REG_EDX         0x10249004U
 593 #define REG_RDX         0x10249008U
 594 #define REG_HIGH        0x10289001U   /* high regs: AH, CH, DH, BH */
 595 #define REG_NOTACC      0x10000000U   /* non-accumulator register */
 596 #define REG8NA          0x10209001U   /*  8-bit non-acc GPR  */
 597 #define REG16NA         0x10209002U   /* 16-bit non-acc GPR */
 598 #define REG32NA         0x10209004U   /* 32-bit non-acc GPR */
 599 #define REG64NA         0x10209008U   /* 64-bit non-acc GPR */
 600
 601 /* special types of EAs */
 602 #define MEM_OFFS        0x0001c000U   /* simple [address] offset - absolute! */
 603 #define IP_REL          0x0002c000U   /* IP-relative offset */
 604
 605 /* memory which matches any type of r/m operand */
 606 #define MEMORY_ANY      (MEMORY|RM_GPR|RM_MMX|RM_XMM|RM_YMM)
 607
 608 /* special type of immediate operand */
 609 #define UNITY           0x00012000U   /* for shift/rotate instructions */
 610 #define SBYTE16         0x00022000U   /* for op r16,immediate instrs. */
 611 #define SBYTE32         0x00042000U   /* for op r32,immediate instrs. */
 612 #define SBYTE64         0x00082000U   /* for op r64,immediate instrs. */
 613 #define BYTENESS        0x000e0000U   /* for testing for byteness */
 614
 615 /* special flags */
 616 #define SAME_AS         0x40000000U
 617
 618 /* Register names automatically generated from regs.dat */
 619 #include "regs.h"
 620
 621 enum ccode {                    /* condition code names */
 622     C_A, C_AE, C_B, C_BE, C_C, C_E, C_G, C_GE, C_L, C_LE, C_NA, C_NAE,
 623     C_NB, C_NBE, C_NC, C_NE, C_NG, C_NGE, C_NL, C_NLE, C_NO, C_NP,
 624     C_NS, C_NZ, C_O, C_P, C_PE, C_PO, C_S, C_Z,
 625     C_none = -1
 626 };
 627
 628 /*
 629  * REX flags
 630  */
 631 #define REX_REAL        0x4f    /* Actual REX prefix bits */
 632 #define REX_B           0x01    /* ModRM r/m extension */
 633 #define REX_X           0x02    /* SIB index extension */
 634 #define REX_R           0x04    /* ModRM reg extension */
 635 #define REX_W           0x08    /* 64-bit operand size */
 636 #define REX_L           0x20    /* Use LOCK prefix instead of REX.R */
 637 #define REX_P           0x40    /* REX prefix present/required */
 638 #define REX_H           0x80    /* High register present, REX forbidden */
 639 #define REX_D           0x0100  /* Instruction uses DREX instead of REX */
 640 #define REX_OC          0x0200  /* DREX suffix has the OC0 bit set */
 641 #define REX_V           0x0400  /* Instruction uses VEX/XOP instead of REX */
 642 #define REX_NH          0x0800  /* Instruction which doesn't use high regs */
 643
 644 /*
 645  * REX_V "classes" (prefixes which behave like VEX)
 646  */
 647 enum vex_class {
 648     RV_VEX              = 0,    /* C4/C5 */
 649     RV_XOP              = 1     /* 8F */
 650 };
 651
 652 /*
 653  * Note that because segment registers may be used as instruction
 654  * prefixes, we must ensure the enumerations for prefixes and
 655  * register names do not overlap.
 656  */
 657 enum prefixes {                 /* instruction prefixes */
 658     P_none = 0,
 659     PREFIX_ENUM_START = REG_ENUM_LIMIT,
 660     P_A16 = PREFIX_ENUM_START, P_A32, P_A64, P_ASP,
 661     P_LOCK, P_O16, P_O32, P_O64, P_OSP,
 662     P_REP, P_REPE, P_REPNE, P_REPNZ, P_REPZ, P_TIMES,
 663     P_WAIT,
 664     PREFIX_ENUM_LIMIT
 665 };
 666
 667 enum extop_type {               /* extended operand types */
 668     EOT_NOTHING,
 669     EOT_DB_STRING,              /* Byte string */
 670     EOT_DB_STRING_FREE,         /* Byte string which should be nasm_free'd*/
 671     EOT_DB_NUMBER,              /* Integer */
 672 };
 673
 674 enum ea_flags {                 /* special EA flags */
 675     EAF_BYTEOFFS =  1,          /* force offset part to byte size */
 676     EAF_WORDOFFS =  2,          /* force offset part to [d]word size */
 677     EAF_TIMESTWO =  4,          /* really do EAX*2 not EAX+EAX */
 678     EAF_REL      =  8,          /* IP-relative addressing */
 679     EAF_ABS      = 16,          /* non-IP-relative addressing */
 680     EAF_FSGS     = 32           /* fs/gs segment override present */
 681 };
 682
 683 enum eval_hint {                /* values for `hinttype' */
 684     EAH_NOHINT   = 0,           /* no hint at all - our discretion */
 685     EAH_MAKEBASE = 1,           /* try to make given reg the base */
 686     EAH_NOTBASE  = 2            /* try _not_ to make reg the base */
 687 };
 688
 689 typedef struct operand {        /* operand to an instruction */
 690     int32_t type;               /* type of operand */
 691     int disp_size;              /* 0 means default; 16; 32; 64 */
 692     enum reg_enum basereg, indexreg; /* address registers */
 693     int scale;                  /* index scale */
 694     int hintbase;
 695     enum eval_hint hinttype;    /* hint as to real base register */
 696     int32_t segment;            /* immediate segment, if needed */
 697     int64_t offset;             /* any immediate number */
 698     int32_t wrt;                /* segment base it's relative to */
 699     int eaflags;                /* special EA flags */
 700     int opflags;                /* see OPFLAG_* defines below */
 701 } operand;
 702
 703 #define OPFLAG_FORWARD          1       /* operand is a forward reference */
 704 #define OPFLAG_EXTERN           2       /* operand is an external reference */
 705 #define OPFLAG_UNKNOWN          4       /* operand is an unknown reference */
 706                                         /* (always a forward reference also) */
 707
 708 typedef struct extop {          /* extended operand */
 709     struct extop *next;         /* linked list */
 710     char *stringval;            /* if it's a string, then here it is */
 711     size_t stringlen;           /* ... and here's how long it is */
 712     int64_t offset;             /* ... it's given here ... */
 713     int32_t segment;            /* if it's a number/address, then... */
 714     int32_t wrt;                /* ... and here */
 715     enum extop_type type;       /* defined above */
 716 } extop;
 717
 718 /* Prefix positions: each type of prefix goes in a specific slot.
 719    This affects the final ordering of the assembled output, which
 720    shouldn't matter to the processor, but if you have stylistic
 721    preferences, you can change this.  REX prefixes are handled
 722    differently for the time being.
 723
 724    Note that LOCK and REP are in the same slot.  This is
 725    an x86 architectural constraint. */
 726 enum prefix_pos {
 727     PPS_WAIT,                   /* WAIT (technically not a prefix!) */
 728     PPS_LREP,                   /* Lock or REP prefix */
 729     PPS_SEG,                    /* Segment override prefix */
 730     PPS_OSIZE,                  /* Operand size prefix */
 731     PPS_ASIZE,                  /* Address size prefix */
 732     MAXPREFIX                   /* Total number of prefix slots */
 733 };
 734
 735 /* If you need to change this, also change it in insns.pl */
 736 #define MAX_OPERANDS 5
 737
 738 typedef struct insn {           /* an instruction itself */
 739     char *label;                /* the label defined, or NULL */
 740     enum prefixes prefixes[MAXPREFIX]; /* instruction prefixes, if any */
 741     enum opcode opcode;         /* the opcode - not just the string */
 742     enum ccode condition;       /* the condition code, if Jcc/SETcc */
 743     int operands;               /* how many operands? 0-3
 744                                  * (more if db et al) */
 745     int addr_size;              /* address size */
 746     operand oprs[MAX_OPERANDS]; /* the operands, defined as above */
 747     extop *eops;                /* extended operands */
 748     int eops_float;             /* true if DD and floating */
 749     int32_t times;              /* repeat count (TIMES prefix) */
 750     bool forw_ref;              /* is there a forward reference? */
 751     int rex;                    /* Special REX Prefix */
 752     int drexdst;                /* Destination register for DREX/VEX suffix */
 753     int vex_cm;                 /* Class and M field for VEX prefix */
 754     int vex_wlp;                /* W, P and L information for VEX prefix */
 755 } insn;
 756
 757 enum geninfo { GI_SWITCH };
 758 /*
 759  * ------------------------------------------------------------
 760  * The data structure defining an output format driver, and the
 761  * interfaces to the functions therein.
 762  * ------------------------------------------------------------
 763  */
 764
 765 struct ofmt {
 766     /*
 767      * This is a short (one-liner) description of the type of
 768      * output generated by the driver.
 769      */
 770     const char *fullname;
 771
 772     /*
 773      * This is a single keyword used to select the driver.
 774      */
 775     const char *shortname;
 776
 777
 778     /*
 779      * this is reserved for out module specific help.
 780      * It is set to NULL in all the out modules and is not implemented
 781      * in the main program
 782      */
 783     const char *helpstring;
 784
 785     /*
 786      * this is a pointer to the first element of the debug information
 787      */
 788     struct dfmt **debug_formats;
 789
 790     /*
 791      * and a pointer to the element that is being used
 792      * note: this is set to the default at compile time and changed if the
 793      * -F option is selected.  If developing a set of new debug formats for
 794      * an output format, be sure to set this to whatever default you want
 795      *
 796      */
 797     struct dfmt *current_dfmt;
 798
 799     /*
 800      * This, if non-NULL, is a NULL-terminated list of `char *'s
 801      * pointing to extra standard macros supplied by the object
 802      * format (e.g. a sensible initial default value of __SECT__,
 803      * and user-level equivalents for any format-specific
 804      * directives).
 805      */
 806     macros_t *stdmac;
 807
 808     /*
 809      * This procedure is called at the start of an output session.
 810      * It tells the output format what file it will be writing to,
 811      * what routine to report errors through, and how to interface
 812      * to the label manager and expression evaluator if necessary.
 813      * It also gives it a chance to do other initialisation.
 814      */
 815     void (*init) (FILE * fp, efunc error, ldfunc ldef, evalfunc eval);
 816
 817     /*
 818      * This procedure is called to pass generic information to the
 819      * object file.  The first parameter gives the information type
 820      * (currently only command line switches)
 821      * and the second parameter gives the value.  This function returns
 822      * 1 if recognized, 0 if unrecognized
 823      */
 824     int (*setinfo) (enum geninfo type, char **string);
 825
 826     /*
 827      * This procedure is called by assemble() to write actual
 828      * generated code or data to the object file. Typically it
 829      * doesn't have to actually _write_ it, just store it for
 830      * later.
 831      *
 832      * The `type' argument specifies the type of output data, and
 833      * usually the size as well: its contents are described below.
 834      */
 835     void (*output) (int32_t segto, const void *data,
 836                     enum out_type type, uint64_t size,
 837                     int32_t segment, int32_t wrt);
 838
 839     /*
 840      * This procedure is called once for every symbol defined in
 841      * the module being assembled. It gives the name and value of
 842      * the symbol, in NASM's terms, and indicates whether it has
 843      * been declared to be global. Note that the parameter "name",
 844      * when passed, will point to a piece of static storage
 845      * allocated inside the label manager - it's safe to keep using
 846      * that pointer, because the label manager doesn't clean up
 847      * until after the output driver has.
 848      *
 849      * Values of `is_global' are: 0 means the symbol is local; 1
 850      * means the symbol is global; 2 means the symbol is common (in
 851      * which case `offset' holds the _size_ of the variable).
 852      * Anything else is available for the output driver to use
 853      * internally.
 854      *
 855      * This routine explicitly _is_ allowed to call the label
 856      * manager to define further symbols, if it wants to, even
 857      * though it's been called _from_ the label manager. That much
 858      * re-entrancy is guaranteed in the label manager. However, the
 859      * label manager will in turn call this routine, so it should
 860      * be prepared to be re-entrant itself.
 861      *
 862      * The `special' parameter contains special information passed
 863      * through from the command that defined the label: it may have
 864      * been an EXTERN, a COMMON or a GLOBAL. The distinction should
 865      * be obvious to the output format from the other parameters.
 866      */
 867     void (*symdef) (char *name, int32_t segment, int64_t offset,
 868                     int is_global, char *special);
 869
 870     /*
 871      * This procedure is called when the source code requests a
 872      * segment change. It should return the corresponding segment
 873      * _number_ for the name, or NO_SEG if the name is not a valid
 874      * segment name.
 875      *
 876      * It may also be called with NULL, in which case it is to
 877      * return the _default_ section number for starting assembly in.
 878      *
 879      * It is allowed to modify the string it is given a pointer to.
 880      *
 881      * It is also allowed to specify a default instruction size for
 882      * the segment, by setting `*bits' to 16 or 32. Or, if it
 883      * doesn't wish to define a default, it can leave `bits' alone.
 884      */
 885     int32_t (*section) (char *name, int pass, int *bits);
 886
 887     /*
 888      * This procedure is called to modify the segment base values
 889      * returned from the SEG operator. It is given a segment base
 890      * value (i.e. a segment value with the low bit set), and is
 891      * required to produce in return a segment value which may be
 892      * different. It can map segment bases to absolute numbers by
 893      * means of returning SEG_ABS types.
 894      *
 895      * It should return NO_SEG if the segment base cannot be
 896      * determined; the evaluator (which calls this routine) is
 897      * responsible for throwing an error condition if that occurs
 898      * in pass two or in a critical expression.
 899      */
 900     int32_t (*segbase) (int32_t segment);
 901
 902     /*
 903      * This procedure is called to allow the output driver to
 904      * process its own specific directives. When called, it has the
 905      * directive word in `directive' and the parameter string in
 906      * `value'. It is called in both assembly passes, and `pass'
 907      * will be either 1 or 2.
 908      *
 909      * This procedure should return zero if it does not _recognise_
 910      * the directive, so that the main program can report an error.
 911      * If it recognises the directive but then has its own errors,
 912      * it should report them itself and then return non-zero. It
 913      * should also return non-zero if it correctly processes the
 914      * directive.
 915      */
 916     int (*directive) (char *directive, char *value, int pass);
 917
 918     /*
 919      * This procedure is called before anything else - even before
 920      * the "init" routine - and is passed the name of the input
 921      * file from which this output file is being generated. It
 922      * should return its preferred name for the output file in
 923      * `outname', if outname[0] is not '\0', and do nothing to
 924      * `outname' otherwise. Since it is called before the driver is
 925      * properly initialized, it has to be passed its error handler
 926      * separately.
 927      *
 928      * This procedure may also take its own copy of the input file
 929      * name for use in writing the output file: it is _guaranteed_
 930      * that it will be called before the "init" routine.
 931      *
 932      * The parameter `outname' points to an area of storage
 933      * guaranteed to be at least FILENAME_MAX in size.
 934      */
 935     void (*filename) (char *inname, char *outname, efunc error);
 936
 937     /*
 938      * This procedure is called after assembly finishes, to allow
 939      * the output driver to clean itself up and free its memory.
 940      * Typically, it will also be the point at which the object
 941      * file actually gets _written_.
 942      *
 943      * One thing the cleanup routine should always do is to close
 944      * the output file pointer.
 945      */
 946     void (*cleanup) (int debuginfo);
 947 };
 948
 949
 950 /*
 951  * ------------------------------------------------------------
 952  * The data structure defining a debug format driver, and the
 953  * interfaces to the functions therein.
 954  * ------------------------------------------------------------
 955  */
 956
 957 struct dfmt {
 958
 959     /*
 960      * This is a short (one-liner) description of the type of
 961      * output generated by the driver.
 962      */
 963     const char *fullname;
 964
 965     /*
 966      * This is a single keyword used to select the driver.
 967      */
 968     const char *shortname;
 969
 970     /*
 971      * init - called initially to set up local pointer to object format,
 972      * void pointer to implementation defined data, file pointer (which
 973      * probably won't be used, but who knows?), and error function.
 974      */
 975     void (*init) (struct ofmt * of, void *id, FILE * fp, efunc error);
 976
 977     /*
 978      * linenum - called any time there is output with a change of
 979      * line number or file.
 980      */
 981     void (*linenum) (const char *filename, int32_t linenumber, int32_t segto);
 982
 983     /*
 984      * debug_deflabel - called whenever a label is defined. Parameters
 985      * are the same as to 'symdef()' in the output format. This function
 986      * would be called before the output format version.
 987      */
 988
 989     void (*debug_deflabel) (char *name, int32_t segment, int64_t offset,
 990                             int is_global, char *special);
 991     /*
 992      * debug_directive - called whenever a DEBUG directive other than 'LINE'
 993      * is encountered. 'directive' contains the first parameter to the
 994      * DEBUG directive, and params contains the rest. For example,
 995      * 'DEBUG VAR _somevar:int' would translate to a call to this
 996      * function with 'directive' equal to "VAR" and 'params' equal to
 997      * "_somevar:int".
 998      */
 999     void (*debug_directive) (const char *directive, const char *params);
1000
1001     /*
1002      * typevalue - called whenever the assembler wishes to register a type
1003      * for the last defined label.  This routine MUST detect if a type was
1004      * already registered and not re-register it.
1005      */
1006     void (*debug_typevalue) (int32_t type);
1007
1008     /*
1009      * debug_output - called whenever output is required
1010      * 'type' is the type of info required, and this is format-specific
1011      */
1012     void (*debug_output) (int type, void *param);
1013
1014     /*
1015      * cleanup - called after processing of file is complete
1016      */
1017     void (*cleanup) (void);
1018
1019 };
1020 /*
1021  * The type definition macros
1022  * for debugging
1023  *
1024  * low 3 bits: reserved
1025  * next 5 bits: type
1026  * next 24 bits: number of elements for arrays (0 for labels)
1027  */
1028
1029 #define TY_UNKNOWN 0x00
1030 #define TY_LABEL   0x08
1031 #define TY_BYTE    0x10
1032 #define TY_WORD    0x18
1033 #define TY_DWORD   0x20
1034 #define TY_FLOAT   0x28
1035 #define TY_QWORD   0x30
1036 #define TY_TBYTE   0x38
1037 #define TY_OWORD   0x40
1038 #define TY_YWORD   0x48
1039 #define TY_COMMON  0xE0
1040 #define TY_SEG     0xE8
1041 #define TY_EXTERN  0xF0
1042 #define TY_EQU     0xF8
1043
1044 #define TYM_TYPE(x) ((x) & 0xF8)
1045 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
1046
1047 #define TYS_ELEMENTS(x)  ((x) << 8)
1048
1049 /*
1050  * -----
1051  * Special tokens
1052  * -----
1053  */
1054
1055 enum special_tokens {
1056     SPECIAL_ENUM_START = PREFIX_ENUM_LIMIT,
1057     S_ABS = SPECIAL_ENUM_START,
1058     S_BYTE, S_DWORD, S_FAR, S_LONG, S_NEAR, S_NOSPLIT,
1059     S_OWORD, S_QWORD, S_REL, S_SHORT, S_STRICT, S_TO, S_TWORD, S_WORD, S_YWORD,
1060     SPECIAL_ENUM_LIMIT
1061 };
1062
1063 /*
1064  * -----
1065  * Global modes
1066  * -----
1067  */
1068
1069 /*
1070  * This declaration passes the "pass" number to all other modules
1071  * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
1072  * where 0 = optimizing pass
1073  *       1 = pass 1
1074  *       2 = pass 2
1075  */
1076
1077 extern int pass0;
1078 extern int passn;               /* Actual pass number */
1079
1080 extern bool tasm_compatible_mode;
1081 extern int optimizing;
1082 extern int globalbits;          /* 16, 32 or 64-bit mode */
1083 extern int globalrel;           /* default to relative addressing? */
1084 extern int maxbits;             /* max bits supported by output */
1085
1086 /*
1087  * NASM version strings, defined in ver.c
1088  */
1089 extern const char nasm_version[];
1090 extern const char nasm_date[];
1091 extern const char nasm_compile_options[];
1092 extern const char nasm_comment[];
1093 extern const char nasm_signature[];
1094
1095 #endif