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