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