1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2016 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 * outobj.c output routines for the Netwide Assembler to produce
60 * outobj.c is divided into two sections. The first section is low level
61 * routines for creating obj records; It has nearly zero NASM specific
62 * code. The second section is high level routines for processing calls and
63 * data structures from the rest of NASM into obj format.
65 * It should be easy (though not zero work) to lift the first section out for
66 * use as an obj file writer for some other assembler or compiler.
70 * These routines are built around the ObjRecord data struture. An ObjRecord
71 * holds an object file record that may be under construction or complete.
73 * A major function of these routines is to support continuation of an obj
74 * record into the next record when the maximum record size is exceeded. The
75 * high level code does not need to worry about where the record breaks occur.
76 * It does need to do some minor extra steps to make the automatic continuation
77 * work. Those steps may be skipped for records where the high level knows no
78 * continuation could be required.
80 * 1) An ObjRecord is allocated and cleared by obj_new, or an existing ObjRecord
81 * is cleared by obj_clear.
83 * 2) The caller should fill in .type.
85 * 3) If the record is continuable and there is processing that must be done at
86 * the start of each record then the caller should fill in .ori with the
87 * address of the record initializer routine.
89 * 4) If the record is continuable and it should be saved (rather than emitted
90 * immediately) as each record is done, the caller should set .up to be a
91 * pointer to a location in which the caller keeps the master pointer to the
92 * ObjRecord. When the record is continued, the obj_bump routine will then
93 * allocate a new ObjRecord structure and update the master pointer.
95 * 5) If the .ori field was used then the caller should fill in the .parm with
96 * any data required by the initializer.
98 * 6) The caller uses the routines: obj_byte, obj_word, obj_rword, obj_dword,
99 * obj_x, obj_index, obj_value and obj_name to fill in the various kinds of
100 * data required for this record.
102 * 7) If the record is continuable, the caller should call obj_commit at each
103 * point where breaking the record is permitted.
105 * 8) To write out the record, the caller should call obj_emit2. If the
106 * caller has called obj_commit for all data written then he can get slightly
107 * faster code by calling obj_emit instead of obj_emit2.
109 * Most of these routines return an ObjRecord pointer. This will be the input
110 * pointer most of the time and will be the new location if the ObjRecord
111 * moved as a result of the call. The caller may ignore the return value in
112 * three cases: It is a "Never Reallocates" routine; or The caller knows
113 * continuation is not possible; or The caller uses the master pointer for the
117 #define RECORD_MAX (1024-3) /* maximal size of any record except type+reclen */
118 #define OBJ_PARMS 3 /* maximum .parm used by any .ori routine */
120 #define FIX_08_LOW 0x8000 /* location type for various fixup subrecords */
121 #define FIX_16_OFFSET 0x8400
122 #define FIX_16_SELECTOR 0x8800
123 #define FIX_32_POINTER 0x8C00
124 #define FIX_08_HIGH 0x9000
125 #define FIX_32_OFFSET 0xA400
126 #define FIX_48_POINTER 0xAC00
128 enum RecordID
{ /* record ID codes */
130 THEADR
= 0x80, /* module header */
131 COMENT
= 0x88, /* comment record */
133 LINNUM
= 0x94, /* line number record */
134 LNAMES
= 0x96, /* list of names */
136 SEGDEF
= 0x98, /* segment definition */
137 GRPDEF
= 0x9A, /* group definition */
138 EXTDEF
= 0x8C, /* external definition */
139 PUBDEF
= 0x90, /* public definition */
140 COMDEF
= 0xB0, /* common definition */
142 LEDATA
= 0xA0, /* logical enumerated data */
143 FIXUPP
= 0x9C, /* fixups (relocations) */
144 FIXU32
= 0x9D, /* 32-bit fixups (relocations) */
146 MODEND
= 0x8A, /* module end */
147 MODE32
= 0x8B /* module end for 32-bit objects */
150 enum ComentID
{ /* ID codes for comment records */
152 dEXTENDED
= 0xA1, /* tells that we are using translator-specific extensions */
153 dLINKPASS
= 0xA2, /* link pass 2 marker */
154 dTYPEDEF
= 0xE3, /* define a type */
155 dSYM
= 0xE6, /* symbol debug record */
156 dFILNAME
= 0xE8, /* file name record */
157 dCOMPDEF
= 0xEA /* compiler type info */
160 typedef struct ObjRecord ObjRecord
;
161 typedef void ORI(ObjRecord
* orp
);
164 ORI
*ori
; /* Initialization routine */
165 int used
; /* Current data size */
166 int committed
; /* Data size at last boundary */
167 int x_size
; /* (see obj_x) */
168 unsigned int type
; /* Record type */
169 ObjRecord
*child
; /* Associated record below this one */
170 ObjRecord
**up
; /* Master pointer to this ObjRecord */
171 ObjRecord
*back
; /* Previous part of this record */
172 uint32_t parm
[OBJ_PARMS
]; /* Parameters for ori routine */
173 uint8_t buf
[RECORD_MAX
+ 3];
176 static void obj_fwrite(ObjRecord
* orp
);
177 static void ori_ledata(ObjRecord
* orp
);
178 static void ori_pubdef(ObjRecord
* orp
);
179 static void ori_null(ObjRecord
* orp
);
180 static ObjRecord
*obj_commit(ObjRecord
* orp
);
182 static bool obj_uppercase
; /* Flag: all names in uppercase */
183 static bool obj_use32
; /* Flag: at least one segment is 32-bit */
186 * Clear an ObjRecord structure. (Never reallocates).
187 * To simplify reuse of ObjRecord's, .type, .ori and .parm are not cleared.
189 static ObjRecord
*obj_clear(ObjRecord
* orp
)
201 * Emit an ObjRecord structure. (Never reallocates).
202 * The record is written out preceeded (recursively) by its previous part (if
203 * any) and followed (recursively) by its child (if any).
204 * The previous part and the child are freed. The main ObjRecord is cleared,
207 static ObjRecord
*obj_emit(ObjRecord
* orp
)
211 nasm_free(orp
->back
);
218 obj_emit(orp
->child
);
219 nasm_free(orp
->child
);
222 return (obj_clear(orp
));
226 * Commit and Emit a record. (Never reallocates).
228 static ObjRecord
*obj_emit2(ObjRecord
* orp
)
231 return (obj_emit(orp
));
235 * Allocate and clear a new ObjRecord; Also sets .ori to ori_null
237 static ObjRecord
*obj_new(void)
241 orp
= obj_clear(nasm_malloc(sizeof(ObjRecord
)));
247 * Advance to the next record because the existing one is full or its x_size
249 * Any uncommited data is moved into the next record.
251 static ObjRecord
*obj_bump(ObjRecord
* orp
)
254 int used
= orp
->used
;
255 int committed
= orp
->committed
;
258 *orp
->up
= nxt
= obj_new();
260 nxt
->type
= orp
->type
;
263 memcpy(nxt
->parm
, orp
->parm
, sizeof(orp
->parm
));
271 nxt
->committed
= nxt
->used
;
272 memcpy(nxt
->buf
+ nxt
->committed
, orp
->buf
+ committed
, used
);
273 nxt
->used
= nxt
->committed
+ used
;
280 * Advance to the next record if necessary to allow the next field to fit.
282 static ObjRecord
*obj_check(ObjRecord
* orp
, int size
)
284 if (orp
->used
+ size
> RECORD_MAX
)
287 if (!orp
->committed
) {
290 orp
->committed
= orp
->used
;
297 * All data written so far is commited to the current record (won't be moved to
298 * the next record in case of continuation).
300 static ObjRecord
*obj_commit(ObjRecord
* orp
)
302 orp
->committed
= orp
->used
;
309 static ObjRecord
*obj_byte(ObjRecord
* orp
, uint8_t val
)
311 orp
= obj_check(orp
, 1);
312 orp
->buf
[orp
->used
] = val
;
320 static ObjRecord
*obj_word(ObjRecord
* orp
, unsigned int val
)
322 orp
= obj_check(orp
, 2);
323 orp
->buf
[orp
->used
] = val
;
324 orp
->buf
[orp
->used
+ 1] = val
>> 8;
330 * Write a reversed word
332 static ObjRecord
*obj_rword(ObjRecord
* orp
, unsigned int val
)
334 orp
= obj_check(orp
, 2);
335 orp
->buf
[orp
->used
] = val
>> 8;
336 orp
->buf
[orp
->used
+ 1] = val
;
344 static ObjRecord
*obj_dword(ObjRecord
* orp
, uint32_t val
)
346 orp
= obj_check(orp
, 4);
347 orp
->buf
[orp
->used
] = val
;
348 orp
->buf
[orp
->used
+ 1] = val
>> 8;
349 orp
->buf
[orp
->used
+ 2] = val
>> 16;
350 orp
->buf
[orp
->used
+ 3] = val
>> 24;
356 * All fields of "size x" in one obj record must be the same size (either 16
357 * bits or 32 bits). There is a one bit flag in each record which specifies
359 * This routine is used to force the current record to have the desired
360 * x_size. x_size is normally automatic (using obj_x), so that this
361 * routine should be used outside obj_x, only to provide compatibility with
362 * linkers that have bugs in their processing of the size bit.
365 static ObjRecord
*obj_force(ObjRecord
* orp
, int x
)
367 if (orp
->x_size
== (x
^ 48))
374 * This routine writes a field of size x. The caller does not need to worry at
375 * all about whether 16-bits or 32-bits are required.
377 static ObjRecord
*obj_x(ObjRecord
* orp
, uint32_t val
)
382 orp
= obj_force(orp
, 32);
383 if (orp
->x_size
== 32) {
384 ObjRecord
*nxt
= obj_dword(orp
, val
);
385 nxt
->x_size
= 32; /* x_size is cleared when a record overflows */
389 return (obj_word(orp
, val
));
395 static ObjRecord
*obj_index(ObjRecord
* orp
, unsigned int val
)
398 return (obj_byte(orp
, val
));
399 return (obj_word(orp
, (val
>> 8) | (val
<< 8) | 0x80));
403 * Writes a variable length value
405 static ObjRecord
*obj_value(ObjRecord
* orp
, uint32_t val
)
408 return (obj_byte(orp
, val
));
410 orp
= obj_byte(orp
, 129);
411 return (obj_word(orp
, val
));
414 return (obj_dword(orp
, (val
<< 8) + 132));
415 orp
= obj_byte(orp
, 136);
416 return (obj_dword(orp
, val
));
420 * Writes a counted string
422 static ObjRecord
*obj_name(ObjRecord
* orp
, const char *name
)
424 int len
= strlen(name
);
427 orp
= obj_check(orp
, len
+ 1);
428 ptr
= orp
->buf
+ orp
->used
;
430 orp
->used
+= len
+ 1;
433 *ptr
++ = toupper(*name
);
436 memcpy(ptr
, name
, len
);
441 * Initializer for an LEDATA record.
443 * parm[1] = segment index
444 * During the use of a LEDATA ObjRecord, parm[0] is constantly updated to
445 * represent the offset that would be required if the record were split at the
447 * parm[2] is a copy of parm[0] as it was when the current record was initted.
449 static void ori_ledata(ObjRecord
* orp
)
451 obj_index(orp
, orp
->parm
[1]);
452 orp
->parm
[2] = orp
->parm
[0];
453 obj_x(orp
, orp
->parm
[0]);
457 * Initializer for a PUBDEF record.
458 * parm[0] = group index
459 * parm[1] = segment index
460 * parm[2] = frame (only used when both indexes are zero)
462 static void ori_pubdef(ObjRecord
* orp
)
464 obj_index(orp
, orp
->parm
[0]);
465 obj_index(orp
, orp
->parm
[1]);
466 if (!(orp
->parm
[0] | orp
->parm
[1]))
467 obj_word(orp
, orp
->parm
[2]);
471 * Initializer for a LINNUM record.
472 * parm[0] = group index
473 * parm[1] = segment index
475 static void ori_linnum(ObjRecord
* orp
)
477 obj_index(orp
, orp
->parm
[0]);
478 obj_index(orp
, orp
->parm
[1]);
482 * Initializer for a local vars record.
484 static void ori_local(ObjRecord
* orp
)
491 * Null initializer for records that continue without any header info
493 static void ori_null(ObjRecord
* orp
)
495 (void)orp
; /* Do nothing */
499 * This concludes the low level section of outobj.c
502 static char obj_infile
[FILENAME_MAX
];
504 static int32_t first_seg
;
505 static bool any_segs
;
509 #define GROUP_MAX 256 /* we won't _realistically_ have more
510 * than this many segs in a group */
511 #define EXT_BLKSIZ 256 /* block size for externals list */
513 struct Segment
; /* need to know these structs exist */
517 struct LineNumber
*next
;
518 struct Segment
*segment
;
523 static struct FileName
{
524 struct FileName
*next
;
526 struct LineNumber
*lnhead
, **lntail
;
530 static struct Array
{
534 } *arrhead
, **arrtail
;
536 #define ARRAYBOT 31 /* magic number for first array index */
538 static struct Public
{
542 int32_t segment
; /* only if it's far-absolute */
543 int type
; /* only for local debug syms */
544 } *fpubhead
, **fpubtail
, *last_defined
;
546 static struct External
{
547 struct External
*next
;
550 int32_t commonelem
; /* element size if FAR, else zero */
551 int index
; /* OBJ-file external index */
553 DEFWRT_NONE
, /* no unusual default-WRT */
554 DEFWRT_STRING
, /* a string we don't yet understand */
555 DEFWRT_SEGMENT
, /* a segment */
556 DEFWRT_GROUP
/* a group */
563 struct External
*next_dws
; /* next with DEFWRT_STRING */
564 } *exthead
, **exttail
, *dws
;
566 static int externals
;
568 static struct ExtBack
{
569 struct ExtBack
*next
;
570 struct External
*exts
[EXT_BLKSIZ
];
573 static struct Segment
{
574 struct Segment
*next
;
576 int32_t index
; /* the NASM segment id */
577 int32_t obj_index
; /* the OBJ-file segment index */
578 struct Group
*grp
; /* the group it beint32_ts to */
580 int32_t align
; /* can be SEG_ABS + absolute addr */
581 struct Public
*pubhead
, **pubtail
, *lochead
, **loctail
;
582 char *segclass
, *overlay
; /* `class' is a C++ keyword :-) */
590 bool use32
; /* is this segment 32-bit? */
591 } *seghead
, **segtail
, *obj_seg_needs_update
;
593 static struct Group
{
596 int32_t index
; /* NASM segment id */
597 int32_t obj_index
; /* OBJ-file group index */
598 int32_t nentries
; /* number of elements... */
599 int32_t nindices
; /* ...and number of index elts... */
603 } segs
[GROUP_MAX
]; /* ...in this */
604 } *grphead
, **grptail
, *obj_grp_needs_update
;
606 static struct ImpDef
{
610 unsigned int impindex
;
612 } *imphead
, **imptail
;
614 static struct ExpDef
{
618 unsigned int ordinal
;
620 } *exphead
, **exptail
;
622 #define EXPDEF_FLAG_ORDINAL 0x80
623 #define EXPDEF_FLAG_RESIDENT 0x40
624 #define EXPDEF_FLAG_NODATA 0x20
625 #define EXPDEF_MASK_PARMCNT 0x1F
627 static int32_t obj_entry_seg
, obj_entry_ofs
;
629 const struct ofmt of_obj
;
630 static const struct dfmt borland_debug_form
;
632 /* The current segment */
633 static struct Segment
*current_seg
;
635 static int32_t obj_segment(char *, int, int *);
636 static void obj_write_file(void);
637 static enum directive_result
obj_directive(enum directives
, char *, int);
639 static void obj_init(void)
641 first_seg
= seg_alloc();
644 fpubtail
= &fpubhead
;
655 seghead
= obj_seg_needs_update
= NULL
;
657 grphead
= obj_grp_needs_update
= NULL
;
659 obj_entry_seg
= NO_SEG
;
660 obj_uppercase
= false;
666 static int obj_set_info(enum geninfo type
, char **val
)
674 static void obj_cleanup(void)
679 struct Segment
*segtmp
= seghead
;
680 seghead
= seghead
->next
;
681 while (segtmp
->pubhead
) {
682 struct Public
*pubtmp
= segtmp
->pubhead
;
683 segtmp
->pubhead
= pubtmp
->next
;
684 nasm_free(pubtmp
->name
);
687 nasm_free(segtmp
->segclass
);
688 nasm_free(segtmp
->overlay
);
692 struct Public
*pubtmp
= fpubhead
;
693 fpubhead
= fpubhead
->next
;
694 nasm_free(pubtmp
->name
);
698 struct External
*exttmp
= exthead
;
699 exthead
= exthead
->next
;
703 struct ImpDef
*imptmp
= imphead
;
704 imphead
= imphead
->next
;
705 nasm_free(imptmp
->extname
);
706 nasm_free(imptmp
->libname
);
707 nasm_free(imptmp
->impname
); /* nasm_free won't mind if it's NULL */
711 struct ExpDef
*exptmp
= exphead
;
712 exphead
= exphead
->next
;
713 nasm_free(exptmp
->extname
);
714 nasm_free(exptmp
->intname
);
718 struct ExtBack
*ebtmp
= ebhead
;
719 ebhead
= ebhead
->next
;
723 struct Group
*grptmp
= grphead
;
724 grphead
= grphead
->next
;
729 static void obj_ext_set_defwrt(struct External
*ext
, char *id
)
734 for (seg
= seghead
; seg
; seg
= seg
->next
)
735 if (!strcmp(seg
->name
, id
)) {
736 ext
->defwrt_type
= DEFWRT_SEGMENT
;
737 ext
->defwrt_ptr
.seg
= seg
;
742 for (grp
= grphead
; grp
; grp
= grp
->next
)
743 if (!strcmp(grp
->name
, id
)) {
744 ext
->defwrt_type
= DEFWRT_GROUP
;
745 ext
->defwrt_ptr
.grp
= grp
;
750 ext
->defwrt_type
= DEFWRT_STRING
;
751 ext
->defwrt_ptr
.string
= id
;
756 static void obj_deflabel(char *name
, int32_t segment
,
757 int64_t offset
, int is_global
, char *special
)
760 * We have three cases:
762 * (i) `segment' is a segment-base. If so, set the name field
763 * for the segment or group structure it refers to, and then
766 * (ii) `segment' is one of our segments, or a SEG_ABS segment.
767 * Save the label position for later output of a PUBDEF record.
768 * (Or a MODPUB, if we work out how.)
770 * (iii) `segment' is not one of our segments. Save the label
771 * position for later output of an EXTDEF, and also store a
772 * back-reference so that we can map later references to this
773 * segment number to the external index.
775 struct External
*ext
;
779 bool used_special
= false; /* have we used the special text? */
781 #if defined(DEBUG) && DEBUG>2
782 nasm_error(ERR_DEBUG
,
783 " obj_deflabel: %s, seg=%"PRIx32
", off=%"PRIx64
", is_global=%d, %s\n",
784 name
, segment
, offset
, is_global
, special
);
788 * If it's a special-retry from pass two, discard it.
794 * First check for the double-period, signifying something
797 if (name
[0] == '.' && name
[1] == '.' && name
[2] != '@') {
798 if (!strcmp(name
, "..start")) {
799 obj_entry_seg
= segment
;
800 obj_entry_ofs
= offset
;
803 nasm_error(ERR_NONFATAL
, "unrecognised special symbol `%s'", name
);
809 if (obj_seg_needs_update
) {
810 obj_seg_needs_update
->name
= name
;
812 } else if (obj_grp_needs_update
) {
813 obj_grp_needs_update
->name
= name
;
816 if (segment
< SEG_ABS
&& segment
!= NO_SEG
&& segment
% 2)
819 if (segment
>= SEG_ABS
|| segment
== NO_SEG
) {
821 * SEG_ABS subcase of (ii).
826 pub
= *fpubtail
= nasm_malloc(sizeof(*pub
));
827 fpubtail
= &pub
->next
;
829 pub
->name
= nasm_strdup(name
);
830 pub
->offset
= offset
;
831 pub
->segment
= (segment
== NO_SEG
? 0 : segment
& ~SEG_ABS
);
834 nasm_error(ERR_NONFATAL
, "OBJ supports no special symbol features"
835 " for this symbol type");
840 * If `any_segs' is still false, we might need to define a
841 * default segment, if they're trying to declare a label in
844 if (!any_segs
&& segment
== first_seg
) {
845 int tempint
; /* ignored */
846 if (segment
!= obj_segment("__NASMDEFSEG", 2, &tempint
))
847 nasm_panic(0, "strange segment conditions in OBJ driver");
850 for (seg
= seghead
; seg
&& is_global
; seg
= seg
->next
)
851 if (seg
->index
== segment
) {
852 struct Public
*loc
= nasm_malloc(sizeof(*loc
));
854 * Case (ii). Maybe MODPUB someday?
857 seg
->pubtail
= &loc
->next
;
859 loc
->name
= nasm_strdup(name
);
860 loc
->offset
= offset
;
863 nasm_error(ERR_NONFATAL
,
864 "OBJ supports no special symbol features"
865 " for this symbol type");
873 ext
= *exttail
= nasm_malloc(sizeof(*ext
));
875 exttail
= &ext
->next
;
877 /* Place by default all externs into the current segment */
878 ext
->defwrt_type
= DEFWRT_NONE
;
880 /* 28-Apr-2002 - John Coffman
881 The following code was introduced on 12-Aug-2000, and breaks fixups
882 on code passed thru the MSC 5.1 linker (3.66) and MSC 6.00A linker
883 (5.10). It was introduced after FIXUP32 was added, and may be needed
884 for 32-bit segments. The following will get 16-bit segments working
885 again, and maybe someone can correct the 'if' condition which is
891 if (current_seg
&& current_seg
->use32
) {
892 if (current_seg
->grp
) {
893 ext
->defwrt_type
= DEFWRT_GROUP
;
894 ext
->defwrt_ptr
.grp
= current_seg
->grp
;
896 ext
->defwrt_type
= DEFWRT_SEGMENT
;
897 ext
->defwrt_ptr
.seg
= current_seg
;
902 if (is_global
== 2) {
903 ext
->commonsize
= offset
;
904 ext
->commonelem
= 1; /* default FAR */
911 * Now process the special text, if any, to find default-WRT
912 * specifications and common-variable element-size and near/far
915 while (special
&& *special
) {
919 * We might have a default-WRT specification.
921 if (!nasm_strnicmp(special
, "wrt", 3)) {
925 special
+= strspn(special
, " \t");
926 p
= nasm_strndup(special
, len
= strcspn(special
, ":"));
927 obj_ext_set_defwrt(ext
, p
);
929 if (*special
&& *special
!= ':')
930 nasm_error(ERR_NONFATAL
, "`:' expected in special symbol"
931 " text for `%s'", ext
->name
);
932 else if (*special
== ':')
937 * The NEAR or FAR keywords specify nearness or
938 * farness. FAR gives default element size 1.
940 if (!nasm_strnicmp(special
, "far", 3)) {
944 nasm_error(ERR_NONFATAL
,
945 "`%s': `far' keyword may only be applied"
946 " to common variables\n", ext
->name
);
948 special
+= strspn(special
, " \t");
949 } else if (!nasm_strnicmp(special
, "near", 4)) {
953 nasm_error(ERR_NONFATAL
,
954 "`%s': `far' keyword may only be applied"
955 " to common variables\n", ext
->name
);
957 special
+= strspn(special
, " \t");
961 * If it's a common, and anything else remains on the line
962 * before a further colon, evaluate it as an expression and
963 * use that as the element size. Forward references aren't
969 if (ext
->commonsize
) {
971 struct tokenval tokval
;
974 stdscan_set(special
);
975 tokval
.t_type
= TOKEN_INVALID
;
976 e
= evaluate(stdscan
, NULL
, &tokval
, NULL
, 1, NULL
);
979 nasm_error(ERR_NONFATAL
, "cannot use relocatable"
980 " expression as common-variable element size");
982 ext
->commonelem
= reloc_value(e
);
984 special
= stdscan_get();
986 nasm_error(ERR_NONFATAL
,
987 "`%s': element-size specifications only"
988 " apply to common variables", ext
->name
);
989 while (*special
&& *special
!= ':')
1000 eb
= *ebtail
= nasm_zalloc(sizeof(*eb
));
1004 while (i
>= EXT_BLKSIZ
) {
1008 eb
= *ebtail
= nasm_zalloc(sizeof(*eb
));
1015 ext
->index
= ++externals
;
1017 if (special
&& !used_special
)
1018 nasm_error(ERR_NONFATAL
, "OBJ supports no special symbol features"
1019 " for this symbol type");
1022 /* forward declaration */
1023 static void obj_write_fixup(ObjRecord
* orp
, int bytes
,
1024 int segrel
, int32_t seg
, int32_t wrt
,
1025 struct Segment
*segto
);
1027 static void obj_out(int32_t segto
, const void *data
,
1028 enum out_type type
, uint64_t size
,
1029 int32_t segment
, int32_t wrt
)
1031 const uint8_t *ucdata
;
1033 struct Segment
*seg
;
1037 * handle absolute-assembly (structure definitions)
1039 if (segto
== NO_SEG
) {
1040 if (type
!= OUT_RESERVE
)
1041 nasm_error(ERR_NONFATAL
, "attempt to assemble code in [ABSOLUTE]"
1047 * If `any_segs' is still false, we must define a default
1051 int tempint
; /* ignored */
1052 if (segto
!= obj_segment("__NASMDEFSEG", 2, &tempint
))
1053 nasm_panic(0, "strange segment conditions in OBJ driver");
1057 * Find the segment we are targetting.
1059 for (seg
= seghead
; seg
; seg
= seg
->next
)
1060 if (seg
->index
== segto
)
1063 nasm_panic(0, "code directed to nonexistent segment?");
1066 orp
->parm
[0] = seg
->currentpos
;
1073 orp
= obj_check(seg
->orp
, 1);
1074 len
= RECORD_MAX
- orp
->used
;
1077 memcpy(orp
->buf
+ orp
->used
, ucdata
, len
);
1078 orp
->committed
= orp
->used
+= len
;
1079 orp
->parm
[0] = seg
->currentpos
+= len
;
1093 if (type
== OUT_ADDRESS
)
1094 size
= abs((int)size
);
1096 if (segment
== NO_SEG
&& type
!= OUT_ADDRESS
)
1097 nasm_error(ERR_NONFATAL
, "relative call to absolute address not"
1098 " supported by OBJ format");
1099 if (segment
>= SEG_ABS
)
1100 nasm_error(ERR_NONFATAL
, "far-absolute relocations not supported"
1103 ldata
= *(int64_t *)data
;
1104 if (type
!= OUT_ADDRESS
) {
1106 * For 16-bit and 32-bit x86 code, the size and realsize() always
1107 * matches as only jumps, calls and loops uses PC relative
1108 * addressing and the address isn't followed by any other opcode
1109 * bytes. In 64-bit mode there is RIP relative addressing which
1110 * means the fixup location can be followed by an immediate value,
1111 * meaning that size > realsize().
1113 * When the CPU is calculating the effective address, it takes the
1114 * RIP at the end of the instruction and adds the fixed up relative
1115 * address value to it.
1117 * The linker's point of reference is the end of the fixup location
1118 * (which is the end of the instruction for Jcc, CALL, LOOP[cc]).
1119 * It is calculating distance between the target symbol and the end
1120 * of the fixup location, and add this to the displacement value we
1121 * are calculating here and storing at the fixup location.
1123 * To get the right effect, we need to _reduce_ the displacement
1124 * value by the number of bytes following the fixup.
1127 * data at address 0x100; REL4ADR at 0x050, 4 byte immediate,
1128 * end of fixup at 0x054, end of instruction at 0x058.
1130 * => realsize() -> 4
1131 * => CPU needs a value of: 0x100 - 0x058 = 0x0a8
1132 * => linker/loader will add: 0x100 - 0x054 = 0x0ac
1133 * => We must add an addend of -4.
1134 * => realsize() - size = -4.
1136 * The code used to do size - realsize() at least since v0.90,
1137 * probably because it wasn't needed...
1140 size
= realsize(type
, size
);
1146 nasm_error(ERR_NONFATAL
, "OBJ format can only handle 16- or "
1147 "32-byte relocations");
1148 segment
= NO_SEG
; /* Don't actually generate a relocation */
1151 orp
= obj_word(orp
, ldata
);
1154 orp
= obj_dword(orp
, ldata
);
1159 if (segment
< SEG_ABS
&& (segment
!= NO_SEG
&& segment
% 2) &&
1162 * This is a 4-byte segment-base relocation such as
1163 * `MOV EAX,SEG foo'. OBJ format can't actually handle
1164 * these, but if the constant term has the 16 low bits
1165 * zero, we can just apply a 2-byte segment-base
1166 * relocation to the low word instead.
1170 nasm_error(ERR_NONFATAL
, "OBJ format cannot handle complex"
1171 " dword-size segment base references");
1173 if (segment
!= NO_SEG
)
1174 obj_write_fixup(orp
, rsize
,
1175 (type
== OUT_ADDRESS
? 0x4000 : 0),
1177 seg
->currentpos
+= size
;
1182 nasm_error(ERR_NONFATAL
,
1183 "Relocation type not supported by output format");
1188 orp
= obj_bump(orp
);
1189 seg
->currentpos
+= size
;
1195 static void obj_write_fixup(ObjRecord
* orp
, int bytes
,
1196 int segrel
, int32_t seg
, int32_t wrt
,
1197 struct Segment
*segto
)
1203 struct Segment
*s
= NULL
;
1204 struct Group
*g
= NULL
;
1205 struct External
*e
= NULL
;
1208 if (bytes
!= 2 && bytes
!= 4) {
1209 nasm_error(ERR_NONFATAL
, "`obj' output driver does not support"
1210 " %d-bit relocations", bytes
<< 3);
1216 orp
->child
= forp
= obj_new();
1217 forp
->up
= &(orp
->child
);
1218 /* We should choose between FIXUPP and FIXU32 record type */
1219 /* If we're targeting a 32-bit segment, use a FIXU32 record */
1221 forp
->type
= FIXU32
;
1223 forp
->type
= FIXUPP
;
1228 locat
= FIX_16_SELECTOR
;
1231 nasm_panic(0, "OBJ: 4-byte segment base fixup got"
1232 " through sanity check");
1235 locat
= (bytes
== 2) ? FIX_16_OFFSET
: FIX_32_OFFSET
;
1238 * There is a bug in tlink that makes it process self relative
1239 * fixups incorrectly if the x_size doesn't match the location
1242 forp
= obj_force(forp
, bytes
<< 3);
1245 forp
= obj_rword(forp
, locat
| segrel
| (orp
->parm
[0] - orp
->parm
[2]));
1247 tidx
= fidx
= -1, method
= 0; /* placate optimisers */
1250 * See if we can find the segment ID in our segment list. If
1251 * so, we have a T4 (LSEG) target.
1253 for (s
= seghead
; s
; s
= s
->next
)
1254 if (s
->index
== seg
)
1257 method
= 4, tidx
= s
->obj_index
;
1259 for (g
= grphead
; g
; g
= g
->next
)
1260 if (g
->index
== seg
)
1263 method
= 5, tidx
= g
->obj_index
;
1265 int32_t i
= seg
/ 2;
1266 struct ExtBack
*eb
= ebhead
;
1267 while (i
>= EXT_BLKSIZ
) {
1275 method
= 6, e
= eb
->exts
[i
], tidx
= e
->index
;
1278 "unrecognised segment value in obj_write_fixup");
1283 * If no WRT given, assume the natural default, which is method
1286 * - we are doing an OFFSET fixup for a grouped segment, in
1287 * which case we require F1 (group).
1289 * - we are doing an OFFSET fixup for an external with a
1290 * default WRT, in which case we must honour the default WRT.
1292 if (wrt
== NO_SEG
) {
1293 if (!base
&& s
&& s
->grp
)
1294 method
|= 0x10, fidx
= s
->grp
->obj_index
;
1295 else if (!base
&& e
&& e
->defwrt_type
!= DEFWRT_NONE
) {
1296 if (e
->defwrt_type
== DEFWRT_SEGMENT
)
1297 method
|= 0x00, fidx
= e
->defwrt_ptr
.seg
->obj_index
;
1298 else if (e
->defwrt_type
== DEFWRT_GROUP
)
1299 method
|= 0x10, fidx
= e
->defwrt_ptr
.grp
->obj_index
;
1301 nasm_error(ERR_NONFATAL
, "default WRT specification for"
1302 " external `%s' unresolved", e
->name
);
1303 method
|= 0x50, fidx
= -1; /* got to do _something_ */
1306 method
|= 0x50, fidx
= -1;
1309 * See if we can find the WRT-segment ID in our segment
1310 * list. If so, we have a F0 (LSEG) frame.
1312 for (s
= seghead
; s
; s
= s
->next
)
1313 if (s
->index
== wrt
- 1)
1316 method
|= 0x00, fidx
= s
->obj_index
;
1318 for (g
= grphead
; g
; g
= g
->next
)
1319 if (g
->index
== wrt
- 1)
1322 method
|= 0x10, fidx
= g
->obj_index
;
1324 int32_t i
= wrt
/ 2;
1325 struct ExtBack
*eb
= ebhead
;
1326 while (i
>= EXT_BLKSIZ
) {
1334 method
|= 0x20, fidx
= eb
->exts
[i
]->index
;
1337 "unrecognised WRT value in obj_write_fixup");
1342 forp
= obj_byte(forp
, method
);
1344 forp
= obj_index(forp
, fidx
);
1345 forp
= obj_index(forp
, tidx
);
1349 static int32_t obj_segment(char *name
, int pass
, int *bits
)
1352 * We call the label manager here to define a name for the new
1353 * segment, and when our _own_ label-definition stub gets
1354 * called in return, it should register the new segment name
1355 * using the pointer it gets passed. That way we save memory,
1356 * by sponging off the label manager.
1358 #if defined(DEBUG) && DEBUG>=3
1359 nasm_error(ERR_DEBUG
, " obj_segment: < %s >, pass=%d, *bits=%d\n",
1367 struct Segment
*seg
;
1369 struct External
**extp
;
1370 int obj_idx
, i
, attrs
;
1375 * Look for segment attributes.
1378 while (*name
== '.')
1379 name
++; /* hack, but a documented one */
1381 while (*p
&& !nasm_isspace(*p
))
1385 while (*p
&& nasm_isspace(*p
))
1389 while (*p
&& !nasm_isspace(*p
))
1393 while (*p
&& nasm_isspace(*p
))
1401 for (seg
= seghead
; seg
; seg
= seg
->next
) {
1403 if (!strcmp(seg
->name
, name
)) {
1404 if (attrs
> 0 && pass
== 1)
1405 nasm_error(ERR_WARNING
, "segment attributes specified on"
1406 " redeclaration of segment: ignoring");
1416 *segtail
= seg
= nasm_malloc(sizeof(*seg
));
1418 segtail
= &seg
->next
;
1419 seg
->index
= (any_segs
? seg_alloc() : first_seg
);
1420 seg
->obj_index
= obj_idx
;
1424 seg
->currentpos
= 0;
1425 seg
->align
= 1; /* default */
1426 seg
->use32
= false; /* default */
1427 seg
->combine
= CMB_PUBLIC
; /* default */
1428 seg
->segclass
= seg
->overlay
= NULL
;
1429 seg
->pubhead
= NULL
;
1430 seg
->pubtail
= &seg
->pubhead
;
1431 seg
->lochead
= NULL
;
1432 seg
->loctail
= &seg
->lochead
;
1433 seg
->orp
= obj_new();
1434 seg
->orp
->up
= &(seg
->orp
);
1435 seg
->orp
->ori
= ori_ledata
;
1436 seg
->orp
->type
= LEDATA
;
1437 seg
->orp
->parm
[1] = obj_idx
;
1440 * Process the segment attributes.
1449 * `p' contains a segment attribute.
1451 if (!nasm_stricmp(p
, "private"))
1452 seg
->combine
= CMB_PRIVATE
;
1453 else if (!nasm_stricmp(p
, "public"))
1454 seg
->combine
= CMB_PUBLIC
;
1455 else if (!nasm_stricmp(p
, "common"))
1456 seg
->combine
= CMB_COMMON
;
1457 else if (!nasm_stricmp(p
, "stack"))
1458 seg
->combine
= CMB_STACK
;
1459 else if (!nasm_stricmp(p
, "use16"))
1461 else if (!nasm_stricmp(p
, "use32"))
1463 else if (!nasm_stricmp(p
, "flat")) {
1465 * This segment is an OS/2 FLAT segment. That means
1466 * that its default group is group FLAT, even if
1467 * the group FLAT does not explicitly _contain_ the
1470 * When we see this, we must create the group
1471 * `FLAT', containing no segments, if it does not
1472 * already exist; then we must set the default
1473 * group of this segment to be the FLAT group.
1476 for (grp
= grphead
; grp
; grp
= grp
->next
)
1477 if (!strcmp(grp
->name
, "FLAT"))
1480 obj_directive(D_GROUP
, "FLAT", 1);
1481 for (grp
= grphead
; grp
; grp
= grp
->next
)
1482 if (!strcmp(grp
->name
, "FLAT"))
1485 nasm_panic(0, "failure to define FLAT?!");
1488 } else if (!nasm_strnicmp(p
, "class=", 6))
1489 seg
->segclass
= nasm_strdup(p
+ 6);
1490 else if (!nasm_strnicmp(p
, "overlay=", 8))
1491 seg
->overlay
= nasm_strdup(p
+ 8);
1492 else if (!nasm_strnicmp(p
, "align=", 6)) {
1493 seg
->align
= readnum(p
+ 6, &rn_error
);
1496 nasm_error(ERR_NONFATAL
, "segment alignment should be"
1499 switch (seg
->align
) {
1504 case 256: /* PAGE */
1505 case 4096: /* PharLap extension */
1508 nasm_error(ERR_WARNING
,
1509 "OBJ format does not support alignment"
1510 " of 8: rounding up to 16");
1516 nasm_error(ERR_WARNING
,
1517 "OBJ format does not support alignment"
1518 " of %d: rounding up to 256", seg
->align
);
1524 nasm_error(ERR_WARNING
,
1525 "OBJ format does not support alignment"
1526 " of %d: rounding up to 4096", seg
->align
);
1530 nasm_error(ERR_NONFATAL
, "invalid alignment value %d",
1535 } else if (!nasm_strnicmp(p
, "absolute=", 9)) {
1536 seg
->align
= SEG_ABS
+ readnum(p
+ 9, &rn_error
);
1538 nasm_error(ERR_NONFATAL
, "argument to `absolute' segment"
1539 " attribute should be numeric");
1543 /* We need to know whenever we have at least one 32-bit segment */
1544 obj_use32
|= seg
->use32
;
1546 obj_seg_needs_update
= seg
;
1547 if (seg
->align
>= SEG_ABS
)
1548 define_label(name
, NO_SEG
, seg
->align
- SEG_ABS
,
1549 NULL
, false, false);
1551 define_label(name
, seg
->index
+ 1, 0L,
1552 NULL
, false, false);
1553 obj_seg_needs_update
= NULL
;
1556 * See if this segment is defined in any groups.
1558 for (grp
= grphead
; grp
; grp
= grp
->next
) {
1559 for (i
= grp
->nindices
; i
< grp
->nentries
; i
++) {
1560 if (!strcmp(grp
->segs
[i
].name
, seg
->name
)) {
1561 nasm_free(grp
->segs
[i
].name
);
1562 grp
->segs
[i
] = grp
->segs
[grp
->nindices
];
1563 grp
->segs
[grp
->nindices
++].index
= seg
->obj_index
;
1565 nasm_error(ERR_WARNING
,
1566 "segment `%s' is already part of"
1567 " a group: first one takes precedence",
1576 * Walk through the list of externals with unresolved
1577 * default-WRT clauses, and resolve any that point at this
1582 if ((*extp
)->defwrt_type
== DEFWRT_STRING
&&
1583 !strcmp((*extp
)->defwrt_ptr
.string
, seg
->name
)) {
1584 nasm_free((*extp
)->defwrt_ptr
.string
);
1585 (*extp
)->defwrt_type
= DEFWRT_SEGMENT
;
1586 (*extp
)->defwrt_ptr
.seg
= seg
;
1587 *extp
= (*extp
)->next_dws
;
1589 extp
= &(*extp
)->next_dws
;
1601 static enum directive_result
1602 obj_directive(enum directives directive
, char *value
, int pass
)
1604 switch (directive
) {
1610 struct Segment
*seg
;
1611 struct External
**extp
;
1616 q
++; /* hack, but a documented one */
1618 while (*q
&& !nasm_isspace(*q
))
1620 if (nasm_isspace(*q
)) {
1622 while (*q
&& nasm_isspace(*q
))
1626 * Here we used to sanity-check the group directive to
1627 * ensure nobody tried to declare a group containing no
1628 * segments. However, OS/2 does this as standard
1629 * practice, so the sanity check has been removed.
1632 * nasm_error(ERR_NONFATAL,"GROUP directive contains no segments");
1633 * return DIRR_ERROR;
1638 for (grp
= grphead
; grp
; grp
= grp
->next
) {
1640 if (!strcmp(grp
->name
, v
)) {
1641 nasm_error(ERR_NONFATAL
, "group `%s' defined twice", v
);
1646 *grptail
= grp
= nasm_malloc(sizeof(*grp
));
1648 grptail
= &grp
->next
;
1649 grp
->index
= seg_alloc();
1650 grp
->obj_index
= obj_idx
;
1651 grp
->nindices
= grp
->nentries
= 0;
1654 obj_grp_needs_update
= grp
;
1655 define_label(v
, grp
->index
+ 1, 0L, NULL
, false, false);
1656 obj_grp_needs_update
= NULL
;
1660 while (*q
&& !nasm_isspace(*q
))
1662 if (nasm_isspace(*q
)) {
1664 while (*q
&& nasm_isspace(*q
))
1668 * Now p contains a segment name. Find it.
1670 for (seg
= seghead
; seg
; seg
= seg
->next
)
1671 if (!strcmp(seg
->name
, p
))
1675 * We have a segment index. Shift a name entry
1676 * to the end of the array to make room.
1678 grp
->segs
[grp
->nentries
++] = grp
->segs
[grp
->nindices
];
1679 grp
->segs
[grp
->nindices
++].index
= seg
->obj_index
;
1681 nasm_error(ERR_WARNING
,
1682 "segment `%s' is already part of"
1683 " a group: first one takes precedence",
1689 * We have an as-yet undefined segment.
1690 * Remember its name, for later.
1692 grp
->segs
[grp
->nentries
++].name
= nasm_strdup(p
);
1697 * Walk through the list of externals with unresolved
1698 * default-WRT clauses, and resolve any that point at
1703 if ((*extp
)->defwrt_type
== DEFWRT_STRING
&&
1704 !strcmp((*extp
)->defwrt_ptr
.string
, grp
->name
)) {
1705 nasm_free((*extp
)->defwrt_ptr
.string
);
1706 (*extp
)->defwrt_type
= DEFWRT_GROUP
;
1707 (*extp
)->defwrt_ptr
.grp
= grp
;
1708 *extp
= (*extp
)->next_dws
;
1710 extp
= &(*extp
)->next_dws
;
1716 obj_uppercase
= true;
1721 char *q
, *extname
, *libname
, *impname
;
1724 return 1; /* ignore in pass two */
1725 extname
= q
= value
;
1726 while (*q
&& !nasm_isspace(*q
))
1728 if (nasm_isspace(*q
)) {
1730 while (*q
&& nasm_isspace(*q
))
1735 while (*q
&& !nasm_isspace(*q
))
1737 if (nasm_isspace(*q
)) {
1739 while (*q
&& nasm_isspace(*q
))
1745 if (!*extname
|| !*libname
)
1746 nasm_error(ERR_NONFATAL
, "`import' directive requires symbol name"
1747 " and library name");
1752 imp
= *imptail
= nasm_malloc(sizeof(struct ImpDef
));
1753 imptail
= &imp
->next
;
1755 imp
->extname
= nasm_strdup(extname
);
1756 imp
->libname
= nasm_strdup(libname
);
1757 imp
->impindex
= readnum(impname
, &err
);
1758 if (!*impname
|| err
)
1759 imp
->impname
= nasm_strdup(impname
);
1761 imp
->impname
= NULL
;
1768 char *q
, *extname
, *intname
, *v
;
1769 struct ExpDef
*export
;
1771 unsigned int ordinal
= 0;
1774 return DIRR_OK
; /* ignore in pass two */
1775 intname
= q
= value
;
1776 while (*q
&& !nasm_isspace(*q
))
1778 if (nasm_isspace(*q
)) {
1780 while (*q
&& nasm_isspace(*q
))
1785 while (*q
&& !nasm_isspace(*q
))
1787 if (nasm_isspace(*q
)) {
1789 while (*q
&& nasm_isspace(*q
))
1794 nasm_error(ERR_NONFATAL
, "`export' directive requires export name");
1803 while (*q
&& !nasm_isspace(*q
))
1805 if (nasm_isspace(*q
)) {
1807 while (*q
&& nasm_isspace(*q
))
1810 if (!nasm_stricmp(v
, "resident"))
1811 flags
|= EXPDEF_FLAG_RESIDENT
;
1812 else if (!nasm_stricmp(v
, "nodata"))
1813 flags
|= EXPDEF_FLAG_NODATA
;
1814 else if (!nasm_strnicmp(v
, "parm=", 5)) {
1816 flags
|= EXPDEF_MASK_PARMCNT
& readnum(v
+ 5, &err
);
1818 nasm_error(ERR_NONFATAL
,
1819 "value `%s' for `parm' is non-numeric", v
+ 5);
1824 ordinal
= readnum(v
, &err
);
1826 nasm_error(ERR_NONFATAL
,
1827 "unrecognised export qualifier `%s'", v
);
1830 flags
|= EXPDEF_FLAG_ORDINAL
;
1834 export
= *exptail
= nasm_malloc(sizeof(struct ExpDef
));
1835 exptail
= &export
->next
;
1836 export
->next
= NULL
;
1837 export
->extname
= nasm_strdup(extname
);
1838 export
->intname
= nasm_strdup(intname
);
1839 export
->ordinal
= ordinal
;
1840 export
->flags
= flags
;
1845 return DIRR_UNKNOWN
;
1849 static void obj_sectalign(int32_t seg
, unsigned int value
)
1853 list_for_each(s
, seghead
) {
1854 if (s
->index
== seg
)
1859 * it should not be too big value
1860 * and applied on non-absolute sections
1862 if (!s
|| !is_power2(value
) ||
1863 value
> 4096 || s
->align
>= SEG_ABS
)
1867 * FIXME: No code duplication please
1868 * consider making helper for this
1869 * mapping since section handler has
1888 if (s
->align
< (int)value
)
1892 static int32_t obj_segbase(int32_t segment
)
1894 struct Segment
*seg
;
1897 * Find the segment in our list.
1899 for (seg
= seghead
; seg
; seg
= seg
->next
)
1900 if (seg
->index
== segment
- 1)
1905 * Might be an external with a default WRT.
1907 int32_t i
= segment
/ 2;
1908 struct ExtBack
*eb
= ebhead
;
1911 while (i
>= EXT_BLKSIZ
) {
1921 nasm_assert(pass0
== 0);
1922 /* Not available - can happen during optimization */
1926 switch (e
->defwrt_type
) {
1928 return segment
; /* fine */
1929 case DEFWRT_SEGMENT
:
1930 return e
->defwrt_ptr
.seg
->index
+ 1;
1932 return e
->defwrt_ptr
.grp
->index
+ 1;
1934 return NO_SEG
; /* can't tell what it is */
1938 return segment
; /* not one of ours - leave it alone */
1941 if (seg
->align
>= SEG_ABS
)
1942 return seg
->align
; /* absolute segment */
1944 return seg
->grp
->index
+ 1; /* grouped segment */
1946 return segment
; /* no special treatment */
1949 static void obj_filename(char *inname
, char *outname
)
1951 strcpy(obj_infile
, inname
);
1952 standard_extension(inname
, outname
, ".obj");
1955 static void obj_write_file(void)
1957 struct Segment
*seg
, *entry_seg_ptr
= 0;
1958 struct FileName
*fn
;
1959 struct LineNumber
*ln
;
1961 struct Public
*pub
, *loc
;
1962 struct External
*ext
;
1964 struct ExpDef
*export
;
1967 const bool debuginfo
= (dfmt
== &borland_debug_form
);
1970 * Write the THEADR module header.
1974 obj_name(orp
, obj_infile
);
1978 * Write the NASM boast comment.
1981 obj_rword(orp
, 0); /* comment type zero */
1982 obj_name(orp
, nasm_comment
);
1987 * Write the IMPDEF records, if any.
1989 for (imp
= imphead
; imp
; imp
= imp
->next
) {
1990 obj_rword(orp
, 0xA0); /* comment class A0 */
1991 obj_byte(orp
, 1); /* subfunction 1: IMPDEF */
1993 obj_byte(orp
, 0); /* import by name */
1995 obj_byte(orp
, 1); /* import by ordinal */
1996 obj_name(orp
, imp
->extname
);
1997 obj_name(orp
, imp
->libname
);
1999 obj_name(orp
, imp
->impname
);
2001 obj_word(orp
, imp
->impindex
);
2006 * Write the EXPDEF records, if any.
2008 for (export
= exphead
; export
; export
= export
->next
) {
2009 obj_rword(orp
, 0xA0); /* comment class A0 */
2010 obj_byte(orp
, 2); /* subfunction 2: EXPDEF */
2011 obj_byte(orp
, export
->flags
);
2012 obj_name(orp
, export
->extname
);
2013 obj_name(orp
, export
->intname
);
2014 if (export
->flags
& EXPDEF_FLAG_ORDINAL
)
2015 obj_word(orp
, export
->ordinal
);
2019 /* we're using extended OMF if we put in debug info */
2022 obj_byte(orp
, 0x40);
2023 obj_byte(orp
, dEXTENDED
);
2028 * Write the first LNAMES record, containing LNAME one, which
2029 * is null. Also initialize the LNAME counter.
2035 * Write some LNAMES for the segment names
2037 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2038 orp
= obj_name(orp
, seg
->name
);
2040 orp
= obj_name(orp
, seg
->segclass
);
2042 orp
= obj_name(orp
, seg
->overlay
);
2046 * Write some LNAMES for the group names
2048 for (grp
= grphead
; grp
; grp
= grp
->next
) {
2049 orp
= obj_name(orp
, grp
->name
);
2055 * Write the SEGDEF records.
2058 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2060 uint32_t seglen
= seg
->currentpos
;
2062 acbp
= (seg
->combine
<< 2); /* C field */
2065 acbp
|= 0x01; /* P bit is Use32 flag */
2066 else if (seglen
== 0x10000L
) {
2067 seglen
= 0; /* This special case may be needed for old linkers */
2068 acbp
|= 0x02; /* B bit */
2072 if (seg
->align
>= SEG_ABS
)
2073 /* acbp |= 0x00 */ ;
2074 else if (seg
->align
>= 4096) {
2075 if (seg
->align
> 4096)
2076 nasm_error(ERR_NONFATAL
, "segment `%s' requires more alignment"
2077 " than OBJ format supports", seg
->name
);
2078 acbp
|= 0xC0; /* PharLap extension */
2079 } else if (seg
->align
>= 256) {
2081 } else if (seg
->align
>= 16) {
2083 } else if (seg
->align
>= 4) {
2085 } else if (seg
->align
>= 2) {
2090 obj_byte(orp
, acbp
);
2091 if (seg
->align
& SEG_ABS
) {
2092 obj_x(orp
, seg
->align
- SEG_ABS
); /* Frame */
2093 obj_byte(orp
, 0); /* Offset */
2096 obj_index(orp
, ++lname_idx
);
2097 obj_index(orp
, seg
->segclass
? ++lname_idx
: 1);
2098 obj_index(orp
, seg
->overlay
? ++lname_idx
: 1);
2103 * Write the GRPDEF records.
2106 for (grp
= grphead
; grp
; grp
= grp
->next
) {
2109 if (grp
->nindices
!= grp
->nentries
) {
2110 for (i
= grp
->nindices
; i
< grp
->nentries
; i
++) {
2111 nasm_error(ERR_NONFATAL
, "group `%s' contains undefined segment"
2112 " `%s'", grp
->name
, grp
->segs
[i
].name
);
2113 nasm_free(grp
->segs
[i
].name
);
2114 grp
->segs
[i
].name
= NULL
;
2117 obj_index(orp
, ++lname_idx
);
2118 for (i
= 0; i
< grp
->nindices
; i
++) {
2119 obj_byte(orp
, 0xFF);
2120 obj_index(orp
, grp
->segs
[i
].index
);
2126 * Write the PUBDEF records: first the ones in the segments,
2127 * then the far-absolutes.
2130 orp
->ori
= ori_pubdef
;
2131 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2132 orp
->parm
[0] = seg
->grp
? seg
->grp
->obj_index
: 0;
2133 orp
->parm
[1] = seg
->obj_index
;
2134 for (pub
= seg
->pubhead
; pub
; pub
= pub
->next
) {
2135 orp
= obj_name(orp
, pub
->name
);
2136 orp
= obj_x(orp
, pub
->offset
);
2137 orp
= obj_byte(orp
, 0); /* type index */
2144 for (pub
= fpubhead
; pub
; pub
= pub
->next
) { /* pub-crawl :-) */
2145 if (orp
->parm
[2] != (uint32_t)pub
->segment
) {
2147 orp
->parm
[2] = pub
->segment
;
2149 orp
= obj_name(orp
, pub
->name
);
2150 orp
= obj_x(orp
, pub
->offset
);
2151 orp
= obj_byte(orp
, 0); /* type index */
2157 * Write the EXTDEF and COMDEF records, in order.
2159 orp
->ori
= ori_null
;
2160 for (ext
= exthead
; ext
; ext
= ext
->next
) {
2161 if (ext
->commonsize
== 0) {
2162 if (orp
->type
!= EXTDEF
) {
2166 orp
= obj_name(orp
, ext
->name
);
2167 orp
= obj_index(orp
, 0);
2169 if (orp
->type
!= COMDEF
) {
2173 orp
= obj_name(orp
, ext
->name
);
2174 orp
= obj_index(orp
, 0);
2175 if (ext
->commonelem
) {
2176 orp
= obj_byte(orp
, 0x61); /* far communal */
2177 orp
= obj_value(orp
, (ext
->commonsize
/ ext
->commonelem
));
2178 orp
= obj_value(orp
, ext
->commonelem
);
2180 orp
= obj_byte(orp
, 0x62); /* near communal */
2181 orp
= obj_value(orp
, ext
->commonsize
);
2189 * Write a COMENT record stating that the linker's first pass
2190 * may stop processing at this point. Exception is if our
2191 * MODEND record specifies a start point, in which case,
2192 * according to some variants of the documentation, this COMENT
2193 * should be omitted. So we'll omit it just in case.
2194 * But, TASM puts it in all the time so if we are using
2195 * TASM debug stuff we are putting it in
2197 if (debuginfo
|| obj_entry_seg
== NO_SEG
) {
2199 obj_byte(orp
, 0x40);
2200 obj_byte(orp
, dLINKPASS
);
2206 * 1) put out the compiler type
2207 * 2) Put out the type info. The only type we are using is near label #19
2211 struct Array
*arrtmp
= arrhead
;
2213 obj_byte(orp
, 0x40);
2214 obj_byte(orp
, dCOMPDEF
);
2219 obj_byte(orp
, 0x40);
2220 obj_byte(orp
, dTYPEDEF
);
2221 obj_word(orp
, 0x18); /* type # for linking */
2222 obj_word(orp
, 6); /* size of type */
2223 obj_byte(orp
, 0x2a); /* absolute type for debugging */
2225 obj_byte(orp
, 0x40);
2226 obj_byte(orp
, dTYPEDEF
);
2227 obj_word(orp
, 0x19); /* type # for linking */
2228 obj_word(orp
, 0); /* size of type */
2229 obj_byte(orp
, 0x24); /* absolute type for debugging */
2230 obj_byte(orp
, 0); /* near/far specifier */
2232 obj_byte(orp
, 0x40);
2233 obj_byte(orp
, dTYPEDEF
);
2234 obj_word(orp
, 0x1A); /* type # for linking */
2235 obj_word(orp
, 0); /* size of type */
2236 obj_byte(orp
, 0x24); /* absolute type for debugging */
2237 obj_byte(orp
, 1); /* near/far specifier */
2239 obj_byte(orp
, 0x40);
2240 obj_byte(orp
, dTYPEDEF
);
2241 obj_word(orp
, 0x1b); /* type # for linking */
2242 obj_word(orp
, 0); /* size of type */
2243 obj_byte(orp
, 0x23); /* absolute type for debugging */
2248 obj_byte(orp
, 0x40);
2249 obj_byte(orp
, dTYPEDEF
);
2250 obj_word(orp
, 0x1c); /* type # for linking */
2251 obj_word(orp
, 0); /* size of type */
2252 obj_byte(orp
, 0x23); /* absolute type for debugging */
2257 obj_byte(orp
, 0x40);
2258 obj_byte(orp
, dTYPEDEF
);
2259 obj_word(orp
, 0x1d); /* type # for linking */
2260 obj_word(orp
, 0); /* size of type */
2261 obj_byte(orp
, 0x23); /* absolute type for debugging */
2266 obj_byte(orp
, 0x40);
2267 obj_byte(orp
, dTYPEDEF
);
2268 obj_word(orp
, 0x1e); /* type # for linking */
2269 obj_word(orp
, 0); /* size of type */
2270 obj_byte(orp
, 0x23); /* absolute type for debugging */
2276 /* put out the array types */
2277 for (i
= ARRAYBOT
; i
< arrindex
; i
++) {
2278 obj_byte(orp
, 0x40);
2279 obj_byte(orp
, dTYPEDEF
);
2280 obj_word(orp
, i
); /* type # for linking */
2281 obj_word(orp
, arrtmp
->size
); /* size of type */
2282 obj_byte(orp
, 0x1A); /* absolute type for debugging (array) */
2283 obj_byte(orp
, arrtmp
->basetype
); /* base type */
2285 arrtmp
= arrtmp
->next
;
2289 * write out line number info with a LINNUM record
2290 * switch records when we switch segments, and output the
2291 * file in a pseudo-TASM fashion. The record switch is naive; that
2292 * is that one file may have many records for the same segment
2293 * if there are lots of segment switches
2295 if (fnhead
&& debuginfo
) {
2296 seg
= fnhead
->lnhead
->segment
;
2298 for (fn
= fnhead
; fn
; fn
= fn
->next
) {
2299 /* write out current file name */
2301 orp
->ori
= ori_null
;
2302 obj_byte(orp
, 0x40);
2303 obj_byte(orp
, dFILNAME
);
2305 obj_name(orp
, fn
->name
);
2309 /* write out line numbers this file */
2312 orp
->ori
= ori_linnum
;
2313 for (ln
= fn
->lnhead
; ln
; ln
= ln
->next
) {
2314 if (seg
!= ln
->segment
) {
2315 /* if we get here have to flush the buffer and start
2316 * a new record for a new segment
2321 orp
->parm
[0] = seg
->grp
? seg
->grp
->obj_index
: 0;
2322 orp
->parm
[1] = seg
->obj_index
;
2323 orp
= obj_word(orp
, ln
->lineno
);
2324 orp
= obj_x(orp
, ln
->offset
);
2331 * we are going to locate the entry point segment now
2332 * rather than wait until the MODEND record, because,
2333 * then we can output a special symbol to tell where the
2337 if (obj_entry_seg
!= NO_SEG
) {
2338 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2339 if (seg
->index
== obj_entry_seg
) {
2340 entry_seg_ptr
= seg
;
2345 nasm_error(ERR_NONFATAL
, "entry point is not in this module");
2349 * get ready to put out symbol records
2352 orp
->ori
= ori_local
;
2355 * put out a symbol for the entry point
2356 * no dots in this symbol, because, borland does
2357 * not (officially) support dots in label names
2358 * and I don't know what various versions of TLINK will do
2360 if (debuginfo
&& obj_entry_seg
!= NO_SEG
) {
2361 orp
= obj_name(orp
, "start_of_program");
2362 orp
= obj_word(orp
, 0x19); /* type: near label */
2363 orp
= obj_index(orp
, seg
->grp
? seg
->grp
->obj_index
: 0);
2364 orp
= obj_index(orp
, seg
->obj_index
);
2365 orp
= obj_x(orp
, obj_entry_ofs
);
2370 * put out the local labels
2372 for (seg
= seghead
; seg
&& debuginfo
; seg
= seg
->next
) {
2373 /* labels this seg */
2374 for (loc
= seg
->lochead
; loc
; loc
= loc
->next
) {
2375 orp
= obj_name(orp
, loc
->name
);
2376 orp
= obj_word(orp
, loc
->type
);
2377 orp
= obj_index(orp
, seg
->grp
? seg
->grp
->obj_index
: 0);
2378 orp
= obj_index(orp
, seg
->obj_index
);
2379 orp
= obj_x(orp
, loc
->offset
);
2387 * Write the LEDATA/FIXUPP pairs.
2389 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2391 nasm_free(seg
->orp
);
2395 * Write the MODEND module end marker.
2397 orp
->type
= obj_use32
? MODE32
: MODEND
;
2398 orp
->ori
= ori_null
;
2399 if (entry_seg_ptr
) {
2400 orp
->type
= entry_seg_ptr
->use32
? MODE32
: MODEND
;
2401 obj_byte(orp
, 0xC1);
2402 seg
= entry_seg_ptr
;
2404 obj_byte(orp
, 0x10);
2405 obj_index(orp
, seg
->grp
->obj_index
);
2408 * the below changed to prevent TLINK crashing.
2409 * Previous more efficient version read:
2411 * obj_byte (orp, 0x50);
2413 obj_byte(orp
, 0x00);
2414 obj_index(orp
, seg
->obj_index
);
2416 obj_index(orp
, seg
->obj_index
);
2417 obj_x(orp
, obj_entry_ofs
);
2424 static void obj_fwrite(ObjRecord
* orp
)
2426 unsigned int cksum
, len
;
2430 if (orp
->x_size
== 32)
2432 fputc(cksum
, ofile
);
2433 len
= orp
->committed
+ 1;
2434 cksum
+= (len
& 0xFF) + ((len
>> 8) & 0xFF);
2435 fwriteint16_t(len
, ofile
);
2436 nasm_write(orp
->buf
, len
-1, ofile
);
2437 for (ptr
= orp
->buf
; --len
; ptr
++)
2439 fputc((-cksum
) & 0xFF, ofile
);
2442 extern macros_t obj_stdmac
[];
2444 static void dbgbi_init(void)
2448 arrindex
= ARRAYBOT
;
2452 static void dbgbi_cleanup(void)
2454 struct Segment
*segtmp
;
2456 struct FileName
*fntemp
= fnhead
;
2457 while (fnhead
->lnhead
) {
2458 struct LineNumber
*lntemp
= fnhead
->lnhead
;
2459 fnhead
->lnhead
= lntemp
->next
;
2462 fnhead
= fnhead
->next
;
2463 nasm_free(fntemp
->name
);
2466 for (segtmp
= seghead
; segtmp
; segtmp
= segtmp
->next
) {
2467 while (segtmp
->lochead
) {
2468 struct Public
*loctmp
= segtmp
->lochead
;
2469 segtmp
->lochead
= loctmp
->next
;
2470 nasm_free(loctmp
->name
);
2475 struct Array
*arrtmp
= arrhead
;
2476 arrhead
= arrhead
->next
;
2481 static void dbgbi_linnum(const char *lnfname
, int32_t lineno
, int32_t segto
)
2483 struct FileName
*fn
;
2484 struct LineNumber
*ln
;
2485 struct Segment
*seg
;
2487 if (segto
== NO_SEG
)
2491 * If `any_segs' is still false, we must define a default
2495 int tempint
; /* ignored */
2496 if (segto
!= obj_segment("__NASMDEFSEG", 2, &tempint
))
2497 nasm_panic(0, "strange segment conditions in OBJ driver");
2501 * Find the segment we are targetting.
2503 for (seg
= seghead
; seg
; seg
= seg
->next
)
2504 if (seg
->index
== segto
)
2507 nasm_panic(0, "lineno directed to nonexistent segment?");
2509 /* for (fn = fnhead; fn; fn = fnhead->next) */
2510 for (fn
= fnhead
; fn
; fn
= fn
->next
) /* fbk - Austin Lunnen - John Fine */
2511 if (!nasm_stricmp(lnfname
, fn
->name
))
2514 fn
= nasm_malloc(sizeof(*fn
));
2515 fn
->name
= nasm_malloc(strlen(lnfname
) + 1);
2516 strcpy(fn
->name
, lnfname
);
2518 fn
->lntail
= &fn
->lnhead
;
2523 ln
= nasm_malloc(sizeof(*ln
));
2525 ln
->offset
= seg
->currentpos
;
2526 ln
->lineno
= lineno
;
2529 fn
->lntail
= &ln
->next
;
2532 static void dbgbi_deflabel(char *name
, int32_t segment
,
2533 int64_t offset
, int is_global
, char *special
)
2535 struct Segment
*seg
;
2540 * Note: ..[^@] special symbols are filtered in labels.c
2544 * If it's a special-retry from pass two, discard it.
2552 if (obj_seg_needs_update
) {
2554 } else if (obj_grp_needs_update
) {
2557 if (segment
< SEG_ABS
&& segment
!= NO_SEG
&& segment
% 2)
2560 if (segment
>= SEG_ABS
|| segment
== NO_SEG
) {
2565 * If `any_segs' is still false, we might need to define a
2566 * default segment, if they're trying to declare a label in
2567 * `first_seg'. But the label should exist due to a prior
2568 * call to obj_deflabel so we can skip that.
2571 for (seg
= seghead
; seg
; seg
= seg
->next
)
2572 if (seg
->index
== segment
) {
2573 struct Public
*loc
= nasm_malloc(sizeof(*loc
));
2575 * Case (ii). Maybe MODPUB someday?
2577 last_defined
= *seg
->loctail
= loc
;
2578 seg
->loctail
= &loc
->next
;
2580 loc
->name
= nasm_strdup(name
);
2581 loc
->offset
= offset
;
2584 static void dbgbi_typevalue(int32_t type
)
2587 int elem
= TYM_ELEMENTS(type
);
2588 type
= TYM_TYPE(type
);
2595 last_defined
->type
= 8; /* uint8_t */
2599 last_defined
->type
= 10; /* unsigned word */
2603 last_defined
->type
= 12; /* unsigned dword */
2607 last_defined
->type
= 14; /* float */
2611 last_defined
->type
= 15; /* qword */
2615 last_defined
->type
= 16; /* TBYTE */
2619 last_defined
->type
= 0x19; /*label */
2625 struct Array
*arrtmp
= nasm_malloc(sizeof(*arrtmp
));
2626 int vtype
= last_defined
->type
;
2627 arrtmp
->size
= vsize
* elem
;
2628 arrtmp
->basetype
= vtype
;
2629 arrtmp
->next
= NULL
;
2630 last_defined
->type
= arrindex
++;
2632 arrtail
= &(arrtmp
->next
);
2634 last_defined
= NULL
;
2636 static void dbgbi_output(int output_type
, void *param
)
2641 static const struct dfmt borland_debug_form
= {
2642 "Borland Debug Records",
2647 null_debug_directive
,
2651 NULL
/* pragma list */
2654 static const struct dfmt
* const borland_debug_arr
[3] = {
2655 &borland_debug_form
,
2660 const struct ofmt of_obj
= {
2661 "MS-DOS 16-bit/32-bit OMF object files",
2666 &borland_debug_form
,
2670 nasm_do_legacy_output
,
2679 NULL
/* pragma list */