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*__ */
228 TOKEN_IFUNC
, /* __ilog2*__ */
242 /* Must match the list in string_transform(), in strfunc.c */
259 size_t string_transform(char *, size_t, char **, enum strfunc
);
262 * The expression evaluator must be passed a scanner function; a
263 * standard scanner is provided as part of nasmlib.c. The
264 * preprocessor will use a different one. Scanners, and the
265 * token-value structures they return, look like this.
267 * The return value from the scanner is always a copy of the
268 * `t_type' field in the structure.
274 enum token_type t_type
;
276 typedef int (*scanner
)(void *private_data
, struct tokenval
*tv
);
285 * Expression-evaluator datatype. Expressions, within the
286 * evaluator, are stored as an array of these beasts, terminated by
287 * a record with type==0. Mostly, it's a vector type: each type
288 * denotes some kind of a component, and the value denotes the
289 * multiple of that component present in the expression. The
290 * exception is the WRT type, whose `value' field denotes the
291 * segment to which the expression is relative. These segments will
292 * be segment-base types, i.e. either odd segment values or SEG_ABS
293 * types. So it is still valid to assume that anything with a
294 * `value' field of zero is insignificant.
297 int32_t type
; /* a register, or EXPR_xxx */
298 int64_t value
; /* must be >= 32 bits */
302 * Library routines to manipulate expression data types.
304 int is_reloc(expr
*vect
);
305 int is_simple(expr
*vect
);
306 int is_really_simple(expr
*vect
);
307 int is_unknown(expr
*vect
);
308 int is_just_unknown(expr
*vect
);
309 int64_t reloc_value(expr
*vect
);
310 int32_t reloc_seg(expr
*vect
);
311 int32_t reloc_wrt(expr
*vect
);
314 * The evaluator can also return hints about which of two registers
315 * used in an expression should be the base register. See also the
316 * `operand' structure.
324 * The actual expression evaluator function looks like this. When
325 * called, it expects the first token of its expression to already
326 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
327 * it will start by calling the scanner.
329 * If a forward reference happens during evaluation, the evaluator
330 * must set `*fwref' to true if `fwref' is non-NULL.
332 * `critical' is non-zero if the expression may not contain forward
333 * references. The evaluator will report its own error if this
334 * occurs; if `critical' is 1, the error will be "symbol not
335 * defined before use", whereas if `critical' is 2, the error will
336 * be "symbol undefined".
338 * If `critical' has bit 8 set (in addition to its main value: 0x101
339 * and 0x102 correspond to 1 and 2) then an extended expression
340 * syntax is recognised, in which relational operators such as =, <
341 * and >= are accepted, as well as low-precedence logical operators
344 * If `hints' is non-NULL, it gets filled in with some hints as to
345 * the base register in complex effective addresses.
347 #define CRITICAL 0x100
348 typedef expr
*(*evalfunc
)(scanner sc
, void *scprivate
,
349 struct tokenval
*tv
, int *fwref
, int critical
,
350 efunc error
, struct eval_hints
*hints
);
353 * Special values for expr->type.
354 * These come after EXPR_REG_END as defined in regs.h.
356 #define EXPR_UNKNOWN (EXPR_REG_END+1) /* forward references */
357 #define EXPR_SIMPLE (EXPR_REG_END+2)
358 #define EXPR_WRT (EXPR_REG_END+3)
359 #define EXPR_SEGBASE (EXPR_REG_END+4)
362 * Linked list of strings
364 typedef struct string_list
{
365 struct string_list
*next
;
370 * preprocessors ought to look like this:
374 * Called at the start of a pass; given a file name, the number
375 * of the pass, an error reporting function, an evaluator
376 * function, and a listing generator to talk to.
378 void (*reset
)(char *file
, int pass
, ListGen
*listgen
, StrList
**deplist
);
381 * Called to fetch a line of preprocessed source. The line
382 * returned has been malloc'ed, and so should be freed after
385 char *(*getline
)(void);
387 /* Called at the end of a pass */
388 void (*cleanup
)(int pass
);
390 /* Additional macros specific to output format */
391 void (*extra_stdmac
)(macros_t
*macros
);
393 /* Early definitions and undefinitions for macros */
394 void (*pre_define
)(char *definition
);
395 void (*pre_undefine
)(char *definition
);
397 /* Include file from command line */
398 void (*pre_include
)(char *fname
);
400 /* Include path from command line */
401 void (*include_path
)(char *path
);
404 extern struct preproc_ops nasmpp
;
405 extern struct preproc_ops preproc_nop
;
408 * Some lexical properties of the NASM source language, included
409 * here because they are shared between the parser and preprocessor.
413 * isidstart matches any character that may start an identifier, and isidchar
414 * matches any character that may appear at places other than the start of an
415 * identifier. E.g. a period may only appear at the start of an identifier
416 * (for local labels), whereas a number may appear anywhere *but* at the
420 #define isidstart(c) (nasm_isalpha(c) || \
426 #define isidchar(c) (isidstart(c) || \
432 /* Ditto for numeric constants. */
434 #define isnumstart(c) (nasm_isdigit(c) || (c) == '$')
435 #define isnumchar(c) (nasm_isalnum(c) || (c) == '_')
438 * Data-type flags that get passed to listing-file routines.
450 * -----------------------------------------------------------
451 * Format of the `insn' structure returned from `parser.c' and
452 * passed into `assemble.c'
453 * -----------------------------------------------------------
456 /* Verify value to be a valid register */
457 static inline bool is_register(int reg
)
459 return reg
>= EXPR_REG_START
&& reg
< REG_ENUM_LIMIT
;
462 enum ccode
{ /* condition code names */
463 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
464 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
465 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
,
472 #define REX_REAL 0x4f /* Actual REX prefix bits */
473 #define REX_B 0x01 /* ModRM r/m extension */
474 #define REX_X 0x02 /* SIB index extension */
475 #define REX_R 0x04 /* ModRM reg extension */
476 #define REX_W 0x08 /* 64-bit operand size */
477 #define REX_L 0x20 /* Use LOCK prefix instead of REX.R */
478 #define REX_P 0x40 /* REX prefix present/required */
479 #define REX_H 0x80 /* High register present, REX forbidden */
480 #define REX_V 0x0100 /* Instruction uses VEX/XOP instead of REX */
481 #define REX_NH 0x0200 /* Instruction which doesn't use high regs */
484 * REX_V "classes" (prefixes which behave like VEX)
487 RV_VEX
= 0, /* C4/C5 */
492 * Note that because segment registers may be used as instruction
493 * prefixes, we must ensure the enumerations for prefixes and
494 * register names do not overlap.
496 enum prefixes
{ /* instruction prefixes */
498 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
499 P_A16
= PREFIX_ENUM_START
,
520 enum extop_type
{ /* extended operand types */
522 EOT_DB_STRING
, /* Byte string */
523 EOT_DB_STRING_FREE
, /* Byte string which should be nasm_free'd*/
524 EOT_DB_NUMBER
, /* Integer */
527 enum ea_flags
{ /* special EA flags */
528 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
529 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
530 EAF_TIMESTWO
= 4, /* really do EAX*2 not EAX+EAX */
531 EAF_REL
= 8, /* IP-relative addressing */
532 EAF_ABS
= 16, /* non-IP-relative addressing */
533 EAF_FSGS
= 32 /* fs/gs segment override present */
536 enum eval_hint
{ /* values for `hinttype' */
537 EAH_NOHINT
= 0, /* no hint at all - our discretion */
538 EAH_MAKEBASE
= 1, /* try to make given reg the base */
539 EAH_NOTBASE
= 2 /* try _not_ to make reg the base */
542 typedef struct operand
{ /* operand to an instruction */
543 opflags_t type
; /* type of operand */
544 int disp_size
; /* 0 means default; 16; 32; 64 */
545 enum reg_enum basereg
;
546 enum reg_enum indexreg
; /* address registers */
547 int scale
; /* index scale */
549 enum eval_hint hinttype
; /* hint as to real base register */
550 int32_t segment
; /* immediate segment, if needed */
551 int64_t offset
; /* any immediate number */
552 int32_t wrt
; /* segment base it's relative to */
553 int eaflags
; /* special EA flags */
554 int opflags
; /* see OPFLAG_* defines below */
557 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
558 #define OPFLAG_EXTERN 2 /* operand is an external reference */
559 #define OPFLAG_UNKNOWN 4 /* operand is an unknown reference
560 * (always a forward reference also)
563 typedef struct extop
{ /* extended operand */
564 struct extop
*next
; /* linked list */
565 char *stringval
; /* if it's a string, then here it is */
566 size_t stringlen
; /* ... and here's how long it is */
567 int64_t offset
; /* ... it's given here ... */
568 int32_t segment
; /* if it's a number/address, then... */
569 int32_t wrt
; /* ... and here */
570 enum extop_type type
; /* defined above */
574 EA_INVALID
, /* Not a valid EA at all */
575 EA_SCALAR
, /* Scalar EA */
576 EA_XMMVSIB
, /* XMM vector EA */
577 EA_YMMVSIB
, /* XMM vector EA */
581 * Prefix positions: each type of prefix goes in a specific slot.
582 * This affects the final ordering of the assembled output, which
583 * shouldn't matter to the processor, but if you have stylistic
584 * preferences, you can change this. REX prefixes are handled
585 * differently for the time being.
587 * LOCK and REP used to be one slot; this is no longer the case since
588 * the introduction of HLE.
591 PPS_WAIT
, /* WAIT (technically not a prefix!) */
592 PPS_REP
, /* REP/HLE prefix */
593 PPS_LOCK
, /* LOCK prefix */
594 PPS_SEG
, /* Segment override prefix */
595 PPS_OSIZE
, /* Operand size prefix */
596 PPS_ASIZE
, /* Address size prefix */
597 MAXPREFIX
/* Total number of prefix slots */
600 /* If you need to change this, also change it in insns.pl */
601 #define MAX_OPERANDS 5
603 typedef struct insn
{ /* an instruction itself */
604 char *label
; /* the label defined, or NULL */
605 int prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
606 enum opcode opcode
; /* the opcode - not just the string */
607 enum ccode condition
; /* the condition code, if Jcc/SETcc */
608 int operands
; /* how many operands? 0-3 (more if db et al) */
609 int addr_size
; /* address size */
610 operand oprs
[MAX_OPERANDS
]; /* the operands, defined as above */
611 extop
*eops
; /* extended operands */
612 int eops_float
; /* true if DD and floating */
613 int32_t times
; /* repeat count (TIMES prefix) */
614 bool forw_ref
; /* is there a forward reference? */
615 int rex
; /* Special REX Prefix */
616 int vexreg
; /* Register encoded in VEX prefix */
617 int vex_cm
; /* Class and M field for VEX prefix */
618 int vex_wlp
; /* W, P and L information for VEX prefix */
621 enum geninfo
{ GI_SWITCH
};
624 * The data structure defining an output format driver, and the
625 * interfaces to the functions therein.
629 * This is a short (one-liner) description of the type of
630 * output generated by the driver.
632 const char *fullname
;
635 * This is a single keyword used to select the driver.
637 const char *shortname
;
640 * Output format flags.
642 #define OFMT_TEXT 1 /* Text file format */
646 * this is a pointer to the first element of the debug information
648 struct dfmt
**debug_formats
;
651 * and a pointer to the element that is being used
652 * note: this is set to the default at compile time and changed if the
653 * -F option is selected. If developing a set of new debug formats for
654 * an output format, be sure to set this to whatever default you want
657 const struct dfmt
*current_dfmt
;
660 * This, if non-NULL, is a NULL-terminated list of `char *'s
661 * pointing to extra standard macros supplied by the object
662 * format (e.g. a sensible initial default value of __SECT__,
663 * and user-level equivalents for any format-specific
669 * This procedure is called at the start of an output session to set
670 * up internal parameters.
675 * This procedure is called to pass generic information to the
676 * object file. The first parameter gives the information type
677 * (currently only command line switches)
678 * and the second parameter gives the value. This function returns
679 * 1 if recognized, 0 if unrecognized
681 int (*setinfo
)(enum geninfo type
, char **string
);
684 * This procedure is called by assemble() to write actual
685 * generated code or data to the object file. Typically it
686 * doesn't have to actually _write_ it, just store it for
689 * The `type' argument specifies the type of output data, and
690 * usually the size as well: its contents are described below.
692 void (*output
)(int32_t segto
, const void *data
,
693 enum out_type type
, uint64_t size
,
694 int32_t segment
, int32_t wrt
);
697 * This procedure is called once for every symbol defined in
698 * the module being assembled. It gives the name and value of
699 * the symbol, in NASM's terms, and indicates whether it has
700 * been declared to be global. Note that the parameter "name",
701 * when passed, will point to a piece of static storage
702 * allocated inside the label manager - it's safe to keep using
703 * that pointer, because the label manager doesn't clean up
704 * until after the output driver has.
706 * Values of `is_global' are: 0 means the symbol is local; 1
707 * means the symbol is global; 2 means the symbol is common (in
708 * which case `offset' holds the _size_ of the variable).
709 * Anything else is available for the output driver to use
712 * This routine explicitly _is_ allowed to call the label
713 * manager to define further symbols, if it wants to, even
714 * though it's been called _from_ the label manager. That much
715 * re-entrancy is guaranteed in the label manager. However, the
716 * label manager will in turn call this routine, so it should
717 * be prepared to be re-entrant itself.
719 * The `special' parameter contains special information passed
720 * through from the command that defined the label: it may have
721 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
722 * be obvious to the output format from the other parameters.
724 void (*symdef
)(char *name
, int32_t segment
, int64_t offset
,
725 int is_global
, char *special
);
728 * This procedure is called when the source code requests a
729 * segment change. It should return the corresponding segment
730 * _number_ for the name, or NO_SEG if the name is not a valid
733 * It may also be called with NULL, in which case it is to
734 * return the _default_ section number for starting assembly in.
736 * It is allowed to modify the string it is given a pointer to.
738 * It is also allowed to specify a default instruction size for
739 * the segment, by setting `*bits' to 16 or 32. Or, if it
740 * doesn't wish to define a default, it can leave `bits' alone.
742 int32_t (*section
)(char *name
, int pass
, int *bits
);
745 * This procedure is called to modify section alignment,
746 * note there is a trick, the alignment can only increase
748 void (*sectalign
)(int32_t seg
, unsigned int value
);
751 * This procedure is called to modify the segment base values
752 * returned from the SEG operator. It is given a segment base
753 * value (i.e. a segment value with the low bit set), and is
754 * required to produce in return a segment value which may be
755 * different. It can map segment bases to absolute numbers by
756 * means of returning SEG_ABS types.
758 * It should return NO_SEG if the segment base cannot be
759 * determined; the evaluator (which calls this routine) is
760 * responsible for throwing an error condition if that occurs
761 * in pass two or in a critical expression.
763 int32_t (*segbase
)(int32_t segment
);
766 * This procedure is called to allow the output driver to
767 * process its own specific directives. When called, it has the
768 * directive word in `directive' and the parameter string in
769 * `value'. It is called in both assembly passes, and `pass'
770 * will be either 1 or 2.
772 * This procedure should return zero if it does not _recognise_
773 * the directive, so that the main program can report an error.
774 * If it recognises the directive but then has its own errors,
775 * it should report them itself and then return non-zero. It
776 * should also return non-zero if it correctly processes the
779 int (*directive
)(enum directives directive
, char *value
, int pass
);
782 * This procedure is called before anything else - even before
783 * the "init" routine - and is passed the name of the input
784 * file from which this output file is being generated. It
785 * should return its preferred name for the output file in
786 * `outname', if outname[0] is not '\0', and do nothing to
787 * `outname' otherwise. Since it is called before the driver is
788 * properly initialized, it has to be passed its error handler
791 * This procedure may also take its own copy of the input file
792 * name for use in writing the output file: it is _guaranteed_
793 * that it will be called before the "init" routine.
795 * The parameter `outname' points to an area of storage
796 * guaranteed to be at least FILENAME_MAX in size.
798 void (*filename
)(char *inname
, char *outname
);
801 * This procedure is called after assembly finishes, to allow
802 * the output driver to clean itself up and free its memory.
803 * Typically, it will also be the point at which the object
804 * file actually gets _written_.
806 * One thing the cleanup routine should always do is to close
807 * the output file pointer.
809 void (*cleanup
)(int debuginfo
);
813 * Output format driver alias
816 const char *shortname
;
817 const char *fullname
;
821 extern struct ofmt
*ofmt
;
825 * ------------------------------------------------------------
826 * The data structure defining a debug format driver, and the
827 * interfaces to the functions therein.
828 * ------------------------------------------------------------
833 * This is a short (one-liner) description of the type of
834 * output generated by the driver.
836 const char *fullname
;
839 * This is a single keyword used to select the driver.
841 const char *shortname
;
844 * init - called initially to set up local pointer to object format.
849 * linenum - called any time there is output with a change of
850 * line number or file.
852 void (*linenum
)(const char *filename
, int32_t linenumber
, int32_t segto
);
855 * debug_deflabel - called whenever a label is defined. Parameters
856 * are the same as to 'symdef()' in the output format. This function
857 * would be called before the output format version.
860 void (*debug_deflabel
)(char *name
, int32_t segment
, int64_t offset
,
861 int is_global
, char *special
);
863 * debug_directive - called whenever a DEBUG directive other than 'LINE'
864 * is encountered. 'directive' contains the first parameter to the
865 * DEBUG directive, and params contains the rest. For example,
866 * 'DEBUG VAR _somevar:int' would translate to a call to this
867 * function with 'directive' equal to "VAR" and 'params' equal to
870 void (*debug_directive
)(const char *directive
, const char *params
);
873 * typevalue - called whenever the assembler wishes to register a type
874 * for the last defined label. This routine MUST detect if a type was
875 * already registered and not re-register it.
877 void (*debug_typevalue
)(int32_t type
);
880 * debug_output - called whenever output is required
881 * 'type' is the type of info required, and this is format-specific
883 void (*debug_output
)(int type
, void *param
);
886 * cleanup - called after processing of file is complete
888 void (*cleanup
)(void);
891 extern const struct dfmt
*dfmt
;
894 * The type definition macros
897 * low 3 bits: reserved
899 * next 24 bits: number of elements for arrays (0 for labels)
902 #define TY_UNKNOWN 0x00
903 #define TY_LABEL 0x08
906 #define TY_DWORD 0x20
907 #define TY_FLOAT 0x28
908 #define TY_QWORD 0x30
909 #define TY_TBYTE 0x38
910 #define TY_OWORD 0x40
911 #define TY_YWORD 0x48
912 #define TY_COMMON 0xE0
914 #define TY_EXTERN 0xF0
917 #define TYM_TYPE(x) ((x) & 0xF8)
918 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
920 #define TYS_ELEMENTS(x) ((x) << 8)
922 enum special_tokens
{
923 SPECIAL_ENUM_START
= PREFIX_ENUM_LIMIT
,
924 S_ABS
= SPECIAL_ENUM_START
,
948 * This declaration passes the "pass" number to all other modules
949 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
950 * where 0 = optimizing pass
956 extern int passn
; /* Actual pass number */
958 extern bool tasm_compatible_mode
;
959 extern int optimizing
;
960 extern int globalbits
; /* 16, 32 or 64-bit mode */
961 extern int globalrel
; /* default to relative addressing? */
962 extern int maxbits
; /* max bits supported by output */
965 * NASM version strings, defined in ver.c
967 extern const char nasm_version
[];
968 extern const char nasm_date
[];
969 extern const char nasm_compile_options
[];
970 extern const char nasm_comment
[];
971 extern const char nasm_signature
[];