AltairZ80/nasm.h

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