1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2012 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
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 * ----------------------------------------------------------------------- */
35 * nasm.h main header file for the Netwide Assembler: inter-module interface
47 #include "insnsi.h" /* For enum opcode */
48 #include "directiv.h" /* For enum directive */
52 #define NO_SEG -1L /* null segment value */
53 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
56 #define FILENAME_MAX 256
64 #define POSTFIX_MAX 10
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.
79 * We must declare the existence of this structure type up here,
80 * since we have to reference it before we define it...
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"
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 * A label-lookup function.
114 typedef bool (*lfunc
)(char *label
, int32_t *segment
, int64_t *offset
);
117 * And a label-definition function. The boolean parameter
118 * `is_norm' states whether the label is a `normal' label (which
119 * should affect the local-label system), or something odder like
120 * an EQU or a segment-base symbol, which shouldn't.
122 typedef void (*ldfunc
)(char *label
, int32_t segment
, int64_t offset
,
123 char *special
, bool is_norm
, bool isextrn
);
125 void define_label(char *label
, int32_t segment
, int64_t offset
,
126 char *special
, bool is_norm
, bool isextrn
);
129 * List-file generators should look like this:
133 * Called to initialize the listing file generator. Before this
134 * is called, the other routines will silently do nothing when
135 * called. The `char *' parameter is the file name to write the
138 void (*init
)(char *fname
, efunc error
);
141 * Called to clear stuff up and close the listing file.
143 void (*cleanup
)(void);
146 * Called to output binary data. Parameters are: the offset;
147 * the data; the data type. Data types are similar to the
148 * output-format interface, only OUT_ADDRESS will _always_ be
149 * displayed as if it's relocatable, so ensure that any non-
150 * relocatable address has been converted to OUT_RAWDATA by
151 * then. Note that OUT_RAWDATA,0 is a valid data type, and is a
152 * dummy call used to give the listing generator an offset to
153 * work with when doing things like uplevel(LIST_TIMES) or
154 * uplevel(LIST_INCBIN).
156 void (*output
)(int32_t offset
, const void *data
, enum out_type type
, uint64_t size
);
159 * Called to send a text line to the listing generator. The
160 * `int' parameter is LIST_READ or LIST_MACRO depending on
161 * whether the line came directly from an input file or is the
162 * result of a multi-line macro expansion.
164 void (*line
)(int type
, char *line
);
167 * Called to change one of the various levelled mechanisms in
168 * the listing generator. LIST_INCLUDE and LIST_MACRO can be
169 * used to increase the nesting level of include files and
170 * macro expansions; LIST_TIMES and LIST_INCBIN switch on the
171 * two binary-output-suppression mechanisms for large-scale
172 * pseudo-instructions.
174 * LIST_MACRO_NOLIST is synonymous with LIST_MACRO except that
175 * it indicates the beginning of the expansion of a `nolist'
176 * macro, so anything under that level won't be expanded unless
177 * it includes another file.
179 void (*uplevel
)(int type
);
182 * Reverse the effects of uplevel.
184 void (*downlevel
)(int type
);
187 * Called on a warning or error, with the error message.
189 void (*error
)(int severity
, const char *pfx
, const char *msg
);
193 * Token types returned by the scanner, in addition to ordinary
194 * ASCII character values, and zero for end-of-string.
196 enum token_type
{ /* token types, other than chars */
197 TOKEN_INVALID
= -1, /* a placeholder value */
198 TOKEN_EOS
= 0, /* end of string */
201 TOKEN_LT
= '<', /* aliases */
202 TOKEN_ID
= 256, /* identifier */
203 TOKEN_NUM
, /* numeric constant */
204 TOKEN_ERRNUM
, /* malformed numeric constant */
205 TOKEN_STR
, /* string constant */
206 TOKEN_ERRSTR
, /* unterminated string constant */
207 TOKEN_FLOAT
, /* floating-point constant */
208 TOKEN_REG
, /* register name */
209 TOKEN_INSN
, /* instruction name */
212 TOKEN_SPECIAL
, /* BYTE, WORD, DWORD, QWORD, FAR, NEAR, etc */
213 TOKEN_PREFIX
, /* A32, O16, LOCK, REPNZ, TIMES, etc */
220 TOKEN_NE
, /* <> (!= is same as <>) */
221 TOKEN_DBL_AND
, /* && */
222 TOKEN_DBL_OR
, /* || */
223 TOKEN_DBL_XOR
, /* ^^ */
226 TOKEN_FLOATIZE
, /* __floatX__ */
227 TOKEN_STRFUNC
, /* __utf16*__, __utf32*__ */
241 /* Must match the list in string_transform(), in strfunc.c */
251 size_t string_transform(char *, size_t, char **, enum strfunc
);
254 * The expression evaluator must be passed a scanner function; a
255 * standard scanner is provided as part of nasmlib.c. The
256 * preprocessor will use a different one. Scanners, and the
257 * token-value structures they return, look like this.
259 * The return value from the scanner is always a copy of the
260 * `t_type' field in the structure.
266 enum token_type t_type
;
268 typedef int (*scanner
)(void *private_data
, struct tokenval
*tv
);
277 * Expression-evaluator datatype. Expressions, within the
278 * evaluator, are stored as an array of these beasts, terminated by
279 * a record with type==0. Mostly, it's a vector type: each type
280 * denotes some kind of a component, and the value denotes the
281 * multiple of that component present in the expression. The
282 * exception is the WRT type, whose `value' field denotes the
283 * segment to which the expression is relative. These segments will
284 * be segment-base types, i.e. either odd segment values or SEG_ABS
285 * types. So it is still valid to assume that anything with a
286 * `value' field of zero is insignificant.
289 int32_t type
; /* a register, or EXPR_xxx */
290 int64_t value
; /* must be >= 32 bits */
294 * Library routines to manipulate expression data types.
296 int is_reloc(expr
*vect
);
297 int is_simple(expr
*vect
);
298 int is_really_simple(expr
*vect
);
299 int is_unknown(expr
*vect
);
300 int is_just_unknown(expr
*vect
);
301 int64_t reloc_value(expr
*vect
);
302 int32_t reloc_seg(expr
*vect
);
303 int32_t reloc_wrt(expr
*vect
);
306 * The evaluator can also return hints about which of two registers
307 * used in an expression should be the base register. See also the
308 * `operand' structure.
316 * The actual expression evaluator function looks like this. When
317 * called, it expects the first token of its expression to already
318 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
319 * it will start by calling the scanner.
321 * If a forward reference happens during evaluation, the evaluator
322 * must set `*fwref' to true if `fwref' is non-NULL.
324 * `critical' is non-zero if the expression may not contain forward
325 * references. The evaluator will report its own error if this
326 * occurs; if `critical' is 1, the error will be "symbol not
327 * defined before use", whereas if `critical' is 2, the error will
328 * be "symbol undefined".
330 * If `critical' has bit 8 set (in addition to its main value: 0x101
331 * and 0x102 correspond to 1 and 2) then an extended expression
332 * syntax is recognised, in which relational operators such as =, <
333 * and >= are accepted, as well as low-precedence logical operators
336 * If `hints' is non-NULL, it gets filled in with some hints as to
337 * the base register in complex effective addresses.
339 #define CRITICAL 0x100
340 typedef expr
*(*evalfunc
)(scanner sc
, void *scprivate
,
341 struct tokenval
*tv
, int *fwref
, int critical
,
342 efunc error
, struct eval_hints
*hints
);
345 * Special values for expr->type.
346 * These come after EXPR_REG_END as defined in regs.h.
348 #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */
349 #define EXPR_SIMPLE (EXPR_REG_END+2)
350 #define EXPR_WRT (EXPR_REG_END+3)
351 #define EXPR_SEGBASE (EXPR_REG_END+4)
354 * Linked list of strings
356 typedef struct string_list
{
357 struct string_list
*next
;
362 * preprocessors ought to look like this:
366 * Called at the start of a pass; given a file name, the number
367 * of the pass, an error reporting function, an evaluator
368 * function, and a listing generator to talk to.
370 void (*reset
)(char *file
, int pass
, ListGen
*listgen
, StrList
**deplist
);
373 * Called to fetch a line of preprocessed source. The line
374 * returned has been malloc'ed, and so should be freed after
377 char *(*getline
)(void);
379 /* Called at the end of a pass */
380 void (*cleanup
)(int pass
);
382 /* Additional macros specific to output format */
383 void (*extra_stdmac
)(macros_t
*macros
);
385 /* Early definitions and undefinitions for macros */
386 void (*pre_define
)(char *definition
);
387 void (*pre_undefine
)(char *definition
);
389 /* Include file from command line */
390 void (*pre_include
)(char *fname
);
392 /* Include path from command line */
393 void (*include_path
)(char *path
);
396 extern struct preproc_ops nasmpp
;
399 * Some lexical properties of the NASM source language, included
400 * here because they are shared between the parser and preprocessor.
404 * isidstart matches any character that may start an identifier, and isidchar
405 * matches any character that may appear at places other than the start of an
406 * identifier. E.g. a period may only appear at the start of an identifier
407 * (for local labels), whereas a number may appear anywhere *but* at the
411 #define isidstart(c) (nasm_isalpha(c) || \
417 #define isidchar(c) (isidstart(c) || \
423 /* Ditto for numeric constants. */
425 #define isnumstart(c) (nasm_isdigit(c) || (c) == '$')
426 #define isnumchar(c) (nasm_isalnum(c) || (c) == '_')
429 * Data-type flags that get passed to listing-file routines.
441 * -----------------------------------------------------------
442 * Format of the `insn' structure returned from `parser.c' and
443 * passed into `assemble.c'
444 * -----------------------------------------------------------
447 /* Verify value to be a valid register */
448 static inline bool is_register(int reg
)
450 return reg
>= EXPR_REG_START
&& reg
< REG_ENUM_LIMIT
;
453 enum ccode
{ /* condition code names */
454 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
455 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
456 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
,
463 #define REX_REAL 0x4f /* Actual REX prefix bits */
464 #define REX_B 0x01 /* ModRM r/m extension */
465 #define REX_X 0x02 /* SIB index extension */
466 #define REX_R 0x04 /* ModRM reg extension */
467 #define REX_W 0x08 /* 64-bit operand size */
468 #define REX_L 0x20 /* Use LOCK prefix instead of REX.R */
469 #define REX_P 0x40 /* REX prefix present/required */
470 #define REX_H 0x80 /* High register present, REX forbidden */
471 #define REX_V 0x0100 /* Instruction uses VEX/XOP instead of REX */
472 #define REX_NH 0x0200 /* Instruction which doesn't use high regs */
475 * REX_V "classes" (prefixes which behave like VEX)
478 RV_VEX
= 0, /* C4/C5 */
483 * Note that because segment registers may be used as instruction
484 * prefixes, we must ensure the enumerations for prefixes and
485 * register names do not overlap.
487 enum prefixes
{ /* instruction prefixes */
489 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
490 P_A16
= PREFIX_ENUM_START
, P_A32
, P_A64
, P_ASP
,
491 P_LOCK
, P_O16
, P_O32
, P_O64
, P_OSP
,
492 P_REP
, P_REPE
, P_REPNE
, P_REPNZ
, P_REPZ
, P_TIMES
,
493 P_WAIT
, P_XACQUIRE
, P_XRELEASE
,
497 enum extop_type
{ /* extended operand types */
499 EOT_DB_STRING
, /* Byte string */
500 EOT_DB_STRING_FREE
, /* Byte string which should be nasm_free'd*/
501 EOT_DB_NUMBER
, /* Integer */
504 enum ea_flags
{ /* special EA flags */
505 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
506 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
507 EAF_TIMESTWO
= 4, /* really do EAX*2 not EAX+EAX */
508 EAF_REL
= 8, /* IP-relative addressing */
509 EAF_ABS
= 16, /* non-IP-relative addressing */
510 EAF_FSGS
= 32 /* fs/gs segment override present */
513 enum eval_hint
{ /* values for `hinttype' */
514 EAH_NOHINT
= 0, /* no hint at all - our discretion */
515 EAH_MAKEBASE
= 1, /* try to make given reg the base */
516 EAH_NOTBASE
= 2 /* try _not_ to make reg the base */
519 typedef struct operand
{ /* operand to an instruction */
520 opflags_t type
; /* type of operand */
521 int disp_size
; /* 0 means default; 16; 32; 64 */
522 enum reg_enum basereg
;
523 enum reg_enum indexreg
; /* address registers */
524 int scale
; /* index scale */
526 enum eval_hint hinttype
; /* hint as to real base register */
527 int32_t segment
; /* immediate segment, if needed */
528 int64_t offset
; /* any immediate number */
529 int32_t wrt
; /* segment base it's relative to */
530 int eaflags
; /* special EA flags */
531 int opflags
; /* see OPFLAG_* defines below */
534 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
535 #define OPFLAG_EXTERN 2 /* operand is an external reference */
536 #define OPFLAG_UNKNOWN 4 /* operand is an unknown reference
537 * (always a forward reference also)
540 typedef struct extop
{ /* extended operand */
541 struct extop
*next
; /* linked list */
542 char *stringval
; /* if it's a string, then here it is */
543 size_t stringlen
; /* ... and here's how long it is */
544 int64_t offset
; /* ... it's given here ... */
545 int32_t segment
; /* if it's a number/address, then... */
546 int32_t wrt
; /* ... and here */
547 enum extop_type type
; /* defined above */
551 EA_INVALID
, /* Not a valid EA at all */
552 EA_SCALAR
, /* Scalar EA */
553 EA_XMMVSIB
, /* XMM vector EA */
554 EA_YMMVSIB
, /* XMM vector EA */
558 * Prefix positions: each type of prefix goes in a specific slot.
559 * This affects the final ordering of the assembled output, which
560 * shouldn't matter to the processor, but if you have stylistic
561 * preferences, you can change this. REX prefixes are handled
562 * differently for the time being.
564 * LOCK and REP used to be one slot; this is no longer the case since
565 * the introduction of HLE.
568 PPS_WAIT
, /* WAIT (technically not a prefix!) */
569 PPS_REP
, /* REP/HLE prefix */
570 PPS_LOCK
, /* LOCK prefix */
571 PPS_SEG
, /* Segment override prefix */
572 PPS_OSIZE
, /* Operand size prefix */
573 PPS_ASIZE
, /* Address size prefix */
574 MAXPREFIX
/* Total number of prefix slots */
577 /* If you need to change this, also change it in insns.pl */
578 #define MAX_OPERANDS 5
580 typedef struct insn
{ /* an instruction itself */
581 char *label
; /* the label defined, or NULL */
582 int prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
583 enum opcode opcode
; /* the opcode - not just the string */
584 enum ccode condition
; /* the condition code, if Jcc/SETcc */
585 int operands
; /* how many operands? 0-3 (more if db et al) */
586 int addr_size
; /* address size */
587 operand oprs
[MAX_OPERANDS
]; /* the operands, defined as above */
588 extop
*eops
; /* extended operands */
589 int eops_float
; /* true if DD and floating */
590 int32_t times
; /* repeat count (TIMES prefix) */
591 bool forw_ref
; /* is there a forward reference? */
592 int rex
; /* Special REX Prefix */
593 int vexreg
; /* Register encoded in VEX prefix */
594 int vex_cm
; /* Class and M field for VEX prefix */
595 int vex_wlp
; /* W, P and L information for VEX prefix */
598 enum geninfo
{ GI_SWITCH
};
601 * The data structure defining an output format driver, and the
602 * interfaces to the functions therein.
606 * This is a short (one-liner) description of the type of
607 * output generated by the driver.
609 const char *fullname
;
612 * This is a single keyword used to select the driver.
614 const char *shortname
;
617 * Output format flags.
619 #define OFMT_TEXT 1 /* Text file format */
623 * this is a pointer to the first element of the debug information
625 struct dfmt
**debug_formats
;
628 * and a pointer to the element that is being used
629 * note: this is set to the default at compile time and changed if the
630 * -F option is selected. If developing a set of new debug formats for
631 * an output format, be sure to set this to whatever default you want
634 const struct dfmt
*current_dfmt
;
637 * This, if non-NULL, is a NULL-terminated list of `char *'s
638 * pointing to extra standard macros supplied by the object
639 * format (e.g. a sensible initial default value of __SECT__,
640 * and user-level equivalents for any format-specific
646 * This procedure is called at the start of an output session to set
647 * up internal parameters.
652 * This procedure is called to pass generic information to the
653 * object file. The first parameter gives the information type
654 * (currently only command line switches)
655 * and the second parameter gives the value. This function returns
656 * 1 if recognized, 0 if unrecognized
658 int (*setinfo
)(enum geninfo type
, char **string
);
661 * This procedure is called by assemble() to write actual
662 * generated code or data to the object file. Typically it
663 * doesn't have to actually _write_ it, just store it for
666 * The `type' argument specifies the type of output data, and
667 * usually the size as well: its contents are described below.
669 void (*output
)(int32_t segto
, const void *data
,
670 enum out_type type
, uint64_t size
,
671 int32_t segment
, int32_t wrt
);
674 * This procedure is called once for every symbol defined in
675 * the module being assembled. It gives the name and value of
676 * the symbol, in NASM's terms, and indicates whether it has
677 * been declared to be global. Note that the parameter "name",
678 * when passed, will point to a piece of static storage
679 * allocated inside the label manager - it's safe to keep using
680 * that pointer, because the label manager doesn't clean up
681 * until after the output driver has.
683 * Values of `is_global' are: 0 means the symbol is local; 1
684 * means the symbol is global; 2 means the symbol is common (in
685 * which case `offset' holds the _size_ of the variable).
686 * Anything else is available for the output driver to use
689 * This routine explicitly _is_ allowed to call the label
690 * manager to define further symbols, if it wants to, even
691 * though it's been called _from_ the label manager. That much
692 * re-entrancy is guaranteed in the label manager. However, the
693 * label manager will in turn call this routine, so it should
694 * be prepared to be re-entrant itself.
696 * The `special' parameter contains special information passed
697 * through from the command that defined the label: it may have
698 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
699 * be obvious to the output format from the other parameters.
701 void (*symdef
)(char *name
, int32_t segment
, int64_t offset
,
702 int is_global
, char *special
);
705 * This procedure is called when the source code requests a
706 * segment change. It should return the corresponding segment
707 * _number_ for the name, or NO_SEG if the name is not a valid
710 * It may also be called with NULL, in which case it is to
711 * return the _default_ section number for starting assembly in.
713 * It is allowed to modify the string it is given a pointer to.
715 * It is also allowed to specify a default instruction size for
716 * the segment, by setting `*bits' to 16 or 32. Or, if it
717 * doesn't wish to define a default, it can leave `bits' alone.
719 int32_t (*section
)(char *name
, int pass
, int *bits
);
722 * This procedure is called to modify section alignment,
723 * note there is a trick, the alignment can only increase
725 void (*sectalign
)(int32_t seg
, unsigned int value
);
728 * This procedure is called to modify the segment base values
729 * returned from the SEG operator. It is given a segment base
730 * value (i.e. a segment value with the low bit set), and is
731 * required to produce in return a segment value which may be
732 * different. It can map segment bases to absolute numbers by
733 * means of returning SEG_ABS types.
735 * It should return NO_SEG if the segment base cannot be
736 * determined; the evaluator (which calls this routine) is
737 * responsible for throwing an error condition if that occurs
738 * in pass two or in a critical expression.
740 int32_t (*segbase
)(int32_t segment
);
743 * This procedure is called to allow the output driver to
744 * process its own specific directives. When called, it has the
745 * directive word in `directive' and the parameter string in
746 * `value'. It is called in both assembly passes, and `pass'
747 * will be either 1 or 2.
749 * This procedure should return zero if it does not _recognise_
750 * the directive, so that the main program can report an error.
751 * If it recognises the directive but then has its own errors,
752 * it should report them itself and then return non-zero. It
753 * should also return non-zero if it correctly processes the
756 int (*directive
)(enum directives directive
, char *value
, int pass
);
759 * This procedure is called before anything else - even before
760 * the "init" routine - and is passed the name of the input
761 * file from which this output file is being generated. It
762 * should return its preferred name for the output file in
763 * `outname', if outname[0] is not '\0', and do nothing to
764 * `outname' otherwise. Since it is called before the driver is
765 * properly initialized, it has to be passed its error handler
768 * This procedure may also take its own copy of the input file
769 * name for use in writing the output file: it is _guaranteed_
770 * that it will be called before the "init" routine.
772 * The parameter `outname' points to an area of storage
773 * guaranteed to be at least FILENAME_MAX in size.
775 void (*filename
)(char *inname
, char *outname
);
778 * This procedure is called after assembly finishes, to allow
779 * the output driver to clean itself up and free its memory.
780 * Typically, it will also be the point at which the object
781 * file actually gets _written_.
783 * One thing the cleanup routine should always do is to close
784 * the output file pointer.
786 void (*cleanup
)(int debuginfo
);
790 * Output format driver alias
793 const char *shortname
;
794 const char *fullname
;
798 extern struct ofmt
*ofmt
;
802 * ------------------------------------------------------------
803 * The data structure defining a debug format driver, and the
804 * interfaces to the functions therein.
805 * ------------------------------------------------------------
810 * This is a short (one-liner) description of the type of
811 * output generated by the driver.
813 const char *fullname
;
816 * This is a single keyword used to select the driver.
818 const char *shortname
;
821 * init - called initially to set up local pointer to object format.
826 * linenum - called any time there is output with a change of
827 * line number or file.
829 void (*linenum
)(const char *filename
, int32_t linenumber
, int32_t segto
);
832 * debug_deflabel - called whenever a label is defined. Parameters
833 * are the same as to 'symdef()' in the output format. This function
834 * would be called before the output format version.
837 void (*debug_deflabel
)(char *name
, int32_t segment
, int64_t offset
,
838 int is_global
, char *special
);
840 * debug_directive - called whenever a DEBUG directive other than 'LINE'
841 * is encountered. 'directive' contains the first parameter to the
842 * DEBUG directive, and params contains the rest. For example,
843 * 'DEBUG VAR _somevar:int' would translate to a call to this
844 * function with 'directive' equal to "VAR" and 'params' equal to
847 void (*debug_directive
)(const char *directive
, const char *params
);
850 * typevalue - called whenever the assembler wishes to register a type
851 * for the last defined label. This routine MUST detect if a type was
852 * already registered and not re-register it.
854 void (*debug_typevalue
)(int32_t type
);
857 * debug_output - called whenever output is required
858 * 'type' is the type of info required, and this is format-specific
860 void (*debug_output
)(int type
, void *param
);
863 * cleanup - called after processing of file is complete
865 void (*cleanup
)(void);
868 extern const struct dfmt
*dfmt
;
871 * The type definition macros
874 * low 3 bits: reserved
876 * next 24 bits: number of elements for arrays (0 for labels)
879 #define TY_UNKNOWN 0x00
880 #define TY_LABEL 0x08
883 #define TY_DWORD 0x20
884 #define TY_FLOAT 0x28
885 #define TY_QWORD 0x30
886 #define TY_TBYTE 0x38
887 #define TY_OWORD 0x40
888 #define TY_YWORD 0x48
889 #define TY_COMMON 0xE0
891 #define TY_EXTERN 0xF0
894 #define TYM_TYPE(x) ((x) & 0xF8)
895 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
897 #define TYS_ELEMENTS(x) ((x) << 8)
899 enum special_tokens
{
900 SPECIAL_ENUM_START
= PREFIX_ENUM_LIMIT
,
901 S_ABS
= SPECIAL_ENUM_START
,
925 * This declaration passes the "pass" number to all other modules
926 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
927 * where 0 = optimizing pass
933 extern int passn
; /* Actual pass number */
935 extern bool tasm_compatible_mode
;
936 extern int optimizing
;
937 extern int globalbits
; /* 16, 32 or 64-bit mode */
938 extern int globalrel
; /* default to relative addressing? */
939 extern int maxbits
; /* max bits supported by output */
942 * NASM version strings, defined in ver.c
944 extern const char nasm_version
[];
945 extern const char nasm_date
[];
946 extern const char nasm_compile_options
[];
947 extern const char nasm_comment
[];
948 extern const char nasm_signature
[];