nasm.h

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