1 /* nasm.h main header file for the Netwide Assembler: inter-module interface
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the licence given in the file "Licence"
6 * distributed in the NASM archive.
8 * initial version: 27/iii/95 by Simon Tatham
16 #include "version.h" /* generated NASM version macros */
27 #define FALSE 0 /* comes in handy */
33 #define NO_SEG -1L /* null segment value */
34 #define SEG_ABS 0x40000000L /* mask for far-absolute segments */
37 #define FILENAME_MAX 256
45 #define POSTFIX_MAX 10
48 #define IDLEN_MAX 4096
51 * Name pollution problems: <time.h> on Digital UNIX pulls in some
52 * strange hardware header file which sees fit to define R_SP. We
53 * undefine it here so as not to break the enum below.
60 * We must declare the existence of this structure type up here,
61 * since we have to reference it before we define it...
66 * -------------------------
67 * Error reporting functions
68 * -------------------------
72 * An error reporting function should look like this.
74 typedef void (*efunc
) (int severity
, const char *fmt
, ...);
77 * These are the error severity codes which get passed as the first
78 * argument to an efunc.
81 #define ERR_DEBUG 0x00000008 /* put out debugging message */
82 #define ERR_WARNING 0x00000000 /* warn only: no further action */
83 #define ERR_NONFATAL 0x00000001 /* terminate assembly after phase */
84 #define ERR_FATAL 0x00000002 /* instantly fatal: exit with error */
85 #define ERR_PANIC 0x00000003 /* internal error: panic instantly
86 * and dump core for reference */
87 #define ERR_MASK 0x0000000F /* mask off the above codes */
88 #define ERR_NOFILE 0x00000010 /* don't give source file name/line */
89 #define ERR_USAGE 0x00000020 /* print a usage message */
90 #define ERR_PASS1 0x00000040 /* only print this error on pass one */
93 * These codes define specific types of suppressible warning.
96 #define ERR_WARN_MASK 0x0000FF00 /* the mask for this feature */
97 #define ERR_WARN_SHR 8 /* how far to shift right */
99 #define ERR_WARN_MNP 0x00000100 /* macro-num-parameters warning */
100 #define ERR_WARN_MSR 0x00000200 /* macro self-reference */
101 #define ERR_WARN_OL 0x00000300 /* orphan label (no colon, and
103 #define ERR_WARN_NOV 0x00000400 /* numeric overflow */
104 #define ERR_WARN_GNUELF 0x00000500 /* using GNU ELF extensions */
105 #define ERR_WARN_MAX 5 /* the highest numbered one */
108 * -----------------------
109 * Other function typedefs
110 * -----------------------
114 * A label-lookup function should look like this.
116 typedef int (*lfunc
) (char *label
, int32_t *segment
, int32_t *offset
);
119 * And a label-definition function like this. The boolean parameter
120 * `is_norm' states whether the label is a `normal' label (which
121 * should affect the local-label system), or something odder like
122 * an EQU or a segment-base symbol, which shouldn't.
124 typedef void (*ldfunc
) (char *label
, int32_t segment
, int32_t offset
,
125 char *special
, int is_norm
, int isextrn
,
126 struct ofmt
* ofmt
, efunc error
);
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 *, efunc
);
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, const void *, uint32_t);
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, char *);
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);
182 * Reverse the effects of uplevel.
184 void (*downlevel
) (int);
188 * The expression evaluator must be passed a scanner function; a
189 * standard scanner is provided as part of nasmlib.c. The
190 * preprocessor will use a different one. Scanners, and the
191 * token-value structures they return, look like this.
193 * The return value from the scanner is always a copy of the
194 * `t_type' field in the structure.
198 int64_t t_integer
, t_inttwo
;
201 typedef int (*scanner
) (void *private_data
, struct tokenval
* tv
);
204 * Token types returned by the scanner, in addition to ordinary
205 * ASCII character values, and zero for end-of-string.
207 enum { /* token types, other than chars */
208 TOKEN_INVALID
= -1, /* a placeholder value */
209 TOKEN_EOS
= 0, /* end of string */
210 TOKEN_EQ
= '=', TOKEN_GT
= '>', TOKEN_LT
= '<', /* aliases */
211 TOKEN_ID
= 256, TOKEN_NUM
, TOKEN_REG
, TOKEN_INSN
, /* major token types */
212 TOKEN_ERRNUM
, /* numeric constant with error in */
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_FLOAT
/* floating-point constant */
231 * Expression-evaluator datatype. Expressions, within the
232 * evaluator, are stored as an array of these beasts, terminated by
233 * a record with type==0. Mostly, it's a vector type: each type
234 * denotes some kind of a component, and the value denotes the
235 * multiple of that component present in the expression. The
236 * exception is the WRT type, whose `value' field denotes the
237 * segment to which the expression is relative. These segments will
238 * be segment-base types, i.e. either odd segment values or SEG_ABS
239 * types. So it is still valid to assume that anything with a
240 * `value' field of zero is insignificant.
243 int32_t type
; /* a register, or EXPR_xxx */
244 int64_t value
; /* must be >= 32 bits */
248 * The evaluator can also return hints about which of two registers
249 * used in an expression should be the base register. See also the
250 * `operand' structure.
258 * The actual expression evaluator function looks like this. When
259 * called, it expects the first token of its expression to already
260 * be in `*tv'; if it is not, set tv->t_type to TOKEN_INVALID and
261 * it will start by calling the scanner.
263 * If a forward reference happens during evaluation, the evaluator
264 * must set `*fwref' to TRUE if `fwref' is non-NULL.
266 * `critical' is non-zero if the expression may not contain forward
267 * references. The evaluator will report its own error if this
268 * occurs; if `critical' is 1, the error will be "symbol not
269 * defined before use", whereas if `critical' is 2, the error will
270 * be "symbol undefined".
272 * If `critical' has bit 8 set (in addition to its main value: 0x101
273 * and 0x102 correspond to 1 and 2) then an extended expression
274 * syntax is recognised, in which relational operators such as =, <
275 * and >= are accepted, as well as low-precedence logical operators
278 * If `hints' is non-NULL, it gets filled in with some hints as to
279 * the base register in complex effective addresses.
281 #define CRITICAL 0x100
282 typedef expr
*(*evalfunc
) (scanner sc
, void *scprivate
,
283 struct tokenval
* tv
, int *fwref
, int critical
,
284 efunc error
, struct eval_hints
* hints
);
287 * Special values for expr->type. ASSUMPTION MADE HERE: the number
288 * of distinct register names (i.e. possible "type" fields for an
289 * expr structure) does not exceed 124 (EXPR_REG_START through
292 #define EXPR_REG_START 1
293 #define EXPR_REG_END 124
294 #define EXPR_UNKNOWN 125L /* for forward references */
295 #define EXPR_SIMPLE 126L
296 #define EXPR_WRT 127L
297 #define EXPR_SEGBASE 128L
300 * Preprocessors ought to look like this:
304 * Called at the start of a pass; given a file name, the number
305 * of the pass, an error reporting function, an evaluator
306 * function, and a listing generator to talk to.
308 void (*reset
) (char *, int, efunc
, evalfunc
, ListGen
*);
311 * Called to fetch a line of preprocessed source. The line
312 * returned has been malloc'ed, and so should be freed after
315 char *(*getline
) (void);
318 * Called at the end of a pass.
320 void (*cleanup
) (int);
324 * ----------------------------------------------------------------
325 * Some lexical properties of the NASM source language, included
326 * here because they are shared between the parser and preprocessor
327 * ----------------------------------------------------------------
331 * isidstart matches any character that may start an identifier, and isidchar
332 * matches any character that may appear at places other than the start of an
333 * identifier. E.g. a period may only appear at the start of an identifier
334 * (for local labels), whereas a number may appear anywhere *but* at the
338 #define isidstart(c) ( isalpha(c) || (c)=='_' || (c)=='.' || (c)=='?' \
340 #define isidchar(c) ( isidstart(c) || isdigit(c) || (c)=='$' || (c)=='#' \
343 /* Ditto for numeric constants. */
345 #define isnumstart(c) ( isdigit(c) || (c)=='$' )
346 #define isnumchar(c) ( isalnum(c) )
348 /* This returns the numeric value of a given 'digit'. */
350 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
353 * Data-type flags that get passed to listing-file routines.
356 LIST_READ
, LIST_MACRO
, LIST_MACRO_NOLIST
, LIST_INCLUDE
,
357 LIST_INCBIN
, LIST_TIMES
361 * -----------------------------------------------------------
362 * Format of the `insn' structure returned from `parser.c' and
363 * passed into `assemble.c'
364 * -----------------------------------------------------------
368 * Here we define the operand types. These are implemented as bit
369 * masks, since some are subsets of others; e.g. AX in a MOV
370 * instruction is a special operand type, whereas AX in other
371 * contexts is just another 16-bit register. (Also, consider CL in
372 * shift instructions, DX in OUT, etc.)
375 /* size, and other attributes, of the operand */
376 #define BITS8 0x00000001L
377 #define BITS16 0x00000002L
378 #define BITS32 0x00000004L
379 #define BITS64 0x00000008L /* x64 and FPU only */
380 #define BITS80 0x00000010L /* FPU only */
381 #define FAR 0x00000020L /* grotty: this means 16:16 or */
382 /* 16:32, like in CALL/JMP */
383 #define NEAR 0x00000040L
384 #define SHORT 0x00000080L /* and this means what it says :) */
386 #define SIZE_MASK 0x000000FFL /* all the size attributes */
387 #define NON_SIZE (~SIZE_MASK)
389 #define TO 0x00000100L /* reverse effect in FADD, FSUB &c */
390 #define COLON 0x00000200L /* operand is followed by a colon */
391 #define STRICT 0x00000400L /* do not optimize this operand */
393 /* type of operand: memory reference, register, etc. */
394 #define MEMORY 0x00204000L
395 #define REGISTER 0x00001000L /* register number in 'basereg' */
396 #define IMMEDIATE 0x00002000L
398 #define REGMEM 0x00200000L /* for r/m, ie EA, operands */
399 #define REGNORM 0x00201000L /* 'normal' reg, qualifies as EA */
400 #define REG8 0x00201001L
401 #define REG16 0x00201002L
402 #define REG32 0x00201004L
403 #define REG64 0x00201008L /* x64 registers */
404 #define RIPREG 0x0020100CL /* RIP register */
405 #define MMXREG 0x00201010L /* MMX registers */
406 #define XMMREG 0x00201011L /* XMM Katmai reg */
407 #define FPUREG 0x01000000L /* floating point stack registers */
408 #define FPU0 0x01000800L /* FPU stack register zero */
410 /* special register operands: these may be treated differently */
411 #define REG_SMASK 0x00070000L /* a mask for the following */
412 #define REG_ACCUM 0x00211000L /* accumulator: AL, AX or EAX */
413 #define REG_AL 0x00211001L /* REG_ACCUM | BITSxx */
414 #define REG_AX 0x00211002L /* ditto */
415 #define REG_EAX 0x00211004L /* and again */
416 #define REG_RAX 0x00211008L /* and again */
417 #define REG_COUNT 0x00221000L /* counter: CL, CX, ECX or RCX */
418 #define REG_CL 0x00221001L /* REG_COUNT | BITSxx */
419 #define REG_CX 0x00221002L /* ditto */
420 #define REG_ECX 0x00221004L /* another one */
421 #define REG_RCX 0x00221008L /* another one */
422 #define REG_DL 0x00241001L
423 #define REG_DX 0x00241002L
424 #define REG_EDX 0x00241004L
425 #define REG_RDX 0x00241008L
426 #define REG_RIP 0x0027100CL /* RIP relative addressing */
427 #define REG_SREG 0x00081002L /* any segment register */
428 #define REG_CS 0x01081002L /* CS */
429 #define REG_DESS 0x02081002L /* DS, ES, SS (non-CS 86 registers) */
430 #define REG_FSGS 0x04081002L /* FS, GS (386 extended registers) */
431 #define REG_SEG67 0x08081002L /* Non-implemented segment registers */
432 #define REG_CDT 0x00101004L /* CRn, DRn and TRn */
433 #define REG_CREG 0x08101004L /* CRn */
434 #define REG_DREG 0x10101004L /* DRn */
435 #define REG_TREG 0x20101004L /* TRn */
436 #define REG_C8REG 0x40101004L /* CR8 */
438 /* special type of EA */
439 #define MEM_OFFS 0x00604000L /* simple [address] offset */
441 /* special type of immediate operand */
442 #define ONENESS 0x00800000L /* so UNITY == IMMEDIATE | ONENESS */
443 #define UNITY 0x00802000L /* for shift/rotate instructions */
444 #define BYTENESS 0x40000000L /* so SBYTE == IMMEDIATE | BYTENESS */
445 #define SBYTE 0x40002000L /* for op r16/32,immediate instrs. */
447 /* Register names automatically generated from regs.dat */
450 enum { /* condition code names */
451 C_A
, C_AE
, C_B
, C_BE
, C_C
, C_E
, C_G
, C_GE
, C_L
, C_LE
, C_NA
, C_NAE
,
452 C_NB
, C_NBE
, C_NC
, C_NE
, C_NG
, C_NGE
, C_NL
, C_NLE
, C_NO
, C_NP
,
453 C_NS
, C_NZ
, C_O
, C_P
, C_PE
, C_PO
, C_S
, C_Z
457 * Note that because segment registers may be used as instruction
458 * prefixes, we must ensure the enumerations for prefixes and
459 * register names do not overlap.
461 enum { /* instruction prefixes */
462 PREFIX_ENUM_START
= REG_ENUM_LIMIT
,
463 P_A16
= PREFIX_ENUM_START
, P_A32
, P_LOCK
, P_O16
, P_O32
,
464 P_REP
, P_REPE
, P_REPNE
, P_REPNZ
, P_REPZ
, P_TIMES
467 enum { /* extended operand types */
468 EOT_NOTHING
, EOT_DB_STRING
, EOT_DB_NUMBER
471 enum { /* special EA flags */
472 EAF_BYTEOFFS
= 1, /* force offset part to byte size */
473 EAF_WORDOFFS
= 2, /* force offset part to [d]word size */
474 EAF_TIMESTWO
= 4 /* really do EAX*2 not EAX+EAX */
477 enum { /* values for `hinttype' */
478 EAH_NOHINT
= 0, /* no hint at all - our discretion */
479 EAH_MAKEBASE
= 1, /* try to make given reg the base */
480 EAH_NOTBASE
= 2 /* try _not_ to make reg the base */
483 typedef struct { /* operand to an instruction */
484 int32_t type
; /* type of operand */
485 int addr_size
; /* 0 means default; 16; 32; 64 */
486 int basereg
, indexreg
, scale
; /* registers and scale involved */
487 int hintbase
, hinttype
; /* hint as to real base register */
488 int32_t segment
; /* immediate segment, if needed */
489 int64_t offset
; /* any immediate number */
490 int32_t wrt
; /* segment base it's relative to */
491 int eaflags
; /* special EA flags */
492 int opflags
; /* see OPFLAG_* defines below */
495 #define OPFLAG_FORWARD 1 /* operand is a forward reference */
496 #define OPFLAG_EXTERN 2 /* operand is an external reference */
498 typedef struct extop
{ /* extended operand */
499 struct extop
*next
; /* linked list */
500 int32_t type
; /* defined above */
501 char *stringval
; /* if it's a string, then here it is */
502 int stringlen
; /* ... and here's how long it is */
503 int32_t segment
; /* if it's a number/address, then... */
504 int64_t offset
; /* ... it's given here ... */
505 int32_t wrt
; /* ... and here */
510 typedef struct { /* an instruction itself */
511 char *label
; /* the label defined, or NULL */
512 int prefixes
[MAXPREFIX
]; /* instruction prefixes, if any */
513 int nprefix
; /* number of entries in above */
514 int opcode
; /* the opcode - not just the string */
515 int condition
; /* the condition code, if Jcc/SETcc */
516 int operands
; /* how many operands? 0-3
517 * (more if db et al) */
518 operand oprs
[3]; /* the operands, defined as above */
519 extop
*eops
; /* extended operands */
520 int eops_float
; /* true if DD and floating */
521 int32_t times
; /* repeat count (TIMES prefix) */
522 int forw_ref
; /* is there a forward reference? */
523 uint8_t rex
; /* Special REX Prefix */
526 enum geninfo
{ GI_SWITCH
};
528 * ------------------------------------------------------------
529 * The data structure defining an output format driver, and the
530 * interfaces to the functions therein.
531 * ------------------------------------------------------------
536 * This is a short (one-liner) description of the type of
537 * output generated by the driver.
539 const char *fullname
;
542 * This is a single keyword used to select the driver.
544 const char *shortname
;
548 * this is reserved for out module specific help.
549 * It is set to NULL in all the out modules and is not implemented
550 * in the main program
552 const char *helpstring
;
555 * this is a pointer to the first element of the debug information
557 struct dfmt
**debug_formats
;
560 * and a pointer to the element that is being used
561 * note: this is set to the default at compile time and changed if the
562 * -F option is selected. If developing a set of new debug formats for
563 * an output format, be sure to set this to whatever default you want
566 struct dfmt
*current_dfmt
;
569 * This, if non-NULL, is a NULL-terminated list of `char *'s
570 * pointing to extra standard macros supplied by the object
571 * format (e.g. a sensible initial default value of __SECT__,
572 * and user-level equivalents for any format-specific
578 * This procedure is called at the start of an output session.
579 * It tells the output format what file it will be writing to,
580 * what routine to report errors through, and how to interface
581 * to the label manager and expression evaluator if necessary.
582 * It also gives it a chance to do other initialisation.
584 void (*init
) (FILE * fp
, efunc error
, ldfunc ldef
, evalfunc eval
);
587 * This procedure is called to pass generic information to the
588 * object file. The first parameter gives the information type
589 * (currently only command line switches)
590 * and the second parameter gives the value. This function returns
591 * 1 if recognized, 0 if unrecognized
593 int (*setinfo
) (enum geninfo type
, char **string
);
596 * This procedure is called by assemble() to write actual
597 * generated code or data to the object file. Typically it
598 * doesn't have to actually _write_ it, just store it for
601 * The `type' argument specifies the type of output data, and
602 * usually the size as well: its contents are described below.
604 void (*output
) (int32_t segto
, const void *data
, uint32_t type
,
605 int32_t segment
, int32_t wrt
);
608 * This procedure is called once for every symbol defined in
609 * the module being assembled. It gives the name and value of
610 * the symbol, in NASM's terms, and indicates whether it has
611 * been declared to be global. Note that the parameter "name",
612 * when passed, will point to a piece of static storage
613 * allocated inside the label manager - it's safe to keep using
614 * that pointer, because the label manager doesn't clean up
615 * until after the output driver has.
617 * Values of `is_global' are: 0 means the symbol is local; 1
618 * means the symbol is global; 2 means the symbol is common (in
619 * which case `offset' holds the _size_ of the variable).
620 * Anything else is available for the output driver to use
623 * This routine explicitly _is_ allowed to call the label
624 * manager to define further symbols, if it wants to, even
625 * though it's been called _from_ the label manager. That much
626 * re-entrancy is guaranteed in the label manager. However, the
627 * label manager will in turn call this routine, so it should
628 * be prepared to be re-entrant itself.
630 * The `special' parameter contains special information passed
631 * through from the command that defined the label: it may have
632 * been an EXTERN, a COMMON or a GLOBAL. The distinction should
633 * be obvious to the output format from the other parameters.
635 void (*symdef
) (char *name
, int32_t segment
, int32_t offset
, int is_global
,
639 * This procedure is called when the source code requests a
640 * segment change. It should return the corresponding segment
641 * _number_ for the name, or NO_SEG if the name is not a valid
644 * It may also be called with NULL, in which case it is to
645 * return the _default_ section number for starting assembly in.
647 * It is allowed to modify the string it is given a pointer to.
649 * It is also allowed to specify a default instruction size for
650 * the segment, by setting `*bits' to 16 or 32. Or, if it
651 * doesn't wish to define a default, it can leave `bits' alone.
653 int32_t (*section
) (char *name
, int pass
, int *bits
);
656 * This procedure is called to modify the segment base values
657 * returned from the SEG operator. It is given a segment base
658 * value (i.e. a segment value with the low bit set), and is
659 * required to produce in return a segment value which may be
660 * different. It can map segment bases to absolute numbers by
661 * means of returning SEG_ABS types.
663 * It should return NO_SEG if the segment base cannot be
664 * determined; the evaluator (which calls this routine) is
665 * responsible for throwing an error condition if that occurs
666 * in pass two or in a critical expression.
668 int32_t (*segbase
) (int32_t segment
);
671 * This procedure is called to allow the output driver to
672 * process its own specific directives. When called, it has the
673 * directive word in `directive' and the parameter string in
674 * `value'. It is called in both assembly passes, and `pass'
675 * will be either 1 or 2.
677 * This procedure should return zero if it does not _recognise_
678 * the directive, so that the main program can report an error.
679 * If it recognises the directive but then has its own errors,
680 * it should report them itself and then return non-zero. It
681 * should also return non-zero if it correctly processes the
684 int (*directive
) (char *directive
, char *value
, int pass
);
687 * This procedure is called before anything else - even before
688 * the "init" routine - and is passed the name of the input
689 * file from which this output file is being generated. It
690 * should return its preferred name for the output file in
691 * `outname', if outname[0] is not '\0', and do nothing to
692 * `outname' otherwise. Since it is called before the driver is
693 * properly initialized, it has to be passed its error handler
696 * This procedure may also take its own copy of the input file
697 * name for use in writing the output file: it is _guaranteed_
698 * that it will be called before the "init" routine.
700 * The parameter `outname' points to an area of storage
701 * guaranteed to be at least FILENAME_MAX in size.
703 void (*filename
) (char *inname
, char *outname
, efunc error
);
706 * This procedure is called after assembly finishes, to allow
707 * the output driver to clean itself up and free its memory.
708 * Typically, it will also be the point at which the object
709 * file actually gets _written_.
711 * One thing the cleanup routine should always do is to close
712 * the output file pointer.
714 void (*cleanup
) (int debuginfo
);
718 * values for the `type' parameter to an output function. Each one
719 * must have the actual number of _bytes_ added to it.
721 * Exceptions are OUT_RELxADR, which denote an x-byte relocation
722 * which will be a relative jump. For this we need to know the
723 * distance in bytes from the start of the relocated record until
724 * the end of the containing instruction. _This_ is what is stored
725 * in the size part of the parameter, in this case.
727 * Also OUT_RESERVE denotes reservation of N bytes of BSS space,
728 * and the contents of the "data" parameter is irrelevant.
730 * The "data" parameter for the output function points to a "int32_t",
731 * containing the address in question, unless the type is
732 * OUT_RAWDATA, in which case it points to an "uint8_t"
735 #define OUT_RAWDATA 0x00000000UL
736 #define OUT_ADDRESS 0x10000000UL
737 #define OUT_REL2ADR 0x20000000UL
738 #define OUT_REL4ADR 0x30000000UL
739 #define OUT_RESERVE 0x40000000UL
740 #define OUT_TYPMASK 0xF0000000UL
741 #define OUT_SIZMASK 0x0FFFFFFFUL
744 * ------------------------------------------------------------
745 * The data structure defining a debug format driver, and the
746 * interfaces to the functions therein.
747 * ------------------------------------------------------------
753 * This is a short (one-liner) description of the type of
754 * output generated by the driver.
756 const char *fullname
;
759 * This is a single keyword used to select the driver.
761 const char *shortname
;
764 * init - called initially to set up local pointer to object format,
765 * void pointer to implementation defined data, file pointer (which
766 * probably won't be used, but who knows?), and error function.
768 void (*init
) (struct ofmt
* of
, void *id
, FILE * fp
, efunc error
);
771 * linenum - called any time there is output with a change of
772 * line number or file.
774 void (*linenum
) (const char *filename
, int32_t linenumber
, int32_t segto
);
777 * debug_deflabel - called whenever a label is defined. Parameters
778 * are the same as to 'symdef()' in the output format. This function
779 * would be called before the output format version.
782 void (*debug_deflabel
) (char *name
, int32_t segment
, int32_t offset
,
783 int is_global
, char *special
);
785 * debug_directive - called whenever a DEBUG directive other than 'LINE'
786 * is encountered. 'directive' contains the first parameter to the
787 * DEBUG directive, and params contains the rest. For example,
788 * 'DEBUG VAR _somevar:int' would translate to a call to this
789 * function with 'directive' equal to "VAR" and 'params' equal to
792 void (*debug_directive
) (const char *directive
, const char *params
);
795 * typevalue - called whenever the assembler wishes to register a type
796 * for the last defined label. This routine MUST detect if a type was
797 * already registered and not re-register it.
799 void (*debug_typevalue
) (int32_t type
);
802 * debug_output - called whenever output is required
803 * 'type' is the type of info required, and this is format-specific
805 void (*debug_output
) (int type
, void *param
);
808 * cleanup - called after processing of file is complete
810 void (*cleanup
) (void);
814 * The type definition macros
817 * low 3 bits: reserved
819 * next 24 bits: number of elements for arrays (0 for labels)
822 #define TY_UNKNOWN 0x00
823 #define TY_LABEL 0x08
826 #define TY_DWORD 0x20
827 #define TY_FLOAT 0x28
828 #define TY_QWORD 0x30
829 #define TY_TBYTE 0x38
830 #define TY_COMMON 0xE0
832 #define TY_EXTERN 0xF0
835 #define TYM_TYPE(x) ((x) & 0xF8)
836 #define TYM_ELEMENTS(x) (((x) & 0xFFFFFF00) >> 8)
838 #define TYS_ELEMENTS(x) ((x) << 8)
846 * This is a useful #define which I keep meaning to use more often:
847 * the number of elements of a statically defined array.
850 #define elements(x) ( sizeof(x) / sizeof(*(x)) )
852 extern int tasm_compatible_mode
;
855 * This declaration passes the "pass" number to all other modules
856 * "pass0" assumes the values: 0, 0, ..., 0, 1, 2
857 * where 0 = optimizing pass
862 extern int pass0
; /* this is globally known */
863 extern int optimizing
;
864 extern int globalbits
; /* this is globally known */
865 extern int maxbits
; /* this is globally known */