Commit | Line | Data |
---|---|---|
196ba1fc PH |
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 |