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