1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2009 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
50 #include "output/outform.h"
51 #include "output/outlib.h"
56 * outobj.c is divided into two sections. The first section is low level
57 * routines for creating obj records; It has nearly zero NASM specific
58 * code. The second section is high level routines for processing calls and
59 * data structures from the rest of NASM into obj format.
61 * It should be easy (though not zero work) to lift the first section out for
62 * use as an obj file writer for some other assembler or compiler.
66 * These routines are built around the ObjRecord data struture. An ObjRecord
67 * holds an object file record that may be under construction or complete.
69 * A major function of these routines is to support continuation of an obj
70 * record into the next record when the maximum record size is exceeded. The
71 * high level code does not need to worry about where the record breaks occur.
72 * It does need to do some minor extra steps to make the automatic continuation
73 * work. Those steps may be skipped for records where the high level knows no
74 * continuation could be required.
76 * 1) An ObjRecord is allocated and cleared by obj_new, or an existing ObjRecord
77 * is cleared by obj_clear.
79 * 2) The caller should fill in .type.
81 * 3) If the record is continuable and there is processing that must be done at
82 * the start of each record then the caller should fill in .ori with the
83 * address of the record initializer routine.
85 * 4) If the record is continuable and it should be saved (rather than emitted
86 * immediately) as each record is done, the caller should set .up to be a
87 * pointer to a location in which the caller keeps the master pointer to the
88 * ObjRecord. When the record is continued, the obj_bump routine will then
89 * allocate a new ObjRecord structure and update the master pointer.
91 * 5) If the .ori field was used then the caller should fill in the .parm with
92 * any data required by the initializer.
94 * 6) The caller uses the routines: obj_byte, obj_word, obj_rword, obj_dword,
95 * obj_x, obj_index, obj_value and obj_name to fill in the various kinds of
96 * data required for this record.
98 * 7) If the record is continuable, the caller should call obj_commit at each
99 * point where breaking the record is permitted.
101 * 8) To write out the record, the caller should call obj_emit2. If the
102 * caller has called obj_commit for all data written then he can get slightly
103 * faster code by calling obj_emit instead of obj_emit2.
105 * Most of these routines return an ObjRecord pointer. This will be the input
106 * pointer most of the time and will be the new location if the ObjRecord
107 * moved as a result of the call. The caller may ignore the return value in
108 * three cases: It is a "Never Reallocates" routine; or The caller knows
109 * continuation is not possible; or The caller uses the master pointer for the
113 #define RECORD_MAX (1024-3) /* maximal size of any record except type+reclen */
114 #define OBJ_PARMS 3 /* maximum .parm used by any .ori routine */
116 #define FIX_08_LOW 0x8000 /* location type for various fixup subrecords */
117 #define FIX_16_OFFSET 0x8400
118 #define FIX_16_SELECTOR 0x8800
119 #define FIX_32_POINTER 0x8C00
120 #define FIX_08_HIGH 0x9000
121 #define FIX_32_OFFSET 0xA400
122 #define FIX_48_POINTER 0xAC00
124 enum RecordID
{ /* record ID codes */
126 THEADR
= 0x80, /* module header */
127 COMENT
= 0x88, /* comment record */
129 LINNUM
= 0x94, /* line number record */
130 LNAMES
= 0x96, /* list of names */
132 SEGDEF
= 0x98, /* segment definition */
133 GRPDEF
= 0x9A, /* group definition */
134 EXTDEF
= 0x8C, /* external definition */
135 PUBDEF
= 0x90, /* public definition */
136 COMDEF
= 0xB0, /* common definition */
138 LEDATA
= 0xA0, /* logical enumerated data */
139 FIXUPP
= 0x9C, /* fixups (relocations) */
140 FIXU32
= 0x9D, /* 32-bit fixups (relocations) */
142 MODEND
= 0x8A, /* module end */
143 MODE32
= 0x8B /* module end for 32-bit objects */
146 enum ComentID
{ /* ID codes for comment records */
148 dEXTENDED
= 0xA1, /* tells that we are using translator-specific extensions */
149 dLINKPASS
= 0xA2, /* link pass 2 marker */
150 dTYPEDEF
= 0xE3, /* define a type */
151 dSYM
= 0xE6, /* symbol debug record */
152 dFILNAME
= 0xE8, /* file name record */
153 dCOMPDEF
= 0xEA /* compiler type info */
156 typedef struct ObjRecord ObjRecord
;
157 typedef void ORI(ObjRecord
* orp
);
160 ORI
*ori
; /* Initialization routine */
161 int used
; /* Current data size */
162 int committed
; /* Data size at last boundary */
163 int x_size
; /* (see obj_x) */
164 unsigned int type
; /* Record type */
165 ObjRecord
*child
; /* Associated record below this one */
166 ObjRecord
**up
; /* Master pointer to this ObjRecord */
167 ObjRecord
*back
; /* Previous part of this record */
168 uint32_t parm
[OBJ_PARMS
]; /* Parameters for ori routine */
169 uint8_t buf
[RECORD_MAX
+ 3];
172 static void obj_fwrite(ObjRecord
* orp
);
173 static void ori_ledata(ObjRecord
* orp
);
174 static void ori_pubdef(ObjRecord
* orp
);
175 static void ori_null(ObjRecord
* orp
);
176 static ObjRecord
*obj_commit(ObjRecord
* orp
);
178 static bool obj_uppercase
; /* Flag: all names in uppercase */
179 static bool obj_use32
; /* Flag: at least one segment is 32-bit */
182 * Clear an ObjRecord structure. (Never reallocates).
183 * To simplify reuse of ObjRecord's, .type, .ori and .parm are not cleared.
185 static ObjRecord
*obj_clear(ObjRecord
* orp
)
197 * Emit an ObjRecord structure. (Never reallocates).
198 * The record is written out preceeded (recursively) by its previous part (if
199 * any) and followed (recursively) by its child (if any).
200 * The previous part and the child are freed. The main ObjRecord is cleared,
203 static ObjRecord
*obj_emit(ObjRecord
* orp
)
207 nasm_free(orp
->back
);
214 obj_emit(orp
->child
);
215 nasm_free(orp
->child
);
218 return (obj_clear(orp
));
222 * Commit and Emit a record. (Never reallocates).
224 static ObjRecord
*obj_emit2(ObjRecord
* orp
)
227 return (obj_emit(orp
));
231 * Allocate and clear a new ObjRecord; Also sets .ori to ori_null
233 static ObjRecord
*obj_new(void)
237 orp
= obj_clear(nasm_malloc(sizeof(ObjRecord
)));
243 * Advance to the next record because the existing one is full or its x_size
245 * Any uncommited data is moved into the next record.
247 static ObjRecord
*obj_bump(ObjRecord
* orp
)
250 int used
= orp
->used
;
251 int committed
= orp
->committed
;
254 *orp
->up
= nxt
= obj_new();
256 nxt
->type
= orp
->type
;
259 memcpy(nxt
->parm
, orp
->parm
, sizeof(orp
->parm
));
267 nxt
->committed
= nxt
->used
;
268 memcpy(nxt
->buf
+ nxt
->committed
, orp
->buf
+ committed
, used
);
269 nxt
->used
= nxt
->committed
+ used
;
276 * Advance to the next record if necessary to allow the next field to fit.
278 static ObjRecord
*obj_check(ObjRecord
* orp
, int size
)
280 if (orp
->used
+ size
> RECORD_MAX
)
283 if (!orp
->committed
) {
286 orp
->committed
= orp
->used
;
293 * All data written so far is commited to the current record (won't be moved to
294 * the next record in case of continuation).
296 static ObjRecord
*obj_commit(ObjRecord
* orp
)
298 orp
->committed
= orp
->used
;
305 static ObjRecord
*obj_byte(ObjRecord
* orp
, uint8_t val
)
307 orp
= obj_check(orp
, 1);
308 orp
->buf
[orp
->used
] = val
;
316 static ObjRecord
*obj_word(ObjRecord
* orp
, unsigned int val
)
318 orp
= obj_check(orp
, 2);
319 orp
->buf
[orp
->used
] = val
;
320 orp
->buf
[orp
->used
+ 1] = val
>> 8;
326 * Write a reversed word
328 static ObjRecord
*obj_rword(ObjRecord
* orp
, unsigned int val
)
330 orp
= obj_check(orp
, 2);
331 orp
->buf
[orp
->used
] = val
>> 8;
332 orp
->buf
[orp
->used
+ 1] = val
;
340 static ObjRecord
*obj_dword(ObjRecord
* orp
, uint32_t val
)
342 orp
= obj_check(orp
, 4);
343 orp
->buf
[orp
->used
] = val
;
344 orp
->buf
[orp
->used
+ 1] = val
>> 8;
345 orp
->buf
[orp
->used
+ 2] = val
>> 16;
346 orp
->buf
[orp
->used
+ 3] = val
>> 24;
352 * All fields of "size x" in one obj record must be the same size (either 16
353 * bits or 32 bits). There is a one bit flag in each record which specifies
355 * This routine is used to force the current record to have the desired
356 * x_size. x_size is normally automatic (using obj_x), so that this
357 * routine should be used outside obj_x, only to provide compatibility with
358 * linkers that have bugs in their processing of the size bit.
361 static ObjRecord
*obj_force(ObjRecord
* orp
, int x
)
363 if (orp
->x_size
== (x
^ 48))
370 * This routine writes a field of size x. The caller does not need to worry at
371 * all about whether 16-bits or 32-bits are required.
373 static ObjRecord
*obj_x(ObjRecord
* orp
, uint32_t val
)
378 orp
= obj_force(orp
, 32);
379 if (orp
->x_size
== 32) {
380 ObjRecord
*nxt
= obj_dword(orp
, val
);
381 nxt
->x_size
= 32; /* x_size is cleared when a record overflows */
385 return (obj_word(orp
, val
));
391 static ObjRecord
*obj_index(ObjRecord
* orp
, unsigned int val
)
394 return (obj_byte(orp
, val
));
395 return (obj_word(orp
, (val
>> 8) | (val
<< 8) | 0x80));
399 * Writes a variable length value
401 static ObjRecord
*obj_value(ObjRecord
* orp
, uint32_t val
)
404 return (obj_byte(orp
, val
));
406 orp
= obj_byte(orp
, 129);
407 return (obj_word(orp
, val
));
410 return (obj_dword(orp
, (val
<< 8) + 132));
411 orp
= obj_byte(orp
, 136);
412 return (obj_dword(orp
, val
));
416 * Writes a counted string
418 static ObjRecord
*obj_name(ObjRecord
* orp
, const char *name
)
420 int len
= strlen(name
);
423 orp
= obj_check(orp
, len
+ 1);
424 ptr
= orp
->buf
+ orp
->used
;
426 orp
->used
+= len
+ 1;
429 *ptr
++ = toupper(*name
);
432 memcpy(ptr
, name
, len
);
437 * Initializer for an LEDATA record.
439 * parm[1] = segment index
440 * During the use of a LEDATA ObjRecord, parm[0] is constantly updated to
441 * represent the offset that would be required if the record were split at the
443 * parm[2] is a copy of parm[0] as it was when the current record was initted.
445 static void ori_ledata(ObjRecord
* orp
)
447 obj_index(orp
, orp
->parm
[1]);
448 orp
->parm
[2] = orp
->parm
[0];
449 obj_x(orp
, orp
->parm
[0]);
453 * Initializer for a PUBDEF record.
454 * parm[0] = group index
455 * parm[1] = segment index
456 * parm[2] = frame (only used when both indexes are zero)
458 static void ori_pubdef(ObjRecord
* orp
)
460 obj_index(orp
, orp
->parm
[0]);
461 obj_index(orp
, orp
->parm
[1]);
462 if (!(orp
->parm
[0] | orp
->parm
[1]))
463 obj_word(orp
, orp
->parm
[2]);
467 * Initializer for a LINNUM record.
468 * parm[0] = group index
469 * parm[1] = segment index
471 static void ori_linnum(ObjRecord
* orp
)
473 obj_index(orp
, orp
->parm
[0]);
474 obj_index(orp
, orp
->parm
[1]);
478 * Initializer for a local vars record.
480 static void ori_local(ObjRecord
* orp
)
487 * Null initializer for records that continue without any header info
489 static void ori_null(ObjRecord
* orp
)
491 (void)orp
; /* Do nothing */
495 * This concludes the low level section of outobj.c
498 static char obj_infile
[FILENAME_MAX
];
501 static evalfunc evaluate
;
502 static ldfunc deflabel
;
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
;
575 int32_t index
; /* the NASM segment id */
576 int32_t obj_index
; /* the OBJ-file segment index */
577 struct Group
*grp
; /* the group it beint32_ts to */
579 int32_t align
; /* can be SEG_ABS + absolute addr */
586 bool use32
; /* is this segment 32-bit? */
587 struct Public
*pubhead
, **pubtail
, *lochead
, **loctail
;
589 char *segclass
, *overlay
; /* `class' is a C++ keyword :-) */
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
;
631 /* The current segment */
632 static struct Segment
*current_seg
;
634 static int32_t obj_segment(char *, int, int *);
635 static void obj_write_file(int debuginfo
);
636 static int obj_directive(enum directives
, char *, int);
638 static void obj_init(FILE * fp
, efunc errfunc
, ldfunc ldef
, evalfunc eval
)
644 first_seg
= seg_alloc();
647 fpubtail
= &fpubhead
;
658 seghead
= obj_seg_needs_update
= NULL
;
660 grphead
= obj_grp_needs_update
= NULL
;
662 obj_entry_seg
= NO_SEG
;
663 obj_uppercase
= false;
669 static int obj_set_info(enum geninfo type
, char **val
)
676 static void obj_cleanup(int debuginfo
)
678 obj_write_file(debuginfo
);
679 of_obj
.current_dfmt
->cleanup();
681 struct Segment
*segtmp
= seghead
;
682 seghead
= seghead
->next
;
683 while (segtmp
->pubhead
) {
684 struct Public
*pubtmp
= segtmp
->pubhead
;
685 segtmp
->pubhead
= pubtmp
->next
;
686 nasm_free(pubtmp
->name
);
689 nasm_free(segtmp
->segclass
);
690 nasm_free(segtmp
->overlay
);
694 struct Public
*pubtmp
= fpubhead
;
695 fpubhead
= fpubhead
->next
;
696 nasm_free(pubtmp
->name
);
700 struct External
*exttmp
= exthead
;
701 exthead
= exthead
->next
;
705 struct ImpDef
*imptmp
= imphead
;
706 imphead
= imphead
->next
;
707 nasm_free(imptmp
->extname
);
708 nasm_free(imptmp
->libname
);
709 nasm_free(imptmp
->impname
); /* nasm_free won't mind if it's NULL */
713 struct ExpDef
*exptmp
= exphead
;
714 exphead
= exphead
->next
;
715 nasm_free(exptmp
->extname
);
716 nasm_free(exptmp
->intname
);
720 struct ExtBack
*ebtmp
= ebhead
;
721 ebhead
= ebhead
->next
;
725 struct Group
*grptmp
= grphead
;
726 grphead
= grphead
->next
;
731 static void obj_ext_set_defwrt(struct External
*ext
, char *id
)
736 for (seg
= seghead
; seg
; seg
= seg
->next
)
737 if (!strcmp(seg
->name
, id
)) {
738 ext
->defwrt_type
= DEFWRT_SEGMENT
;
739 ext
->defwrt_ptr
.seg
= seg
;
744 for (grp
= grphead
; grp
; grp
= grp
->next
)
745 if (!strcmp(grp
->name
, id
)) {
746 ext
->defwrt_type
= DEFWRT_GROUP
;
747 ext
->defwrt_ptr
.grp
= grp
;
752 ext
->defwrt_type
= DEFWRT_STRING
;
753 ext
->defwrt_ptr
.string
= id
;
758 static void obj_deflabel(char *name
, int32_t segment
,
759 int64_t offset
, int is_global
, char *special
)
762 * We have three cases:
764 * (i) `segment' is a segment-base. If so, set the name field
765 * for the segment or group structure it refers to, and then
768 * (ii) `segment' is one of our segments, or a SEG_ABS segment.
769 * Save the label position for later output of a PUBDEF record.
770 * (Or a MODPUB, if we work out how.)
772 * (iii) `segment' is not one of our segments. Save the label
773 * position for later output of an EXTDEF, and also store a
774 * back-reference so that we can map later references to this
775 * segment number to the external index.
777 struct External
*ext
;
781 bool used_special
= false; /* have we used the special text? */
783 #if defined(DEBUG) && DEBUG>2
785 " obj_deflabel: %s, seg=%ld, off=%ld, is_global=%d, %s\n",
786 name
, segment
, offset
, is_global
, special
);
790 * If it's a special-retry from pass two, discard it.
796 * First check for the double-period, signifying something
799 if (name
[0] == '.' && name
[1] == '.' && name
[2] != '@') {
800 if (!strcmp(name
, "..start")) {
801 obj_entry_seg
= segment
;
802 obj_entry_ofs
= offset
;
805 error(ERR_NONFATAL
, "unrecognised special symbol `%s'", name
);
811 if (obj_seg_needs_update
) {
812 obj_seg_needs_update
->name
= name
;
814 } else if (obj_grp_needs_update
) {
815 obj_grp_needs_update
->name
= name
;
818 if (segment
< SEG_ABS
&& segment
!= NO_SEG
&& segment
% 2)
821 if (segment
>= SEG_ABS
|| segment
== NO_SEG
) {
823 * SEG_ABS subcase of (ii).
828 pub
= *fpubtail
= nasm_malloc(sizeof(*pub
));
829 fpubtail
= &pub
->next
;
831 pub
->name
= nasm_strdup(name
);
832 pub
->offset
= offset
;
833 pub
->segment
= (segment
== NO_SEG
? 0 : segment
& ~SEG_ABS
);
836 error(ERR_NONFATAL
, "OBJ supports no special symbol features"
837 " for this symbol type");
842 * If `any_segs' is still false, we might need to define a
843 * default segment, if they're trying to declare a label in
846 if (!any_segs
&& segment
== first_seg
) {
847 int tempint
; /* ignored */
848 if (segment
!= obj_segment("__NASMDEFSEG", 2, &tempint
))
849 error(ERR_PANIC
, "strange segment conditions in OBJ driver");
852 for (seg
= seghead
; seg
&& is_global
; seg
= seg
->next
)
853 if (seg
->index
== segment
) {
854 struct Public
*loc
= nasm_malloc(sizeof(*loc
));
856 * Case (ii). Maybe MODPUB someday?
859 seg
->pubtail
= &loc
->next
;
861 loc
->name
= nasm_strdup(name
);
862 loc
->offset
= offset
;
866 "OBJ supports no special symbol features"
867 " for this symbol type");
875 ext
= *exttail
= nasm_malloc(sizeof(*ext
));
877 exttail
= &ext
->next
;
879 /* Place by default all externs into the current segment */
880 ext
->defwrt_type
= DEFWRT_NONE
;
882 /* 28-Apr-2002 - John Coffman
883 The following code was introduced on 12-Aug-2000, and breaks fixups
884 on code passed thru the MSC 5.1 linker (3.66) and MSC 6.00A linker
885 (5.10). It was introduced after FIXUP32 was added, and may be needed
886 for 32-bit segments. The following will get 16-bit segments working
887 again, and maybe someone can correct the 'if' condition which is
893 if (current_seg
&& current_seg
->use32
) {
894 if (current_seg
->grp
) {
895 ext
->defwrt_type
= DEFWRT_GROUP
;
896 ext
->defwrt_ptr
.grp
= current_seg
->grp
;
898 ext
->defwrt_type
= DEFWRT_SEGMENT
;
899 ext
->defwrt_ptr
.seg
= current_seg
;
904 if (is_global
== 2) {
905 ext
->commonsize
= offset
;
906 ext
->commonelem
= 1; /* default FAR */
913 * Now process the special text, if any, to find default-WRT
914 * specifications and common-variable element-size and near/far
917 while (special
&& *special
) {
921 * We might have a default-WRT specification.
923 if (!nasm_strnicmp(special
, "wrt", 3)) {
927 special
+= strspn(special
, " \t");
928 p
= nasm_strndup(special
, len
= strcspn(special
, ":"));
929 obj_ext_set_defwrt(ext
, p
);
931 if (*special
&& *special
!= ':')
932 error(ERR_NONFATAL
, "`:' expected in special symbol"
933 " text for `%s'", ext
->name
);
934 else if (*special
== ':')
939 * The NEAR or FAR keywords specify nearness or
940 * farness. FAR gives default element size 1.
942 if (!nasm_strnicmp(special
, "far", 3)) {
947 "`%s': `far' keyword may only be applied"
948 " to common variables\n", ext
->name
);
950 special
+= strspn(special
, " \t");
951 } else if (!nasm_strnicmp(special
, "near", 4)) {
956 "`%s': `far' keyword may only be applied"
957 " to common variables\n", ext
->name
);
959 special
+= strspn(special
, " \t");
963 * If it's a common, and anything else remains on the line
964 * before a further colon, evaluate it as an expression and
965 * use that as the element size. Forward references aren't
971 if (ext
->commonsize
) {
973 struct tokenval tokval
;
976 stdscan_bufptr
= special
;
977 tokval
.t_type
= TOKEN_INVALID
;
978 e
= evaluate(stdscan
, NULL
, &tokval
, NULL
, 1, error
, NULL
);
981 error(ERR_NONFATAL
, "cannot use relocatable"
982 " expression as common-variable element size");
984 ext
->commonelem
= reloc_value(e
);
986 special
= stdscan_bufptr
;
989 "`%s': element-size specifications only"
990 " apply to common variables", ext
->name
);
991 while (*special
&& *special
!= ':')
1002 eb
= *ebtail
= nasm_malloc(sizeof(*eb
));
1006 while (i
>= EXT_BLKSIZ
) {
1010 eb
= *ebtail
= nasm_malloc(sizeof(*eb
));
1017 ext
->index
= ++externals
;
1019 if (special
&& !used_special
)
1020 error(ERR_NONFATAL
, "OBJ supports no special symbol features"
1021 " for this symbol type");
1024 /* forward declaration */
1025 static void obj_write_fixup(ObjRecord
* orp
, int bytes
,
1026 int segrel
, int32_t seg
, int32_t wrt
,
1027 struct Segment
*segto
);
1029 static void obj_out(int32_t segto
, const void *data
,
1030 enum out_type type
, uint64_t size
,
1031 int32_t segment
, int32_t wrt
)
1033 const uint8_t *ucdata
;
1035 struct Segment
*seg
;
1039 * handle absolute-assembly (structure definitions)
1041 if (segto
== NO_SEG
) {
1042 if (type
!= OUT_RESERVE
)
1043 error(ERR_NONFATAL
, "attempt to assemble code in [ABSOLUTE]"
1049 * If `any_segs' is still false, we must define a default
1053 int tempint
; /* ignored */
1054 if (segto
!= obj_segment("__NASMDEFSEG", 2, &tempint
))
1055 error(ERR_PANIC
, "strange segment conditions in OBJ driver");
1059 * Find the segment we are targetting.
1061 for (seg
= seghead
; seg
; seg
= seg
->next
)
1062 if (seg
->index
== segto
)
1065 error(ERR_PANIC
, "code directed to nonexistent segment?");
1068 orp
->parm
[0] = seg
->currentpos
;
1070 if (type
== OUT_RAWDATA
) {
1074 orp
= obj_check(seg
->orp
, 1);
1075 len
= RECORD_MAX
- orp
->used
;
1078 memcpy(orp
->buf
+ orp
->used
, ucdata
, len
);
1079 orp
->committed
= orp
->used
+= len
;
1080 orp
->parm
[0] = seg
->currentpos
+= len
;
1084 } else if (type
== OUT_ADDRESS
|| type
== OUT_REL2ADR
||
1085 type
== OUT_REL4ADR
) {
1088 if (segment
== NO_SEG
&& type
!= OUT_ADDRESS
)
1089 error(ERR_NONFATAL
, "relative call to absolute address not"
1090 " supported by OBJ format");
1091 if (segment
>= SEG_ABS
)
1092 error(ERR_NONFATAL
, "far-absolute relocations not supported"
1094 ldata
= *(int64_t *)data
;
1095 if (type
== OUT_REL2ADR
) {
1096 ldata
+= (size
- 2);
1098 } else if (type
== OUT_REL4ADR
) {
1099 ldata
+= (size
- 4);
1103 orp
= obj_word(orp
, ldata
);
1105 orp
= obj_dword(orp
, ldata
);
1107 if (segment
< SEG_ABS
&& (segment
!= NO_SEG
&& segment
% 2) &&
1110 * This is a 4-byte segment-base relocation such as
1111 * `MOV EAX,SEG foo'. OBJ format can't actually handle
1112 * these, but if the constant term has the 16 low bits
1113 * zero, we can just apply a 2-byte segment-base
1114 * relocation to the low word instead.
1118 error(ERR_NONFATAL
, "OBJ format cannot handle complex"
1119 " dword-size segment base references");
1121 if (segment
!= NO_SEG
)
1122 obj_write_fixup(orp
, rsize
,
1123 (type
== OUT_ADDRESS
? 0x4000 : 0),
1125 seg
->currentpos
+= size
;
1126 } else if (type
== OUT_RESERVE
) {
1128 orp
= obj_bump(orp
);
1129 seg
->currentpos
+= size
;
1134 static void obj_write_fixup(ObjRecord
* orp
, int bytes
,
1135 int segrel
, int32_t seg
, int32_t wrt
,
1136 struct Segment
*segto
)
1142 struct Segment
*s
= NULL
;
1143 struct Group
*g
= NULL
;
1144 struct External
*e
= NULL
;
1148 error(ERR_NONFATAL
, "`obj' output driver does not support"
1149 " one-byte relocations");
1155 orp
->child
= forp
= obj_new();
1156 forp
->up
= &(orp
->child
);
1157 /* We should choose between FIXUPP and FIXU32 record type */
1158 /* If we're targeting a 32-bit segment, use a FIXU32 record */
1160 forp
->type
= FIXU32
;
1162 forp
->type
= FIXUPP
;
1167 locat
= FIX_16_SELECTOR
;
1170 error(ERR_PANIC
, "OBJ: 4-byte segment base fixup got"
1171 " through sanity check");
1174 locat
= (bytes
== 2) ? FIX_16_OFFSET
: FIX_32_OFFSET
;
1177 * There is a bug in tlink that makes it process self relative
1178 * fixups incorrectly if the x_size doesn't match the location
1181 forp
= obj_force(forp
, bytes
<< 3);
1184 forp
= obj_rword(forp
, locat
| segrel
| (orp
->parm
[0] - orp
->parm
[2]));
1186 tidx
= fidx
= -1, method
= 0; /* placate optimisers */
1189 * See if we can find the segment ID in our segment list. If
1190 * so, we have a T4 (LSEG) target.
1192 for (s
= seghead
; s
; s
= s
->next
)
1193 if (s
->index
== seg
)
1196 method
= 4, tidx
= s
->obj_index
;
1198 for (g
= grphead
; g
; g
= g
->next
)
1199 if (g
->index
== seg
)
1202 method
= 5, tidx
= g
->obj_index
;
1204 int32_t i
= seg
/ 2;
1205 struct ExtBack
*eb
= ebhead
;
1206 while (i
>= EXT_BLKSIZ
) {
1214 method
= 6, e
= eb
->exts
[i
], tidx
= e
->index
;
1217 "unrecognised segment value in obj_write_fixup");
1222 * If no WRT given, assume the natural default, which is method
1225 * - we are doing an OFFSET fixup for a grouped segment, in
1226 * which case we require F1 (group).
1228 * - we are doing an OFFSET fixup for an external with a
1229 * default WRT, in which case we must honour the default WRT.
1231 if (wrt
== NO_SEG
) {
1232 if (!base
&& s
&& s
->grp
)
1233 method
|= 0x10, fidx
= s
->grp
->obj_index
;
1234 else if (!base
&& e
&& e
->defwrt_type
!= DEFWRT_NONE
) {
1235 if (e
->defwrt_type
== DEFWRT_SEGMENT
)
1236 method
|= 0x00, fidx
= e
->defwrt_ptr
.seg
->obj_index
;
1237 else if (e
->defwrt_type
== DEFWRT_GROUP
)
1238 method
|= 0x10, fidx
= e
->defwrt_ptr
.grp
->obj_index
;
1240 error(ERR_NONFATAL
, "default WRT specification for"
1241 " external `%s' unresolved", e
->name
);
1242 method
|= 0x50, fidx
= -1; /* got to do _something_ */
1245 method
|= 0x50, fidx
= -1;
1248 * See if we can find the WRT-segment ID in our segment
1249 * list. If so, we have a F0 (LSEG) frame.
1251 for (s
= seghead
; s
; s
= s
->next
)
1252 if (s
->index
== wrt
- 1)
1255 method
|= 0x00, fidx
= s
->obj_index
;
1257 for (g
= grphead
; g
; g
= g
->next
)
1258 if (g
->index
== wrt
- 1)
1261 method
|= 0x10, fidx
= g
->obj_index
;
1263 int32_t i
= wrt
/ 2;
1264 struct ExtBack
*eb
= ebhead
;
1265 while (i
>= EXT_BLKSIZ
) {
1273 method
|= 0x20, fidx
= eb
->exts
[i
]->index
;
1276 "unrecognised WRT value in obj_write_fixup");
1281 forp
= obj_byte(forp
, method
);
1283 forp
= obj_index(forp
, fidx
);
1284 forp
= obj_index(forp
, tidx
);
1288 static int32_t obj_segment(char *name
, int pass
, int *bits
)
1291 * We call the label manager here to define a name for the new
1292 * segment, and when our _own_ label-definition stub gets
1293 * called in return, it should register the new segment name
1294 * using the pointer it gets passed. That way we save memory,
1295 * by sponging off the label manager.
1297 #if defined(DEBUG) && DEBUG>=3
1298 fprintf(stderr
, " obj_segment: < %s >, pass=%d, *bits=%d\n",
1306 struct Segment
*seg
;
1308 struct External
**extp
;
1309 int obj_idx
, i
, attrs
;
1314 * Look for segment attributes.
1317 while (*name
== '.')
1318 name
++; /* hack, but a documented one */
1320 while (*p
&& !nasm_isspace(*p
))
1324 while (*p
&& nasm_isspace(*p
))
1328 while (*p
&& !nasm_isspace(*p
))
1332 while (*p
&& nasm_isspace(*p
))
1340 for (seg
= seghead
; seg
; seg
= seg
->next
) {
1342 if (!strcmp(seg
->name
, name
)) {
1343 if (attrs
> 0 && pass
== 1)
1344 error(ERR_WARNING
, "segment attributes specified on"
1345 " redeclaration of segment: ignoring");
1355 *segtail
= seg
= nasm_malloc(sizeof(*seg
));
1357 segtail
= &seg
->next
;
1358 seg
->index
= (any_segs
? seg_alloc() : first_seg
);
1359 seg
->obj_index
= obj_idx
;
1363 seg
->currentpos
= 0;
1364 seg
->align
= 1; /* default */
1365 seg
->use32
= false; /* default */
1366 seg
->combine
= CMB_PUBLIC
; /* default */
1367 seg
->segclass
= seg
->overlay
= NULL
;
1368 seg
->pubhead
= NULL
;
1369 seg
->pubtail
= &seg
->pubhead
;
1370 seg
->lochead
= NULL
;
1371 seg
->loctail
= &seg
->lochead
;
1372 seg
->orp
= obj_new();
1373 seg
->orp
->up
= &(seg
->orp
);
1374 seg
->orp
->ori
= ori_ledata
;
1375 seg
->orp
->type
= LEDATA
;
1376 seg
->orp
->parm
[1] = obj_idx
;
1379 * Process the segment attributes.
1388 * `p' contains a segment attribute.
1390 if (!nasm_stricmp(p
, "private"))
1391 seg
->combine
= CMB_PRIVATE
;
1392 else if (!nasm_stricmp(p
, "public"))
1393 seg
->combine
= CMB_PUBLIC
;
1394 else if (!nasm_stricmp(p
, "common"))
1395 seg
->combine
= CMB_COMMON
;
1396 else if (!nasm_stricmp(p
, "stack"))
1397 seg
->combine
= CMB_STACK
;
1398 else if (!nasm_stricmp(p
, "use16"))
1400 else if (!nasm_stricmp(p
, "use32"))
1402 else if (!nasm_stricmp(p
, "flat")) {
1404 * This segment is an OS/2 FLAT segment. That means
1405 * that its default group is group FLAT, even if
1406 * the group FLAT does not explicitly _contain_ the
1409 * When we see this, we must create the group
1410 * `FLAT', containing no segments, if it does not
1411 * already exist; then we must set the default
1412 * group of this segment to be the FLAT group.
1415 for (grp
= grphead
; grp
; grp
= grp
->next
)
1416 if (!strcmp(grp
->name
, "FLAT"))
1419 obj_directive(D_GROUP
, "FLAT", 1);
1420 for (grp
= grphead
; grp
; grp
= grp
->next
)
1421 if (!strcmp(grp
->name
, "FLAT"))
1424 error(ERR_PANIC
, "failure to define FLAT?!");
1427 } else if (!nasm_strnicmp(p
, "class=", 6))
1428 seg
->segclass
= nasm_strdup(p
+ 6);
1429 else if (!nasm_strnicmp(p
, "overlay=", 8))
1430 seg
->overlay
= nasm_strdup(p
+ 8);
1431 else if (!nasm_strnicmp(p
, "align=", 6)) {
1432 seg
->align
= readnum(p
+ 6, &rn_error
);
1435 error(ERR_NONFATAL
, "segment alignment should be"
1438 switch ((int)seg
->align
) {
1443 case 256: /* PAGE */
1444 case 4096: /* PharLap extension */
1448 "OBJ format does not support alignment"
1449 " of 8: rounding up to 16");
1456 "OBJ format does not support alignment"
1457 " of %d: rounding up to 256", seg
->align
);
1464 "OBJ format does not support alignment"
1465 " of %d: rounding up to 4096", seg
->align
);
1469 error(ERR_NONFATAL
, "invalid alignment value %d",
1474 } else if (!nasm_strnicmp(p
, "absolute=", 9)) {
1475 seg
->align
= SEG_ABS
+ readnum(p
+ 9, &rn_error
);
1477 error(ERR_NONFATAL
, "argument to `absolute' segment"
1478 " attribute should be numeric");
1482 /* We need to know whenever we have at least one 32-bit segment */
1483 obj_use32
|= seg
->use32
;
1485 obj_seg_needs_update
= seg
;
1486 if (seg
->align
>= SEG_ABS
)
1487 deflabel(name
, NO_SEG
, seg
->align
- SEG_ABS
,
1488 NULL
, false, false, &of_obj
, error
);
1490 deflabel(name
, seg
->index
+ 1, 0L,
1491 NULL
, false, false, &of_obj
, error
);
1492 obj_seg_needs_update
= NULL
;
1495 * See if this segment is defined in any groups.
1497 for (grp
= grphead
; grp
; grp
= grp
->next
) {
1498 for (i
= grp
->nindices
; i
< grp
->nentries
; i
++) {
1499 if (!strcmp(grp
->segs
[i
].name
, seg
->name
)) {
1500 nasm_free(grp
->segs
[i
].name
);
1501 grp
->segs
[i
] = grp
->segs
[grp
->nindices
];
1502 grp
->segs
[grp
->nindices
++].index
= seg
->obj_index
;
1505 "segment `%s' is already part of"
1506 " a group: first one takes precedence",
1515 * Walk through the list of externals with unresolved
1516 * default-WRT clauses, and resolve any that point at this
1521 if ((*extp
)->defwrt_type
== DEFWRT_STRING
&&
1522 !strcmp((*extp
)->defwrt_ptr
.string
, seg
->name
)) {
1523 nasm_free((*extp
)->defwrt_ptr
.string
);
1524 (*extp
)->defwrt_type
= DEFWRT_SEGMENT
;
1525 (*extp
)->defwrt_ptr
.seg
= seg
;
1526 *extp
= (*extp
)->next_dws
;
1528 extp
= &(*extp
)->next_dws
;
1540 static int obj_directive(enum directives directive
, char *value
, int pass
)
1542 switch (directive
) {
1548 struct Segment
*seg
;
1549 struct External
**extp
;
1554 q
++; /* hack, but a documented one */
1556 while (*q
&& !nasm_isspace(*q
))
1558 if (nasm_isspace(*q
)) {
1560 while (*q
&& nasm_isspace(*q
))
1564 * Here we used to sanity-check the group directive to
1565 * ensure nobody tried to declare a group containing no
1566 * segments. However, OS/2 does this as standard
1567 * practice, so the sanity check has been removed.
1570 * error(ERR_NONFATAL,"GROUP directive contains no segments");
1576 for (grp
= grphead
; grp
; grp
= grp
->next
) {
1578 if (!strcmp(grp
->name
, v
)) {
1579 error(ERR_NONFATAL
, "group `%s' defined twice", v
);
1584 *grptail
= grp
= nasm_malloc(sizeof(*grp
));
1586 grptail
= &grp
->next
;
1587 grp
->index
= seg_alloc();
1588 grp
->obj_index
= obj_idx
;
1589 grp
->nindices
= grp
->nentries
= 0;
1592 obj_grp_needs_update
= grp
;
1593 deflabel(v
, grp
->index
+ 1, 0L,
1594 NULL
, false, false, &of_obj
, error
);
1595 obj_grp_needs_update
= NULL
;
1599 while (*q
&& !nasm_isspace(*q
))
1601 if (nasm_isspace(*q
)) {
1603 while (*q
&& nasm_isspace(*q
))
1607 * Now p contains a segment name. Find it.
1609 for (seg
= seghead
; seg
; seg
= seg
->next
)
1610 if (!strcmp(seg
->name
, p
))
1614 * We have a segment index. Shift a name entry
1615 * to the end of the array to make room.
1617 grp
->segs
[grp
->nentries
++] = grp
->segs
[grp
->nindices
];
1618 grp
->segs
[grp
->nindices
++].index
= seg
->obj_index
;
1621 "segment `%s' is already part of"
1622 " a group: first one takes precedence",
1628 * We have an as-yet undefined segment.
1629 * Remember its name, for later.
1631 grp
->segs
[grp
->nentries
++].name
= nasm_strdup(p
);
1636 * Walk through the list of externals with unresolved
1637 * default-WRT clauses, and resolve any that point at
1642 if ((*extp
)->defwrt_type
== DEFWRT_STRING
&&
1643 !strcmp((*extp
)->defwrt_ptr
.string
, grp
->name
)) {
1644 nasm_free((*extp
)->defwrt_ptr
.string
);
1645 (*extp
)->defwrt_type
= DEFWRT_GROUP
;
1646 (*extp
)->defwrt_ptr
.grp
= grp
;
1647 *extp
= (*extp
)->next_dws
;
1649 extp
= &(*extp
)->next_dws
;
1655 obj_uppercase
= true;
1660 char *q
, *extname
, *libname
, *impname
;
1663 return 1; /* ignore in pass two */
1664 extname
= q
= value
;
1665 while (*q
&& !nasm_isspace(*q
))
1667 if (nasm_isspace(*q
)) {
1669 while (*q
&& nasm_isspace(*q
))
1674 while (*q
&& !nasm_isspace(*q
))
1676 if (nasm_isspace(*q
)) {
1678 while (*q
&& nasm_isspace(*q
))
1684 if (!*extname
|| !*libname
)
1685 error(ERR_NONFATAL
, "`import' directive requires symbol name"
1686 " and library name");
1691 imp
= *imptail
= nasm_malloc(sizeof(struct ImpDef
));
1692 imptail
= &imp
->next
;
1694 imp
->extname
= nasm_strdup(extname
);
1695 imp
->libname
= nasm_strdup(libname
);
1696 imp
->impindex
= readnum(impname
, &err
);
1697 if (!*impname
|| err
)
1698 imp
->impname
= nasm_strdup(impname
);
1700 imp
->impname
= NULL
;
1707 char *q
, *extname
, *intname
, *v
;
1708 struct ExpDef
*export
;
1710 unsigned int ordinal
= 0;
1713 return 1; /* ignore in pass two */
1714 intname
= q
= value
;
1715 while (*q
&& !nasm_isspace(*q
))
1717 if (nasm_isspace(*q
)) {
1719 while (*q
&& nasm_isspace(*q
))
1724 while (*q
&& !nasm_isspace(*q
))
1726 if (nasm_isspace(*q
)) {
1728 while (*q
&& nasm_isspace(*q
))
1733 error(ERR_NONFATAL
, "`export' directive requires export name");
1742 while (*q
&& !nasm_isspace(*q
))
1744 if (nasm_isspace(*q
)) {
1746 while (*q
&& nasm_isspace(*q
))
1749 if (!nasm_stricmp(v
, "resident"))
1750 flags
|= EXPDEF_FLAG_RESIDENT
;
1751 else if (!nasm_stricmp(v
, "nodata"))
1752 flags
|= EXPDEF_FLAG_NODATA
;
1753 else if (!nasm_strnicmp(v
, "parm=", 5)) {
1755 flags
|= EXPDEF_MASK_PARMCNT
& readnum(v
+ 5, &err
);
1758 "value `%s' for `parm' is non-numeric", v
+ 5);
1763 ordinal
= readnum(v
, &err
);
1766 "unrecognised export qualifier `%s'", v
);
1769 flags
|= EXPDEF_FLAG_ORDINAL
;
1773 export
= *exptail
= nasm_malloc(sizeof(struct ExpDef
));
1774 exptail
= &export
->next
;
1775 export
->next
= NULL
;
1776 export
->extname
= nasm_strdup(extname
);
1777 export
->intname
= nasm_strdup(intname
);
1778 export
->ordinal
= ordinal
;
1779 export
->flags
= flags
;
1788 static int32_t obj_segbase(int32_t segment
)
1790 struct Segment
*seg
;
1793 * Find the segment in our list.
1795 for (seg
= seghead
; seg
; seg
= seg
->next
)
1796 if (seg
->index
== segment
- 1)
1801 * Might be an external with a default WRT.
1803 int32_t i
= segment
/ 2;
1804 struct ExtBack
*eb
= ebhead
;
1807 while (i
>= EXT_BLKSIZ
) {
1817 nasm_assert(pass0
== 0);
1818 /* Not available - can happen during optimization */
1822 switch (e
->defwrt_type
) {
1824 return segment
; /* fine */
1825 case DEFWRT_SEGMENT
:
1826 return e
->defwrt_ptr
.seg
->index
+ 1;
1828 return e
->defwrt_ptr
.grp
->index
+ 1;
1830 return NO_SEG
; /* can't tell what it is */
1834 return segment
; /* not one of ours - leave it alone */
1837 if (seg
->align
>= SEG_ABS
)
1838 return seg
->align
; /* absolute segment */
1840 return seg
->grp
->index
+ 1; /* grouped segment */
1842 return segment
; /* no special treatment */
1845 static void obj_filename(char *inname
, char *outname
, efunc lerror
)
1847 strcpy(obj_infile
, inname
);
1848 standard_extension(inname
, outname
, ".obj", lerror
);
1851 static void obj_write_file(int debuginfo
)
1853 struct Segment
*seg
, *entry_seg_ptr
= 0;
1854 struct FileName
*fn
;
1855 struct LineNumber
*ln
;
1857 struct Public
*pub
, *loc
;
1858 struct External
*ext
;
1860 struct ExpDef
*export
;
1865 * Write the THEADR module header.
1869 obj_name(orp
, obj_infile
);
1873 * Write the NASM boast comment.
1876 obj_rword(orp
, 0); /* comment type zero */
1877 obj_name(orp
, nasm_comment
);
1882 * Write the IMPDEF records, if any.
1884 for (imp
= imphead
; imp
; imp
= imp
->next
) {
1885 obj_rword(orp
, 0xA0); /* comment class A0 */
1886 obj_byte(orp
, 1); /* subfunction 1: IMPDEF */
1888 obj_byte(orp
, 0); /* import by name */
1890 obj_byte(orp
, 1); /* import by ordinal */
1891 obj_name(orp
, imp
->extname
);
1892 obj_name(orp
, imp
->libname
);
1894 obj_name(orp
, imp
->impname
);
1896 obj_word(orp
, imp
->impindex
);
1901 * Write the EXPDEF records, if any.
1903 for (export
= exphead
; export
; export
= export
->next
) {
1904 obj_rword(orp
, 0xA0); /* comment class A0 */
1905 obj_byte(orp
, 2); /* subfunction 2: EXPDEF */
1906 obj_byte(orp
, export
->flags
);
1907 obj_name(orp
, export
->extname
);
1908 obj_name(orp
, export
->intname
);
1909 if (export
->flags
& EXPDEF_FLAG_ORDINAL
)
1910 obj_word(orp
, export
->ordinal
);
1914 /* we're using extended OMF if we put in debug info */
1917 obj_byte(orp
, 0x40);
1918 obj_byte(orp
, dEXTENDED
);
1923 * Write the first LNAMES record, containing LNAME one, which
1924 * is null. Also initialize the LNAME counter.
1930 * Write some LNAMES for the segment names
1932 for (seg
= seghead
; seg
; seg
= seg
->next
) {
1933 orp
= obj_name(orp
, seg
->name
);
1935 orp
= obj_name(orp
, seg
->segclass
);
1937 orp
= obj_name(orp
, seg
->overlay
);
1941 * Write some LNAMES for the group names
1943 for (grp
= grphead
; grp
; grp
= grp
->next
) {
1944 orp
= obj_name(orp
, grp
->name
);
1950 * Write the SEGDEF records.
1953 for (seg
= seghead
; seg
; seg
= seg
->next
) {
1955 uint32_t seglen
= seg
->currentpos
;
1957 acbp
= (seg
->combine
<< 2); /* C field */
1960 acbp
|= 0x01; /* P bit is Use32 flag */
1961 else if (seglen
== 0x10000L
) {
1962 seglen
= 0; /* This special case may be needed for old linkers */
1963 acbp
|= 0x02; /* B bit */
1967 if (seg
->align
>= SEG_ABS
)
1968 /* acbp |= 0x00 */ ;
1969 else if (seg
->align
>= 4096) {
1970 if (seg
->align
> 4096)
1971 error(ERR_NONFATAL
, "segment `%s' requires more alignment"
1972 " than OBJ format supports", seg
->name
);
1973 acbp
|= 0xC0; /* PharLap extension */
1974 } else if (seg
->align
>= 256) {
1976 } else if (seg
->align
>= 16) {
1978 } else if (seg
->align
>= 4) {
1980 } else if (seg
->align
>= 2) {
1985 obj_byte(orp
, acbp
);
1986 if (seg
->align
& SEG_ABS
) {
1987 obj_x(orp
, seg
->align
- SEG_ABS
); /* Frame */
1988 obj_byte(orp
, 0); /* Offset */
1991 obj_index(orp
, ++lname_idx
);
1992 obj_index(orp
, seg
->segclass
? ++lname_idx
: 1);
1993 obj_index(orp
, seg
->overlay
? ++lname_idx
: 1);
1998 * Write the GRPDEF records.
2001 for (grp
= grphead
; grp
; grp
= grp
->next
) {
2004 if (grp
->nindices
!= grp
->nentries
) {
2005 for (i
= grp
->nindices
; i
< grp
->nentries
; i
++) {
2006 error(ERR_NONFATAL
, "group `%s' contains undefined segment"
2007 " `%s'", grp
->name
, grp
->segs
[i
].name
);
2008 nasm_free(grp
->segs
[i
].name
);
2009 grp
->segs
[i
].name
= NULL
;
2012 obj_index(orp
, ++lname_idx
);
2013 for (i
= 0; i
< grp
->nindices
; i
++) {
2014 obj_byte(orp
, 0xFF);
2015 obj_index(orp
, grp
->segs
[i
].index
);
2021 * Write the PUBDEF records: first the ones in the segments,
2022 * then the far-absolutes.
2025 orp
->ori
= ori_pubdef
;
2026 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2027 orp
->parm
[0] = seg
->grp
? seg
->grp
->obj_index
: 0;
2028 orp
->parm
[1] = seg
->obj_index
;
2029 for (pub
= seg
->pubhead
; pub
; pub
= pub
->next
) {
2030 orp
= obj_name(orp
, pub
->name
);
2031 orp
= obj_x(orp
, pub
->offset
);
2032 orp
= obj_byte(orp
, 0); /* type index */
2039 for (pub
= fpubhead
; pub
; pub
= pub
->next
) { /* pub-crawl :-) */
2040 if (orp
->parm
[2] != (uint32_t)pub
->segment
) {
2042 orp
->parm
[2] = pub
->segment
;
2044 orp
= obj_name(orp
, pub
->name
);
2045 orp
= obj_x(orp
, pub
->offset
);
2046 orp
= obj_byte(orp
, 0); /* type index */
2052 * Write the EXTDEF and COMDEF records, in order.
2054 orp
->ori
= ori_null
;
2055 for (ext
= exthead
; ext
; ext
= ext
->next
) {
2056 if (ext
->commonsize
== 0) {
2057 if (orp
->type
!= EXTDEF
) {
2061 orp
= obj_name(orp
, ext
->name
);
2062 orp
= obj_index(orp
, 0);
2064 if (orp
->type
!= COMDEF
) {
2068 orp
= obj_name(orp
, ext
->name
);
2069 orp
= obj_index(orp
, 0);
2070 if (ext
->commonelem
) {
2071 orp
= obj_byte(orp
, 0x61); /* far communal */
2072 orp
= obj_value(orp
, (ext
->commonsize
/ ext
->commonelem
));
2073 orp
= obj_value(orp
, ext
->commonelem
);
2075 orp
= obj_byte(orp
, 0x62); /* near communal */
2076 orp
= obj_value(orp
, ext
->commonsize
);
2084 * Write a COMENT record stating that the linker's first pass
2085 * may stop processing at this point. Exception is if our
2086 * MODEND record specifies a start point, in which case,
2087 * according to some variants of the documentation, this COMENT
2088 * should be omitted. So we'll omit it just in case.
2089 * But, TASM puts it in all the time so if we are using
2090 * TASM debug stuff we are putting it in
2092 if (debuginfo
|| obj_entry_seg
== NO_SEG
) {
2094 obj_byte(orp
, 0x40);
2095 obj_byte(orp
, dLINKPASS
);
2101 * 1) put out the compiler type
2102 * 2) Put out the type info. The only type we are using is near label #19
2106 struct Array
*arrtmp
= arrhead
;
2108 obj_byte(orp
, 0x40);
2109 obj_byte(orp
, dCOMPDEF
);
2114 obj_byte(orp
, 0x40);
2115 obj_byte(orp
, dTYPEDEF
);
2116 obj_word(orp
, 0x18); /* type # for linking */
2117 obj_word(orp
, 6); /* size of type */
2118 obj_byte(orp
, 0x2a); /* absolute type for debugging */
2120 obj_byte(orp
, 0x40);
2121 obj_byte(orp
, dTYPEDEF
);
2122 obj_word(orp
, 0x19); /* type # for linking */
2123 obj_word(orp
, 0); /* size of type */
2124 obj_byte(orp
, 0x24); /* absolute type for debugging */
2125 obj_byte(orp
, 0); /* near/far specifier */
2127 obj_byte(orp
, 0x40);
2128 obj_byte(orp
, dTYPEDEF
);
2129 obj_word(orp
, 0x1A); /* type # for linking */
2130 obj_word(orp
, 0); /* size of type */
2131 obj_byte(orp
, 0x24); /* absolute type for debugging */
2132 obj_byte(orp
, 1); /* near/far specifier */
2134 obj_byte(orp
, 0x40);
2135 obj_byte(orp
, dTYPEDEF
);
2136 obj_word(orp
, 0x1b); /* type # for linking */
2137 obj_word(orp
, 0); /* size of type */
2138 obj_byte(orp
, 0x23); /* absolute type for debugging */
2143 obj_byte(orp
, 0x40);
2144 obj_byte(orp
, dTYPEDEF
);
2145 obj_word(orp
, 0x1c); /* type # for linking */
2146 obj_word(orp
, 0); /* size of type */
2147 obj_byte(orp
, 0x23); /* absolute type for debugging */
2152 obj_byte(orp
, 0x40);
2153 obj_byte(orp
, dTYPEDEF
);
2154 obj_word(orp
, 0x1d); /* type # for linking */
2155 obj_word(orp
, 0); /* size of type */
2156 obj_byte(orp
, 0x23); /* absolute type for debugging */
2161 obj_byte(orp
, 0x40);
2162 obj_byte(orp
, dTYPEDEF
);
2163 obj_word(orp
, 0x1e); /* type # for linking */
2164 obj_word(orp
, 0); /* size of type */
2165 obj_byte(orp
, 0x23); /* absolute type for debugging */
2171 /* put out the array types */
2172 for (i
= ARRAYBOT
; i
< arrindex
; i
++) {
2173 obj_byte(orp
, 0x40);
2174 obj_byte(orp
, dTYPEDEF
);
2175 obj_word(orp
, i
); /* type # for linking */
2176 obj_word(orp
, arrtmp
->size
); /* size of type */
2177 obj_byte(orp
, 0x1A); /* absolute type for debugging (array) */
2178 obj_byte(orp
, arrtmp
->basetype
); /* base type */
2180 arrtmp
= arrtmp
->next
;
2184 * write out line number info with a LINNUM record
2185 * switch records when we switch segments, and output the
2186 * file in a pseudo-TASM fashion. The record switch is naive; that
2187 * is that one file may have many records for the same segment
2188 * if there are lots of segment switches
2190 if (fnhead
&& debuginfo
) {
2191 seg
= fnhead
->lnhead
->segment
;
2193 for (fn
= fnhead
; fn
; fn
= fn
->next
) {
2194 /* write out current file name */
2196 orp
->ori
= ori_null
;
2197 obj_byte(orp
, 0x40);
2198 obj_byte(orp
, dFILNAME
);
2200 obj_name(orp
, fn
->name
);
2204 /* write out line numbers this file */
2207 orp
->ori
= ori_linnum
;
2208 for (ln
= fn
->lnhead
; ln
; ln
= ln
->next
) {
2209 if (seg
!= ln
->segment
) {
2210 /* if we get here have to flush the buffer and start
2211 * a new record for a new segment
2216 orp
->parm
[0] = seg
->grp
? seg
->grp
->obj_index
: 0;
2217 orp
->parm
[1] = seg
->obj_index
;
2218 orp
= obj_word(orp
, ln
->lineno
);
2219 orp
= obj_x(orp
, ln
->offset
);
2226 * we are going to locate the entry point segment now
2227 * rather than wait until the MODEND record, because,
2228 * then we can output a special symbol to tell where the
2232 if (obj_entry_seg
!= NO_SEG
) {
2233 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2234 if (seg
->index
== obj_entry_seg
) {
2235 entry_seg_ptr
= seg
;
2240 error(ERR_NONFATAL
, "entry point is not in this module");
2244 * get ready to put out symbol records
2247 orp
->ori
= ori_local
;
2250 * put out a symbol for the entry point
2251 * no dots in this symbol, because, borland does
2252 * not (officially) support dots in label names
2253 * and I don't know what various versions of TLINK will do
2255 if (debuginfo
&& obj_entry_seg
!= NO_SEG
) {
2256 orp
= obj_name(orp
, "start_of_program");
2257 orp
= obj_word(orp
, 0x19); /* type: near label */
2258 orp
= obj_index(orp
, seg
->grp
? seg
->grp
->obj_index
: 0);
2259 orp
= obj_index(orp
, seg
->obj_index
);
2260 orp
= obj_x(orp
, obj_entry_ofs
);
2265 * put out the local labels
2267 for (seg
= seghead
; seg
&& debuginfo
; seg
= seg
->next
) {
2268 /* labels this seg */
2269 for (loc
= seg
->lochead
; loc
; loc
= loc
->next
) {
2270 orp
= obj_name(orp
, loc
->name
);
2271 orp
= obj_word(orp
, loc
->type
);
2272 orp
= obj_index(orp
, seg
->grp
? seg
->grp
->obj_index
: 0);
2273 orp
= obj_index(orp
, seg
->obj_index
);
2274 orp
= obj_x(orp
, loc
->offset
);
2282 * Write the LEDATA/FIXUPP pairs.
2284 for (seg
= seghead
; seg
; seg
= seg
->next
) {
2286 nasm_free(seg
->orp
);
2290 * Write the MODEND module end marker.
2292 orp
->type
= obj_use32
? MODE32
: MODEND
;
2293 orp
->ori
= ori_null
;
2294 if (entry_seg_ptr
) {
2295 orp
->type
= entry_seg_ptr
->use32
? MODE32
: MODEND
;
2296 obj_byte(orp
, 0xC1);
2297 seg
= entry_seg_ptr
;
2299 obj_byte(orp
, 0x10);
2300 obj_index(orp
, seg
->grp
->obj_index
);
2303 * the below changed to prevent TLINK crashing.
2304 * Previous more efficient version read:
2306 * obj_byte (orp, 0x50);
2308 obj_byte(orp
, 0x00);
2309 obj_index(orp
, seg
->obj_index
);
2311 obj_index(orp
, seg
->obj_index
);
2312 obj_x(orp
, obj_entry_ofs
);
2319 static void obj_fwrite(ObjRecord
* orp
)
2321 unsigned int cksum
, len
;
2325 if (orp
->x_size
== 32)
2328 len
= orp
->committed
+ 1;
2329 cksum
+= (len
& 0xFF) + ((len
>> 8) & 0xFF);
2330 fwriteint16_t(len
, ofp
);
2331 fwrite(orp
->buf
, 1, len
- 1, ofp
);
2332 for (ptr
= orp
->buf
; --len
; ptr
++)
2334 fputc((-cksum
) & 0xFF, ofp
);
2337 extern macros_t obj_stdmac
[];
2339 void dbgbi_init(struct ofmt
*of
, void *id
, FILE * fp
, efunc error
)
2348 arrindex
= ARRAYBOT
;
2352 static void dbgbi_cleanup(void)
2354 struct Segment
*segtmp
;
2356 struct FileName
*fntemp
= fnhead
;
2357 while (fnhead
->lnhead
) {
2358 struct LineNumber
*lntemp
= fnhead
->lnhead
;
2359 fnhead
->lnhead
= lntemp
->next
;
2362 fnhead
= fnhead
->next
;
2363 nasm_free(fntemp
->name
);
2366 for (segtmp
= seghead
; segtmp
; segtmp
= segtmp
->next
) {
2367 while (segtmp
->lochead
) {
2368 struct Public
*loctmp
= segtmp
->lochead
;
2369 segtmp
->lochead
= loctmp
->next
;
2370 nasm_free(loctmp
->name
);
2375 struct Array
*arrtmp
= arrhead
;
2376 arrhead
= arrhead
->next
;
2381 static void dbgbi_linnum(const char *lnfname
, int32_t lineno
, int32_t segto
)
2383 struct FileName
*fn
;
2384 struct LineNumber
*ln
;
2385 struct Segment
*seg
;
2387 if (segto
== NO_SEG
)
2391 * If `any_segs' is still false, we must define a default
2395 int tempint
; /* ignored */
2396 if (segto
!= obj_segment("__NASMDEFSEG", 2, &tempint
))
2397 error(ERR_PANIC
, "strange segment conditions in OBJ driver");
2401 * Find the segment we are targetting.
2403 for (seg
= seghead
; seg
; seg
= seg
->next
)
2404 if (seg
->index
== segto
)
2407 error(ERR_PANIC
, "lineno directed to nonexistent segment?");
2409 /* for (fn = fnhead; fn; fn = fnhead->next) */
2410 for (fn
= fnhead
; fn
; fn
= fn
->next
) /* fbk - Austin Lunnen - John Fine */
2411 if (!nasm_stricmp(lnfname
, fn
->name
))
2414 fn
= nasm_malloc(sizeof(*fn
));
2415 fn
->name
= nasm_malloc(strlen(lnfname
) + 1);
2416 strcpy(fn
->name
, lnfname
);
2418 fn
->lntail
= &fn
->lnhead
;
2423 ln
= nasm_malloc(sizeof(*ln
));
2425 ln
->offset
= seg
->currentpos
;
2426 ln
->lineno
= lineno
;
2429 fn
->lntail
= &ln
->next
;
2432 static void dbgbi_deflabel(char *name
, int32_t segment
,
2433 int64_t offset
, int is_global
, char *special
)
2435 struct Segment
*seg
;
2440 * If it's a special-retry from pass two, discard it.
2446 * First check for the double-period, signifying something
2449 if (name
[0] == '.' && name
[1] == '.' && name
[2] != '@') {
2456 if (obj_seg_needs_update
) {
2458 } else if (obj_grp_needs_update
) {
2461 if (segment
< SEG_ABS
&& segment
!= NO_SEG
&& segment
% 2)
2464 if (segment
>= SEG_ABS
|| segment
== NO_SEG
) {
2469 * If `any_segs' is still false, we might need to define a
2470 * default segment, if they're trying to declare a label in
2471 * `first_seg'. But the label should exist due to a prior
2472 * call to obj_deflabel so we can skip that.
2475 for (seg
= seghead
; seg
; seg
= seg
->next
)
2476 if (seg
->index
== segment
) {
2477 struct Public
*loc
= nasm_malloc(sizeof(*loc
));
2479 * Case (ii). Maybe MODPUB someday?
2481 last_defined
= *seg
->loctail
= loc
;
2482 seg
->loctail
= &loc
->next
;
2484 loc
->name
= nasm_strdup(name
);
2485 loc
->offset
= offset
;
2488 static void dbgbi_typevalue(int32_t type
)
2491 int elem
= TYM_ELEMENTS(type
);
2492 type
= TYM_TYPE(type
);
2499 last_defined
->type
= 8; /* uint8_t */
2503 last_defined
->type
= 10; /* unsigned word */
2507 last_defined
->type
= 12; /* unsigned dword */
2511 last_defined
->type
= 14; /* float */
2515 last_defined
->type
= 15; /* qword */
2519 last_defined
->type
= 16; /* TBYTE */
2523 last_defined
->type
= 0x19; /*label */
2529 struct Array
*arrtmp
= nasm_malloc(sizeof(*arrtmp
));
2530 int vtype
= last_defined
->type
;
2531 arrtmp
->size
= vsize
* elem
;
2532 arrtmp
->basetype
= vtype
;
2533 arrtmp
->next
= NULL
;
2534 last_defined
->type
= arrindex
++;
2536 arrtail
= &(arrtmp
->next
);
2538 last_defined
= NULL
;
2540 static void dbgbi_output(int output_type
, void *param
)
2545 static struct dfmt borland_debug_form
= {
2546 "Borland Debug Records",
2557 static struct dfmt
*borland_debug_arr
[3] = {
2558 &borland_debug_form
,
2563 struct ofmt of_obj
= {
2564 "MS-DOS 16-bit/32-bit OMF object files",
2568 &borland_debug_form
,