开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
outobj.c
资源名称：nasm-0.98.zip　[点击查看]
上传用户：yuppie_zhu
上传日期：2007-01-08
资源大小：535k
文件大小：66k
源码类别：

编译器/解释器

开发平台：

C/C++

outobj.c：源码内容
  1. /* outobj.c output routines for the Netwide Assembler to produce
  2.  * .OBJ object files
  3.  *
  4.  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
  5.  * Julian Hall. All rights reserved. The software is
  6.  * redistributable under the licence given in the file "Licence"
  7.  * distributed in the NASM archive.
  8.  */
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <ctype.h>
  15. #include "nasm.h"
  16. #include "nasmlib.h"
  17. #include "outform.h"
  19. #ifdef OF_OBJ
  21. /*
  22.  * outobj.c is divided into two sections.  The first section is low level
  23.  * routines for creating obj records;  It has nearly zero NASM specific
  24.  * code.  The second section is high level routines for processing calls and
  25.  * data structures from the rest of NASM into obj format.
  26.  *
  27.  * It should be easy (though not zero work) to lift the first section out for
  28.  * use as an obj file writer for some other assembler or compiler.
  29.  */
  31. /*
  32.  * These routines are built around the ObjRecord data struture.  An ObjRecord
  33.  * holds an object file record that may be under construction or complete.
  34.  *
  35.  * A major function of these routines is to support continuation of an obj
  36.  * record into the next record when the maximum record size is exceeded.  The
  37.  * high level code does not need to worry about where the record breaks occur.
  38.  * It does need to do some minor extra steps to make the automatic continuation
  39.  * work.  Those steps may be skipped for records where the high level knows no
  40.  * continuation could be required.
  41.  *
  42.  * 1) An ObjRecord is allocated and cleared by obj_new, or an existing ObjRecord
  43.  *    is cleared by obj_clear.
  44.  *
  45.  * 2) The caller should fill in .type.
  46.  *
  47.  * 3) If the record is continuable and there is processing that must be done at
  48.  *    the start of each record then the caller should fill in .ori with the
  49.  *    address of the record initializer routine.
  50.  *
  51.  * 4) If the record is continuable and it should be saved (rather than emitted
  52.  *    immediately) as each record is done, the caller should set .up to be a
  53.  *    pointer to a location in which the caller keeps the master pointer to the
  54.  *    ObjRecord.  When the record is continued, the obj_bump routine will then
  55.  *    allocate a new ObjRecord structure and update the master pointer.
  56.  *
  57.  * 5) If the .ori field was used then the caller should fill in the .parm with
  58.  *    any data required by the initializer.
  59.  *
  60.  * 6) The caller uses the routines: obj_byte, obj_word, obj_rword, obj_dword,
  61.  *    obj_x, obj_index, obj_value and obj_name to fill in the various kinds of
  62.  *    data required for this record.
  63.  *
  64.  * 7) If the record is continuable, the caller should call obj_commit at each
  65.  *    point where breaking the record is permitted.
  66.  *
  67.  * 8) To write out the record, the caller should call obj_emit2.  If the
  68.  *    caller has called obj_commit for all data written then he can get slightly
  69.  *    faster code by calling obj_emit instead of obj_emit2.
  70.  *
  71.  * Most of these routines return an ObjRecord pointer.  This will be the input
  72.  * pointer most of the time and will be the new location if the ObjRecord
  73.  * moved as a result of the call.  The caller may ignore the return value in
  74.  * three cases:  It is a "Never Reallocates" routine;  or  The caller knows
  75.  * continuation is not possible;  or  The caller uses the master pointer for the
  76.  * next operation.
  77.  */
  79. #define RECORD_MAX 1024 /* maximum size of _any_ record */
  80. #define OBJ_PARMS  3 /* maximum .parm used by any .ori routine */
  82. #define FIX_08_LOW      0x8000 /* location type for various fixup subrecords */
  83. #define FIX_16_OFFSET   0x8400
  84. #define FIX_16_SELECTOR 0x8800
  85. #define FIX_32_POINTER  0x8C00
  86. #define FIX_08_HIGH     0x9000
  87. #define FIX_32_OFFSET   0xA400
  88. #define FIX_48_POINTER  0xAC00
  90. enum RecordID {        /* record ID codes */
  92.     THEADR = 0x80,        /* module header */
  93.     COMENT = 0x88,        /* comment record */
  95.     LINNUM = 0x94,                     /* line number record */
  96.     LNAMES = 0x96,        /* list of names */
  98.     SEGDEF = 0x98,        /* segment definition */
  99.     GRPDEF = 0x9A,        /* group definition */
  100.     EXTDEF = 0x8C,        /* external definition */
  101.     PUBDEF = 0x90,        /* public definition */
  102.     COMDEF = 0xB0,        /* common definition */
  104.     LEDATA = 0xA0,        /* logical enumerated data */
  105.     FIXUPP = 0x9C,        /* fixups (relocations) */
  107.     MODEND = 0x8A        /* module end */
  108. };
  110. enum ComentID {                        /* ID codes for comment records */
  112.      dEXTENDED = 0xA1,                 /* tells that we are using translator-specific extensions */
  113.      dLINKPASS = 0xA2,                 /* link pass 2 marker */
  114.      dTYPEDEF = 0xE3,                  /* define a type */
  115.      dSYM = 0xE6,                      /* symbol debug record */
  116.      dFILNAME = 0xE8,                  /* file name record */
  117.      dCOMPDEF = 0xEA                   /* compiler type info */
  119. };
  121. typedef struct ObjRecord ObjRecord;
  122. typedef void ORI(ObjRecord *orp);
  124. struct ObjRecord {
  125.     ORI           *ori; /* Initialization routine           */
  126.     int            used; /* Current data size                */
  127.     int            committed; /* Data size at last boundary       */
  128.     int            x_size; /* (see obj_x)                      */
  129.     unsigned int   type; /* Record type                      */
  130.     ObjRecord     *child; /* Associated record below this one */
  131.     ObjRecord    **up; /* Master pointer to this ObjRecord */
  132.     ObjRecord     *back; /* Previous part of this record     */
  133.     unsigned long  parm[OBJ_PARMS]; /* Parameters for ori routine       */
  134.     unsigned char  buf[RECORD_MAX];
  135. };
  137. static void obj_fwrite(ObjRecord *orp);
  138. static void ori_ledata(ObjRecord *orp);
  139. static void ori_pubdef(ObjRecord *orp);
  140. static void ori_null(ObjRecord *orp);
  141. static ObjRecord *obj_commit(ObjRecord *orp);
  142. static void obj_write_fixup (ObjRecord *orp, int bytes,
  143.      int segrel, long seg, long wrt);
  145. static int obj_uppercase; /* Flag: all names in uppercase */
  147. /*
  148.  * Clear an ObjRecord structure.  (Never reallocates).
  149.  * To simplify reuse of ObjRecord's, .type, .ori and .parm are not cleared.
  150.  */
  151. static ObjRecord *obj_clear(ObjRecord *orp) 
  152. {
  153.     orp->used = 0;
  154.     orp->committed = 0;
  155.     orp->x_size = 0;
  156.     orp->child = NULL;
  157.     orp->up = NULL;
  158.     orp->back = NULL;
  159.     return (orp);
  160. }
  162. /*
  163.  * Emit an ObjRecord structure.  (Never reallocates).
  164.  * The record is written out preceeded (recursively) by its previous part (if
  165.  * any) and followed (recursively) by its child (if any).
  166.  * The previous part and the child are freed.  The main ObjRecord is cleared,
  167.  * not freed.
  168.  */
  169. static ObjRecord *obj_emit(ObjRecord *orp) 
  170. {
  171.     if (orp->back) {
  172. obj_emit(orp->back);
  173. nasm_free(orp->back);
  174.     }
  176.     if (orp->committed)
  177. obj_fwrite(orp);
  179.     if (orp->child) {
  180. obj_emit(orp->child);
  181. nasm_free(orp->child);
  182.     }
  184.     return (obj_clear(orp));
  185. }
  187. /*
  188.  * Commit and Emit a record.  (Never reallocates).
  189.  */
  190. static ObjRecord *obj_emit2(ObjRecord *orp) 
  191. {
  192.     obj_commit(orp);
  193.     return (obj_emit(orp));
  194. }
  196. /*
  197.  * Allocate and clear a new ObjRecord;  Also sets .ori to ori_null
  198.  */
  199. static ObjRecord *obj_new(void) 
  200. {
  201.     ObjRecord *orp;
  202.     
  203.     orp = obj_clear( nasm_malloc(sizeof(ObjRecord)) );
  204.     orp->ori = ori_null;
  205.     return (orp);
  206. }
  207.     
  208. /*
  209.  * Advance to the next record because the existing one is full or its x_size
  210.  * is incompatible.
  211.  * Any uncommited data is moved into the next record.
  212.  */
  213. static ObjRecord *obj_bump(ObjRecord *orp) 
  214. {
  215.     ObjRecord *nxt;
  216.     int used = orp->used;
  217.     int committed = orp->committed;
  219.     if (orp->up) {
  220. *orp->up = nxt = obj_new();
  221. nxt->ori = orp->ori;
  222. nxt->type = orp->type;
  223. nxt->up = orp->up;
  224. nxt->back = orp;
  225. memcpy( nxt->parm, orp->parm, sizeof(orp->parm));
  226.     } else
  227. nxt = obj_emit(orp);
  229.     used -= committed;
  230.     if (used) {
  231. nxt->committed = 1;
  232. nxt->ori (nxt);
  233. nxt->committed = nxt->used;
  234. memcpy( nxt->buf + nxt->committed, orp->buf + committed, used);
  235. nxt->used = nxt->committed + used;
  236.     }
  238.     return (nxt);
  239. }
  241. /*
  242.  * Advance to the next record if necessary to allow the next field to fit.
  243.  */
  244. static ObjRecord *obj_check(ObjRecord *orp, int size) 
  245. {
  246.     if (orp->used + size > RECORD_MAX)
  247. orp = obj_bump(orp);
  249.     if (!orp->committed) {
  250. orp->committed = 1;
  251. orp->ori (orp);
  252. orp->committed = orp->used;
  253.     }
  255.     return (orp);
  256. }
  258. /*
  259.  * All data written so far is commited to the current record (won't be moved to
  260.  * the next record in case of continuation).
  261.  */
  262. static ObjRecord *obj_commit(ObjRecord *orp) 
  263. {
  264.     orp->committed = orp->used;
  265.     return (orp);
  266. }
  268. /*
  269.  * Write a byte
  270.  */
  271. static ObjRecord *obj_byte(ObjRecord *orp, unsigned char val) 
  272. {
  273.     orp = obj_check(orp, 1);
  274.     orp->buf[orp->used] = val;
  275.     orp->used++;
  276.     return (orp);
  277. }
  279. /*
  280.  * Write a word
  281.  */
  282. static ObjRecord *obj_word(ObjRecord *orp, unsigned int val) 
  283. {
  284.     orp = obj_check(orp, 2);
  285.     orp->buf[orp->used] = val;
  286.     orp->buf[orp->used+1] = val >> 8;
  287.     orp->used += 2;
  288.     return (orp);
  289. }
  291. /*
  292.  * Write a reversed word
  293.  */
  294. static ObjRecord *obj_rword(ObjRecord *orp, unsigned int val) 
  295. {
  296.     orp = obj_check(orp, 2);
  297.     orp->buf[orp->used] = val >> 8;
  298.     orp->buf[orp->used+1] = val;
  299.     orp->used += 2;
  300.     return (orp);
  301. }
  303. /*
  304.  * Write a dword
  305.  */
  306. static ObjRecord *obj_dword(ObjRecord *orp, unsigned long val) 
  307. {
  308.     orp = obj_check(orp, 4);
  309.     orp->buf[orp->used] = val;
  310.     orp->buf[orp->used+1] = val >> 8;
  311.     orp->buf[orp->used+2] = val >> 16;
  312.     orp->buf[orp->used+3] = val >> 24;
  313.     orp->used += 4;
  314.     return (orp);
  315. }
  317. /*
  318.  * All fields of "size x" in one obj record must be the same size (either 16
  319.  * bits or 32 bits).  There is a one bit flag in each record which specifies
  320.  * which.
  321.  * This routine is used to force the current record to have the desired
  322.  * x_size.  x_size is normally automatic (using obj_x), so that this
  323.  * routine should be used outside obj_x, only to provide compatibility with
  324.  * linkers that have bugs in their processing of the size bit.
  325.  */
  327. static ObjRecord *obj_force(ObjRecord *orp, int x)
  328. {
  329.     if (orp->x_size == (x^48))
  330. orp = obj_bump(orp);
  331.     orp->x_size = x;
  332. return (orp);
  333. }
  335. /*
  336.  * This routine writes a field of size x.  The caller does not need to worry at
  337.  * all about whether 16-bits or 32-bits are required.
  338.  */
  339. static ObjRecord *obj_x(ObjRecord *orp, unsigned long val) 
  340. {
  341.     if (orp->type & 1)
  342. orp->x_size = 32;
  343.     if (val > 0xFFFF)
  344. orp = obj_force(orp, 32);
  345.     if (orp->x_size == 32)
  346. return (obj_dword(orp, val));
  347.     orp->x_size = 16;
  348.     return (obj_word(orp, val));
  349. }
  351. /*
  352.  * Writes an index
  353.  */
  354. static ObjRecord *obj_index(ObjRecord *orp, unsigned int val) 
  355. {
  356.     if (val < 128)
  357. return ( obj_byte(orp, val) );
  358.     return (obj_word(orp, (val>>8) | (val<<8) | 0x80));
  359. }
  361. /*
  362.  * Writes a variable length value
  363.  */
  364. static ObjRecord *obj_value(ObjRecord *orp, unsigned long val) 
  365. {
  366.     if (val <= 128)
  367. return ( obj_byte(orp, val) );
  368.     if (val <= 0xFFFF) {
  369. orp = obj_byte(orp, 129);
  370. return ( obj_word(orp, val) );
  371.     }
  372.     if (val <= 0xFFFFFF)
  373. return ( obj_dword(orp, (val<<8) + 132 ) );
  374.     orp = obj_byte(orp, 136);
  375.     return ( obj_dword(orp, val) );
  376. }
  378. /*
  379.  * Writes a counted string
  380.  */
  381. static ObjRecord *obj_name(ObjRecord *orp, char *name) 
  382. {
  383.     int len = strlen(name);
  384.     unsigned char *ptr;
  386.     orp = obj_check(orp, len+1);
  387.     ptr = orp->buf + orp->used;
  388.     *ptr++ = len;
  389.     orp->used += len+1;
  390.     if (obj_uppercase)
  391. while (--len >= 0) {
  392.     *ptr++ = toupper(*name);
  393.     name++;
  394.     } else
  395. memcpy(ptr, name, len);
  396.     return (orp);
  397. }
  399. /*
  400.  * Initializer for an LEDATA record.
  401.  * parm[0] = offset
  402.  * parm[1] = segment index
  403.  * During the use of a LEDATA ObjRecord, parm[0] is constantly updated to
  404.  * represent the offset that would be required if the record were split at the
  405.  * last commit point.
  406.  * parm[2] is a copy of parm[0] as it was when the current record was initted.
  407.  */
  408. static void ori_ledata(ObjRecord *orp) 
  409. {
  410.     obj_index (orp, orp->parm[1]);
  411.     orp->parm[2] = orp->parm[0];
  412.     obj_x (orp, orp->parm[0]);
  413. }
  415. /*
  416.  * Initializer for a PUBDEF record.
  417.  * parm[0] = group index
  418.  * parm[1] = segment index
  419.  * parm[2] = frame (only used when both indexes are zero)
  420.  */
  421. static void ori_pubdef(ObjRecord *orp) 
  422. {
  423.     obj_index (orp, orp->parm[0]);
  424.     obj_index (orp, orp->parm[1]);
  425.     if ( !(orp->parm[0] | orp->parm[1]) )
  426. obj_word (orp, orp->parm[2]);
  427. }
  429. /*
  430.  * Initializer for a LINNUM record.
  431.  * parm[0] = group index
  432.  * parm[1] = segment index
  433.  */
  434. static void ori_linnum(ObjRecord *orp) 
  435. {
  436.     obj_index (orp, orp->parm[0]);
  437.     obj_index (orp, orp->parm[1]);
  438. }
  439. /*
  440.  * Initializer for a local vars record.
  441.  */
  442. static void ori_local(ObjRecord *orp) 
  443. {
  444.     obj_byte (orp, 0x40);
  445.     obj_byte (orp, dSYM);
  446. }
  448. /*
  449.  * Null initializer for records that continue without any header info
  450.  */
  451. static void ori_null(ObjRecord *orp) 
  452. {
  453.     (void) orp;  /* Do nothing */
  454. }
  456. /*
  457.  * This concludes the low level section of outobj.c
  458.  */
  460. static char obj_infile[FILENAME_MAX];
  462. static efunc error;
  463. static evalfunc evaluate;
  464. static ldfunc deflabel;
  465. static FILE *ofp;
  466. static long first_seg;
  467. static int any_segs;
  468. static int passtwo;
  469. static int arrindex;
  471. #define GROUP_MAX 256        /* we won't _realistically_ have more
  472. * than this many segs in a group */
  473. #define EXT_BLKSIZ 256        /* block size for externals list */
  475. struct Segment;        /* need to know these structs exist */
  476. struct Group;
  478. struct LineNumber {
  479.     struct LineNumber *next;
  480.     struct Segment *segment;
  481.     long offset;
  482.     long lineno;
  483. };
  485. static struct FileName {
  486.     struct FileName *next;
  487.     char *name;
  488.     struct LineNumber *lnhead, **lntail;
  489.     int index;
  490. } *fnhead, **fntail;
  492. static struct Array {
  493.     struct Array *next;
  494.     unsigned size;
  495.     int basetype;
  496. } *arrhead, **arrtail;
  498. #define ARRAYBOT 31 /* magic number  for first array index */
  501. static struct Public {
  502.     struct Public *next;
  503.     char *name;
  504.     long offset;
  505.     long segment;        /* only if it's far-absolute */
  506.     int type;                          /* only for local debug syms */
  507. } *fpubhead, **fpubtail, *last_defined;
  509. static struct External {
  510.     struct External *next;
  511.     char *name;
  512.     long commonsize;
  513.     long commonelem;        /* element size if FAR, else zero */
  514.     int index;        /* OBJ-file external index */
  515.     enum {
  516. DEFWRT_NONE,        /* no unusual default-WRT */
  517. DEFWRT_STRING,        /* a string we don't yet understand */
  518. DEFWRT_SEGMENT,        /* a segment */
  519. DEFWRT_GROUP        /* a group */
  520.     } defwrt_type;
  521.     union {
  522. char *string;
  523. struct Segment *seg;
  524. struct Group *grp;
  525.     } defwrt_ptr;
  526.     struct External *next_dws;        /* next with DEFWRT_STRING */
  527. } *exthead, **exttail, *dws;
  529. static int externals;
  531. static struct ExtBack {
  532.     struct ExtBack *next;
  533.     struct External *exts[EXT_BLKSIZ];
  534. } *ebhead, **ebtail;
  536. static struct Segment {
  537.     struct Segment *next;
  538.     long index;        /* the NASM segment id */
  539.     long obj_index;        /* the OBJ-file segment index */
  540.     struct Group *grp;        /* the group it belongs to */
  541.     unsigned long currentpos;
  542.     long align;        /* can be SEG_ABS + absolute addr */
  543.     enum {
  544. CMB_PRIVATE = 0,
  545. CMB_PUBLIC = 2,
  546. CMB_STACK = 5,
  547. CMB_COMMON = 6
  548.     } combine;
  549.     long use32;        /* is this segment 32-bit? */
  550.     struct Public *pubhead, **pubtail, *lochead, **loctail;
  551.     char *name;
  552.     char *segclass, *overlay;        /* `class' is a C++ keyword :-) */
  553.     ObjRecord *orp;
  554. } *seghead, **segtail, *obj_seg_needs_update;
  556. static struct Group {
  557.     struct Group *next;
  558.     char *name;
  559.     long index;        /* NASM segment id */
  560.     long obj_index;        /* OBJ-file group index */
  561.     long nentries;        /* number of elements... */
  562.     long nindices;        /* ...and number of index elts... */
  563.     union {
  564. long index;
  565. char *name;
  566.     } segs[GROUP_MAX];        /* ...in this */
  567. } *grphead, **grptail, *obj_grp_needs_update;
  569. static struct ImpDef {
  570.     struct ImpDef *next;
  571.     char *extname;
  572.     char *libname;
  573.     unsigned int impindex;
  574.     char *impname;
  575. } *imphead, **imptail;
  577. static struct ExpDef {
  578.     struct ExpDef *next;
  579.     char *intname;
  580.     char *extname;
  581.     unsigned int ordinal;
  582.     int flags;
  583. } *exphead, **exptail;
  585. #define EXPDEF_FLAG_ORDINAL  0x80
  586. #define EXPDEF_FLAG_RESIDENT 0x40
  587. #define EXPDEF_FLAG_NODATA   0x20
  588. #define EXPDEF_MASK_PARMCNT  0x1F
  590. static long obj_entry_seg, obj_entry_ofs;
  592. struct ofmt of_obj;
  594. static long obj_segment (char *, int, int *);
  595. static void obj_write_file(int debuginfo);
  596. static int obj_directive (char *, char *, int);
  598. static void obj_init (FILE *fp, efunc errfunc, ldfunc ldef, evalfunc eval) 
  599. {
  600.     ofp = fp;
  601.     error = errfunc;
  602.     evaluate = eval;
  603.     deflabel = ldef;
  604.     first_seg = seg_alloc();
  605.     any_segs = FALSE;
  606.     fpubhead = NULL;
  607.     fpubtail = &fpubhead;
  608.     exthead = NULL;
  609.     exttail = &exthead;
  610.     imphead = NULL;
  611.     imptail = &imphead;
  612.     exphead = NULL;
  613.     exptail = &exphead;
  614.     dws = NULL;
  615.     externals = 0;
  616.     ebhead = NULL;
  617.     ebtail = &ebhead;
  618.     seghead = obj_seg_needs_update = NULL;
  619.     segtail = &seghead;
  620.     grphead = obj_grp_needs_update = NULL;
  621.     grptail = &grphead;
  622.     obj_entry_seg = NO_SEG;
  623.     obj_uppercase = FALSE;
  624.     passtwo = 0;
  626.     of_obj.current_dfmt->init (&of_obj,NULL,fp,errfunc);
  627. }
  629. static int obj_set_info(enum geninfo type, char **val)
  630. {
  631.     (void) type;
  632.     (void) val;
  634.     return 0;
  635. }
  636. static void obj_cleanup (int debuginfo) 
  637. {
  638.     obj_write_file(debuginfo);
  639.     of_obj.current_dfmt->cleanup();
  640.     fclose (ofp);
  641.     while (seghead) {
  642. struct Segment *segtmp = seghead;
  643. seghead = seghead->next;
  644. while (segtmp->pubhead) {
  645.     struct Public *pubtmp = segtmp->pubhead;
  646.     segtmp->pubhead = pubtmp->next;
  647.     nasm_free (pubtmp->name);
  648.     nasm_free (pubtmp);
  649. }
  650. nasm_free (segtmp->segclass);
  651. nasm_free (segtmp->overlay);
  652. nasm_free (segtmp);
  653.     }
  654.     while (fpubhead) {
  655. struct Public *pubtmp = fpubhead;
  656. fpubhead = fpubhead->next;
  657. nasm_free (pubtmp->name);
  658. nasm_free (pubtmp);
  659.     }
  660.     while (exthead) {
  661. struct External *exttmp = exthead;
  662. exthead = exthead->next;
  663. nasm_free (exttmp);
  664.     }
  665.     while (imphead) {
  666. struct ImpDef *imptmp = imphead;
  667. imphead = imphead->next;
  668. nasm_free (imptmp->extname);
  669. nasm_free (imptmp->libname);
  670. nasm_free (imptmp->impname);   /* nasm_free won't mind if it's NULL */
  671. nasm_free (imptmp);
  672.     }
  673.     while (exphead) {
  674. struct ExpDef *exptmp = exphead;
  675. exphead = exphead->next;
  676. nasm_free (exptmp->extname);
  677. nasm_free (exptmp->intname);
  678. nasm_free (exptmp);
  679.     }
  680.     while (ebhead) {
  681. struct ExtBack *ebtmp = ebhead;
  682. ebhead = ebhead->next;
  683. nasm_free (ebtmp);
  684.     }
  685.     while (grphead) {
  686. struct Group *grptmp = grphead;
  687. grphead = grphead->next;
  688. nasm_free (grptmp);
  689.     }
  690. }
  692. static void obj_ext_set_defwrt (struct External *ext, char *id) 
  693. {
  694.     struct Segment *seg;
  695.     struct Group *grp;
  697.     for (seg = seghead; seg; seg = seg->next)
  698. if (!strcmp(seg->name, id)) {
  699.     ext->defwrt_type = DEFWRT_SEGMENT;
  700.     ext->defwrt_ptr.seg = seg;
  701.     nasm_free (id);
  702.     return;
  703. }
  705.     for (grp = grphead; grp; grp = grp->next)
  706. if (!strcmp(grp->name, id)) {
  707.     ext->defwrt_type = DEFWRT_GROUP;
  708.     ext->defwrt_ptr.grp = grp;
  709.     nasm_free (id);
  710.     return;
  711. }
  713.     ext->defwrt_type = DEFWRT_STRING;
  714.     ext->defwrt_ptr.string = id;
  715.     ext->next_dws = dws;
  716.     dws = ext;
  717. }
  719. static void obj_deflabel (char *name, long segment,
  720.   long offset, int is_global, char *special) 
  721. {
  722.     /*
  723.      * We have three cases:
  724.      *
  725.      * (i) `segment' is a segment-base. If so, set the name field
  726.      * for the segment or group structure it refers to, and then
  727.      * return.
  728.      *
  729.      * (ii) `segment' is one of our segments, or a SEG_ABS segment.
  730.      * Save the label position for later output of a PUBDEF record.
  731.      * (Or a MODPUB, if we work out how.)
  732.      *
  733.      * (iii) `segment' is not one of our segments. Save the label
  734.      * position for later output of an EXTDEF, and also store a
  735.      * back-reference so that we can map later references to this
  736.      * segment number to the external index.
  737.      */
  738.     struct External *ext;
  739.     struct ExtBack *eb;
  740.     struct Segment *seg;
  741.     int i;
  742.     int used_special = FALSE;        /* have we used the special text? */
  744.     /*
  745.      * If it's a special-retry from pass two, discard it.
  746.      */
  747.     if (is_global == 3)
  748. return;
  750.     /*
  751.      * First check for the double-period, signifying something
  752.      * unusual.
  753.      */
  754.     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
  755. if (!strcmp(name, "..start")) {
  756.     obj_entry_seg = segment;
  757.     obj_entry_ofs = offset;
  758.     return;
  759. }
  760. error (ERR_NONFATAL, "unrecognised special symbol `%s'", name);
  761.     }
  763.     /*
  764.      * Case (i):
  765.      */
  766.     if (obj_seg_needs_update) {
  767. obj_seg_needs_update->name = name;
  768. return;
  769.     } else if (obj_grp_needs_update) {
  770. obj_grp_needs_update->name = name;
  771. return;
  772.     }
  773.     if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
  774. return;
  776.     if (segment >= SEG_ABS || segment == NO_SEG) {
  777. /*
  778.  * SEG_ABS subcase of (ii).
  779.  */
  780. if (is_global) {
  781.     struct Public *pub;
  783.     pub = *fpubtail = nasm_malloc(sizeof(*pub));
  784.     fpubtail = &pub->next;
  785.     pub->next = NULL;
  786.     pub->name = nasm_strdup(name);
  787.     pub->offset = offset;
  788.     pub->segment = (segment == NO_SEG ? 0 : segment & ~SEG_ABS);
  789. }
  790. if (special)
  791.     error(ERR_NONFATAL, "OBJ supports no special symbol features"
  792.   " for this symbol type");
  793. return;
  794.     }
  796.     /*
  797.      * If `any_segs' is still FALSE, we might need to define a
  798.      * default segment, if they're trying to declare a label in
  799.      * `first_seg'.
  800.      */
  801.     if (!any_segs && segment == first_seg) {
  802. int tempint;        /* ignored */
  803. if (segment != obj_segment("__NASMDEFSEG", 2, &tempint))
  804.     error (ERR_PANIC, "strange segment conditions in OBJ driver");
  805.     }
  807.     for (seg = seghead; seg && is_global; seg = seg->next)
  808. if (seg->index == segment) {
  809.     struct Public *loc = nasm_malloc (sizeof(*loc));
  810.     /*
  811.      * Case (ii). Maybe MODPUB someday?
  812.      */
  813.     *seg->pubtail = loc;
  814.     seg->pubtail = &loc->next;
  815.     loc->next = NULL;
  816.     loc->name = nasm_strdup(name);
  817.     loc->offset = offset;
  818.                   
  819.     if (special)
  820. error(ERR_NONFATAL, "OBJ supports no special symbol features"
  821.       " for this symbol type");
  822.     return;
  823. }
  825.     /*
  826.      * Case (iii).
  827.      */
  828.     if (is_global) {
  829.         ext = *exttail = nasm_malloc(sizeof(*ext));
  830.         ext->next = NULL;
  831.         exttail = &ext->next;
  832.         ext->name = name;
  833.         ext->defwrt_type = DEFWRT_NONE;
  834.         if (is_global == 2) {
  835.     ext->commonsize = offset;
  836.     ext->commonelem = 1;        /* default FAR */
  837.         } else
  838.     ext->commonsize = 0;
  839.     }
  840.     else
  841. return;
  843.     /*
  844.      * Now process the special text, if any, to find default-WRT
  845.      * specifications and common-variable element-size and near/far
  846.      * specifications.
  847.      */
  848.     while (special && *special) {
  849. used_special = TRUE;
  851. /*
  852.  * We might have a default-WRT specification.
  853.  */
  854. if (!nasm_strnicmp(special, "wrt", 3)) {
  855.     char *p;
  856.     int len;
  857.     special += 3;
  858.     special += strspn(special, " t");
  859.     p = nasm_strndup(special, len = strcspn(special, ":"));
  860.     obj_ext_set_defwrt (ext, p);
  861.     special += len;
  862.     if (*special && *special != ':')
  863. error(ERR_NONFATAL, "`:' expected in special symbol"
  864.       " text for `%s'", ext->name);
  865.     else if (*special == ':')
  866. special++;
  867. }
  869. /*
  870.  * The NEAR or FAR keywords specify nearness or
  871.  * farness. FAR gives default element size 1.
  872.  */
  873. if (!nasm_strnicmp(special, "far", 3)) {
  874.     if (ext->commonsize)
  875. ext->commonelem = 1;
  876.     else
  877. error(ERR_NONFATAL, "`%s': `far' keyword may only be applied"
  878.       " to common variablesn", ext->name);
  879.     special += 3;
  880.     special += strspn(special, " t");
  881. } else if (!nasm_strnicmp(special, "near", 4)) {
  882.     if (ext->commonsize)
  883. ext->commonelem = 0;
  884.     else
  885. error(ERR_NONFATAL, "`%s': `far' keyword may only be applied"
  886.       " to common variablesn", ext->name);
  887.     special += 4;
  888.     special += strspn(special, " t");
  889. }
  891. /*
  892.  * If it's a common, and anything else remains on the line
  893.  * before a further colon, evaluate it as an expression and
  894.  * use that as the element size. Forward references aren't
  895.  * allowed.
  896.  */
  897. if (*special == ':')
  898.     special++;
  899. else if (*special) {
  900.     if (ext->commonsize) {
  901. expr *e;
  902. struct tokenval tokval;
  904. stdscan_reset();
  905. stdscan_bufptr = special;
  906. tokval.t_type = TOKEN_INVALID;
  907. e = evaluate(stdscan, NULL, &tokval, NULL, 1, error, NULL);
  908. if (e) {
  909.     if (!is_simple(e))
  910. error (ERR_NONFATAL, "cannot use relocatable"
  911.        " expression as common-variable element size");
  912.     else
  913. ext->commonelem = reloc_value(e);
  914. }
  915. special = stdscan_bufptr;
  916.     } else {
  917. error (ERR_NONFATAL, "`%s': element-size specifications only"
  918.        " apply to common variables", ext->name);
  919. while (*special && *special != ':')
  920.     special++;
  921. if (*special == ':')
  922.     special++;
  923.     }
  924. }
  925.     }
  927.     i = segment/2;
  928.     eb = ebhead;
  929.     if (!eb) {
  930. eb = *ebtail = nasm_malloc(sizeof(*eb));
  931. eb->next = NULL;
  932. ebtail = &eb->next;
  933.     }
  934.     while (i > EXT_BLKSIZ) {
  935. if (eb && eb->next)
  936.     eb = eb->next;
  937. else {
  938.     eb = *ebtail = nasm_malloc(sizeof(*eb));
  939.     eb->next = NULL;
  940.     ebtail = &eb->next;
  941. }
  942. i -= EXT_BLKSIZ;
  943.     }
  944.     eb->exts[i] = ext;
  945.     ext->index = ++externals;
  947.     if (special && !used_special)
  948. error(ERR_NONFATAL, "OBJ supports no special symbol features"
  949.       " for this symbol type");
  950. }
  952. static void obj_out (long segto, void *data, unsigned long type,
  953.      long segment, long wrt) 
  954. {
  955.     long size, realtype;
  956.     unsigned char *ucdata;
  957.     long ldata;
  958.     struct Segment *seg;
  959.     ObjRecord *orp;
  961.     /*
  962.      * handle absolute-assembly (structure definitions)
  963.      */
  964.     if (segto == NO_SEG) {
  965. if ((type & OUT_TYPMASK) != OUT_RESERVE)
  966.     error (ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
  967.    " space");
  968. return;
  969.     }
  971.     /*
  972.      * If `any_segs' is still FALSE, we must define a default
  973.      * segment.
  974.      */
  975.     if (!any_segs) {
  976. int tempint;        /* ignored */
  977. if (segto != obj_segment("__NASMDEFSEG", 2, &tempint))
  978.     error (ERR_PANIC, "strange segment conditions in OBJ driver");
  979.     }
  981.     /*
  982.      * Find the segment we are targetting.
  983.      */
  984.     for (seg = seghead; seg; seg = seg->next)
  985. if (seg->index == segto)
  986.     break;
  987.     if (!seg)
  988. error (ERR_PANIC, "code directed to nonexistent segment?");
  990.     orp = seg->orp;
  991.     orp->parm[0] = seg->currentpos;
  993.     size = type & OUT_SIZMASK;
  994.     realtype = type & OUT_TYPMASK;
  995.     if (realtype == OUT_RAWDATA) {
  996. ucdata = data;
  997. while (size > 0) {
  998.     unsigned int len;
  999.     orp = obj_check(seg->orp, 1);
  1000.     len = RECORD_MAX - orp->used;
  1001.     if (len > size)
  1002. len = size;
  1003.     memcpy (orp->buf+orp->used, ucdata, len);
  1004.     orp->committed = orp->used += len;
  1005.     orp->parm[0] = seg->currentpos += len;
  1006.     ucdata += len;
  1007.     size -= len;
  1008. }
  1009.     }
  1010.     else if (realtype == OUT_ADDRESS || realtype == OUT_REL2ADR ||
  1011.      realtype == OUT_REL4ADR) 
  1012.     {
  1013. int rsize;
  1015. if (segment == NO_SEG && realtype != OUT_ADDRESS)
  1016.     error(ERR_NONFATAL, "relative call to absolute address not"
  1017.   " supported by OBJ format");
  1018. if (segment >= SEG_ABS)
  1019.     error(ERR_NONFATAL, "far-absolute relocations not supported"
  1020.   " by OBJ format");
  1021. ldata = *(long *)data;
  1022. if (realtype == OUT_REL2ADR) {
  1023.     ldata += (size-2);
  1024.     size = 2;
  1025. }
  1026. if (realtype == OUT_REL4ADR) {
  1027.     ldata += (size-4);
  1028.     size = 4;
  1029. }
  1030. if (size == 2)
  1031.     orp = obj_word (orp, ldata);
  1032. else
  1033.     orp = obj_dword (orp, ldata);
  1034. rsize = size;
  1035. if (segment < SEG_ABS && (segment != NO_SEG && segment % 2) &&
  1036.     size == 4) {
  1037.     /*
  1038.      * This is a 4-byte segment-base relocation such as
  1039.      * `MOV EAX,SEG foo'. OBJ format can't actually handle
  1040.      * these, but if the constant term has the 16 low bits
  1041.      * zero, we can just apply a 2-byte segment-base
  1042.      * relocation to the low word instead.
  1043.      */
  1044.     rsize = 2;
  1045.     if (ldata & 0xFFFF)
  1046. error(ERR_NONFATAL, "OBJ format cannot handle complex"
  1047.       " dword-size segment base references");
  1048. }
  1049. if (segment != NO_SEG)
  1050.     obj_write_fixup (orp, rsize,
  1051.      (realtype == OUT_ADDRESS  ? 0x4000 : 0),
  1052.      segment, wrt);
  1053. seg->currentpos += size;
  1054.     } else if (realtype == OUT_RESERVE) {
  1055. if (orp->committed)
  1056.     orp = obj_bump(orp);
  1057. seg->currentpos += size;
  1058.     }
  1059.     obj_commit(orp);
  1060. }
  1062. static void obj_write_fixup (ObjRecord *orp, int bytes,
  1063.      int segrel, long seg, long wrt) 
  1064. {
  1065.     int locat, method;
  1066.     int base;
  1067.     long tidx, fidx;
  1068.     struct Segment *s = NULL;
  1069.     struct Group *g = NULL;
  1070.     struct External *e = NULL;
  1071.     ObjRecord *forp;
  1073.     if (bytes == 1) {
  1074. error(ERR_NONFATAL, "`obj' output driver does not support"
  1075.       " one-byte relocations");
  1076. return;
  1077.     }
  1079.     forp = orp->child;
  1080.     if (forp == NULL) {
  1081. orp->child = forp = obj_new();
  1082. forp->up = &(orp->child);
  1083. forp->type = FIXUPP;
  1084.     }
  1086.     if (seg % 2) {
  1087. base = TRUE;
  1088. locat = FIX_16_SELECTOR;
  1089. seg--;
  1090. if (bytes != 2)
  1091.     error(ERR_PANIC, "OBJ: 4-byte segment base fixup got"
  1092.   " through sanity check");
  1093.     }
  1094.     else {
  1095. base = FALSE;
  1096. locat = (bytes == 2) ? FIX_16_OFFSET : FIX_32_OFFSET;
  1097. if (!segrel)
  1098.     /*
  1099.      * There is a bug in tlink that makes it process self relative
  1100.      * fixups incorrectly if the x_size doesn't match the location
  1101.      * size.
  1102.      */
  1103.     forp = obj_force(forp, bytes<<3);
  1104.     }
  1106.     forp = obj_rword (forp, locat | segrel | (orp->parm[0]-orp->parm[2]));
  1108.     tidx = fidx = -1, method = 0;      /* placate optimisers */
  1110.     /*
  1111.      * See if we can find the segment ID in our segment list. If
  1112.      * so, we have a T4 (LSEG) target.
  1113.      */
  1114.     for (s = seghead; s; s = s->next)
  1115. if (s->index == seg)
  1116.     break;
  1117.     if (s)
  1118. method = 4, tidx = s->obj_index;
  1119.     else {
  1120. for (g = grphead; g; g = g->next)
  1121.     if (g->index == seg)
  1122. break;
  1123. if (g)
  1124.     method = 5, tidx = g->obj_index;
  1125. else {
  1126.     long i = seg/2;
  1127.     struct ExtBack *eb = ebhead;
  1128.     while (i > EXT_BLKSIZ) {
  1129. if (eb)
  1130.     eb = eb->next;
  1131. else
  1132.     break;
  1133. i -= EXT_BLKSIZ;
  1134.     }
  1135.     if (eb)
  1136. method = 6, e = eb->exts[i], tidx = e->index;
  1137.     else
  1138. error(ERR_PANIC,
  1139.       "unrecognised segment value in obj_write_fixup");
  1140. }
  1141.     }
  1143.     /*
  1144.      * If no WRT given, assume the natural default, which is method
  1145.      * F5 unless:
  1146.      *
  1147.      * - we are doing an OFFSET fixup for a grouped segment, in
  1148.      *   which case we require F1 (group).
  1149.      *
  1150.      * - we are doing an OFFSET fixup for an external with a
  1151.      *   default WRT, in which case we must honour the default WRT.
  1152.      */
  1153.     if (wrt == NO_SEG) {
  1154. if (!base && s && s->grp)
  1155.     method |= 0x10, fidx = s->grp->obj_index;
  1156. else if (!base && e && e->defwrt_type != DEFWRT_NONE) {
  1157.     if (e->defwrt_type == DEFWRT_SEGMENT)
  1158. method |= 0x00, fidx = e->defwrt_ptr.seg->obj_index;
  1159.     else if (e->defwrt_type == DEFWRT_GROUP)
  1160. method |= 0x10, fidx = e->defwrt_ptr.grp->obj_index;
  1161.     else {
  1162. error(ERR_NONFATAL, "default WRT specification for"
  1163.       " external `%s' unresolved", e->name);
  1164. method |= 0x50, fidx = -1; /* got to do _something_ */
  1165.     }
  1166. } else
  1167.     method |= 0x50, fidx = -1;
  1168.     } else {
  1169. /*
  1170.  * See if we can find the WRT-segment ID in our segment
  1171.  * list. If so, we have a F0 (LSEG) frame.
  1172.  */
  1173. for (s = seghead; s; s = s->next)
  1174.     if (s->index == wrt-1)
  1175. break;
  1176. if (s)
  1177.     method |= 0x00, fidx = s->obj_index;
  1178. else {
  1179.     for (g = grphead; g; g = g->next)
  1180. if (g->index == wrt-1)
  1181.     break;
  1182.     if (g)
  1183. method |= 0x10, fidx = g->obj_index;
  1184.     else {
  1185. long i = wrt/2;
  1186. struct ExtBack *eb = ebhead;
  1187. while (i > EXT_BLKSIZ) {
  1188.     if (eb)
  1189. eb = eb->next;
  1190.     else
  1191. break;
  1192.     i -= EXT_BLKSIZ;
  1193. }
  1194. if (eb)
  1195.     method |= 0x20, fidx = eb->exts[i]->index;
  1196. else
  1197.     error(ERR_PANIC,
  1198.   "unrecognised WRT value in obj_write_fixup");
  1199.     }
  1200. }
  1201.     }
  1203.     forp = obj_byte (forp, method);
  1204.     if (fidx != -1)
  1205. forp = obj_index (forp, fidx);
  1206.     forp = obj_index (forp, tidx);
  1207.     obj_commit (forp);
  1208. }
  1210. static long obj_segment (char *name, int pass, int *bits) 
  1211. {
  1212.     /*
  1213.      * We call the label manager here to define a name for the new
  1214.      * segment, and when our _own_ label-definition stub gets
  1215.      * called in return, it should register the new segment name
  1216.      * using the pointer it gets passed. That way we save memory,
  1217.      * by sponging off the label manager.
  1218.      */
  1219.     if (!name) {
  1220. *bits = 16;
  1221. return first_seg;
  1222.     } else {
  1223. struct Segment *seg;
  1224. struct Group *grp;
  1225. struct External **extp;
  1226. int obj_idx, i, attrs, rn_error;
  1227. char *p;
  1229. /*
  1230.  * Look for segment attributes.
  1231.  */
  1232. attrs = 0;
  1233. while (*name == '.')
  1234.     name++;        /* hack, but a documented one */
  1235. p = name;
  1236. while (*p && !isspace(*p))
  1237.     p++;
  1238. if (*p) {
  1239.     *p++ = '';
  1240.     while (*p && isspace(*p))
  1241. *p++ = '';
  1242. }
  1243. while (*p) {
  1244.     while (*p && !isspace(*p))
  1245. p++;
  1246.     if (*p) {
  1247. *p++ = '';
  1248. while (*p && isspace(*p))
  1249.     *p++ = '';
  1250.     }
  1252.     attrs++;
  1253. }
  1255. obj_idx = 1;
  1256. for (seg = seghead; seg; seg = seg->next) {
  1257.     obj_idx++;
  1258.     if (!strcmp(seg->name, name)) {
  1259. if (attrs > 0 && pass == 1)
  1260.     error(ERR_WARNING, "segment attributes specified on"
  1261.   " redeclaration of segment: ignoring");
  1262. if (seg->use32)
  1263.     *bits = 32;
  1264. else
  1265.     *bits = 16;
  1266. return seg->index;
  1267.     }
  1268. }
  1270. *segtail = seg = nasm_malloc(sizeof(*seg));
  1271. seg->next = NULL;
  1272. segtail = &seg->next;
  1273. seg->index = (any_segs ? seg_alloc() : first_seg);
  1274. seg->obj_index = obj_idx;
  1275. seg->grp = NULL;
  1276. any_segs = TRUE;
  1277. seg->name = NULL;
  1278. seg->currentpos = 0;
  1279. seg->align = 1;        /* default */
  1280. seg->use32 = FALSE;        /* default */
  1281. seg->combine = CMB_PUBLIC;     /* default */
  1282. seg->segclass = seg->overlay = NULL;
  1283. seg->pubhead = NULL;
  1284. seg->pubtail = &seg->pubhead;
  1285. seg->lochead = NULL;
  1286. seg->loctail = &seg->lochead;
  1287. seg->orp = obj_new();
  1288. seg->orp->up = &(seg->orp);
  1289. seg->orp->ori = ori_ledata;
  1290. seg->orp->type = LEDATA;
  1291. seg->orp->parm[1] = obj_idx;
  1293. /*
  1294.  * Process the segment attributes.
  1295.  */
  1296. p = name;
  1297. while (attrs--) {
  1298.     p += strlen(p);
  1299.     while (!*p) p++;
  1301.     /*
  1302.      * `p' contains a segment attribute.
  1303.      */
  1304.     if (!nasm_stricmp(p, "private"))
  1305. seg->combine = CMB_PRIVATE;
  1306.     else if (!nasm_stricmp(p, "public"))
  1307. seg->combine = CMB_PUBLIC;
  1308.     else if (!nasm_stricmp(p, "common"))
  1309. seg->combine = CMB_COMMON;
  1310.     else if (!nasm_stricmp(p, "stack"))
  1311. seg->combine = CMB_STACK;
  1312.     else if (!nasm_stricmp(p, "use16"))
  1313. seg->use32 = FALSE;
  1314.     else if (!nasm_stricmp(p, "use32"))
  1315. seg->use32 = TRUE;
  1316.     else if (!nasm_stricmp(p, "flat")) {
  1317. /*
  1318.  * This segment is an OS/2 FLAT segment. That means
  1319.  * that its default group is group FLAT, even if
  1320.  * the group FLAT does not explicitly _contain_ the
  1321.  * segment.
  1322.  * 
  1323.  * When we see this, we must create the group
  1324.  * `FLAT', containing no segments, if it does not
  1325.  * already exist; then we must set the default
  1326.  * group of this segment to be the FLAT group.
  1327.  */
  1328. struct Group *grp;
  1329. for (grp = grphead; grp; grp = grp->next)
  1330.     if (!strcmp(grp->name, "FLAT"))
  1331. break;
  1332. if (!grp) {
  1333.     obj_directive ("group", "FLAT", 1);
  1334.     for (grp = grphead; grp; grp = grp->next)
  1335. if (!strcmp(grp->name, "FLAT"))
  1336.     break;
  1337.     if (!grp)
  1338. error (ERR_PANIC, "failure to define FLAT?!");
  1339. }
  1340. seg->grp = grp;
  1341.     } else if (!nasm_strnicmp(p, "class=", 6))
  1342. seg->segclass = nasm_strdup(p+6);
  1343.     else if (!nasm_strnicmp(p, "overlay=", 8))
  1344. seg->overlay = nasm_strdup(p+8);
  1345.     else if (!nasm_strnicmp(p, "align=", 6)) {
  1346. seg->align = readnum(p+6, &rn_error);
  1347. if (rn_error) {
  1348.     seg->align = 1;
  1349.     error (ERR_NONFATAL, "segment alignment should be"
  1350.    " numeric");
  1351. }
  1352. switch ((int) seg->align) {
  1353.   case 1:        /* BYTE */
  1354.   case 2:        /* WORD */
  1355.   case 4:        /* DWORD */
  1356.   case 16:        /* PARA */
  1357.   case 256:        /* PAGE */
  1358.   case 4096:        /* PharLap extension */
  1359.     break;
  1360.   case 8:
  1361.     error(ERR_WARNING, "OBJ format does not support alignment"
  1362.   " of 8: rounding up to 16");
  1363.     seg->align = 16;
  1364.     break;
  1365.   case 32:
  1366.   case 64:
  1367.   case 128:
  1368.     error(ERR_WARNING, "OBJ format does not support alignment"
  1369.   " of %d: rounding up to 256", seg->align);
  1370.     seg->align = 256;
  1371.     break;
  1372.   case 512:
  1373.   case 1024:
  1374.   case 2048:
  1375.     error(ERR_WARNING, "OBJ format does not support alignment"
  1376.   " of %d: rounding up to 4096", seg->align);
  1377.     seg->align = 4096;
  1378.     break;
  1379.   default:
  1380.     error(ERR_NONFATAL, "invalid alignment value %d",
  1381.   seg->align);
  1382.     seg->align = 1;
  1383.     break;
  1384. }
  1385.     } else if (!nasm_strnicmp(p, "absolute=", 9)) {
  1386. seg->align = SEG_ABS + readnum(p+9, &rn_error);
  1387. if (rn_error)
  1388.     error (ERR_NONFATAL, "argument to `absolute' segment"
  1389.    " attribute should be numeric");
  1390.     }
  1391. }
  1393. obj_seg_needs_update = seg;
  1394. if (seg->align >= SEG_ABS)
  1395.     deflabel (name, NO_SEG, seg->align - SEG_ABS,
  1396.       NULL, FALSE, FALSE, &of_obj, error);
  1397. else
  1398.     deflabel (name, seg->index+1, 0L,
  1399.       NULL, FALSE, FALSE, &of_obj, error);
  1400. obj_seg_needs_update = NULL;
  1402. /*
  1403.  * See if this segment is defined in any groups.
  1404.  */
  1405. for (grp = grphead; grp; grp = grp->next) {
  1406.     for (i = grp->nindices; i < grp->nentries; i++) {
  1407. if (!strcmp(grp->segs[i].name, seg->name)) {
  1408.     nasm_free (grp->segs[i].name);
  1409.     grp->segs[i] = grp->segs[grp->nindices];
  1410.     grp->segs[grp->nindices++].index = seg->obj_index;
  1411.     if (seg->grp)
  1412. error(ERR_WARNING, "segment `%s' is already part of"
  1413.       " a group: first one takes precedence",
  1414.       seg->name);
  1415.     else
  1416. seg->grp = grp;
  1417. }
  1418.     }
  1419. }
  1421. /*
  1422.  * Walk through the list of externals with unresolved
  1423.  * default-WRT clauses, and resolve any that point at this
  1424.  * segment.
  1425.  */
  1426. extp = &dws;
  1427. while (*extp) {
  1428.     if ((*extp)->defwrt_type == DEFWRT_STRING &&
  1429. !strcmp((*extp)->defwrt_ptr.string, seg->name)) {
  1430. nasm_free((*extp)->defwrt_ptr.string);
  1431. (*extp)->defwrt_type = DEFWRT_SEGMENT;
  1432. (*extp)->defwrt_ptr.seg = seg;
  1433. *extp = (*extp)->next_dws;
  1434.     } else
  1435. extp = &(*extp)->next_dws;
  1436. }
  1438. if (seg->use32)
  1439.     *bits = 32;
  1440. else
  1441.     *bits = 16;
  1442. return seg->index;
  1443.     }
  1444. }
  1446. static int obj_directive (char *directive, char *value, int pass) 
  1447. {
  1448.     if (!strcmp(directive, "group")) {
  1449. char *p, *q, *v;
  1450. if (pass == 1) {
  1451.     struct Group *grp;
  1452.     struct Segment *seg;
  1453.     struct External **extp;
  1454.     int obj_idx;
  1456.     q = value;
  1457.     while (*q == '.')
  1458. q++;        /* hack, but a documented one */
  1459.     v = q;
  1460.     while (*q && !isspace(*q))
  1461. q++;
  1462.     if (isspace(*q)) {
  1463. *q++ = '';
  1464. while (*q && isspace(*q))
  1465.     q++;
  1466.     }
  1467.     /*
  1468.      * Here we used to sanity-check the group directive to
  1469.      * ensure nobody tried to declare a group containing no
  1470.      * segments. However, OS/2 does this as standard
  1471.      * practice, so the sanity check has been removed.
  1472.      *
  1473.      * if (!*q) {
  1474.      *     error(ERR_NONFATAL,"GROUP directive contains no segments");
  1475.      *     return 1;
  1476.      * }
  1477.      */
  1479.     obj_idx = 1;
  1480.     for (grp = grphead; grp; grp = grp->next) {
  1481. obj_idx++;
  1482. if (!strcmp(grp->name, v)) {
  1483.     error(ERR_NONFATAL, "group `%s' defined twice", v);
  1484.     return 1;
  1485. }
  1486.     }
  1488.     *grptail = grp = nasm_malloc(sizeof(*grp));
  1489.     grp->next = NULL;
  1490.     grptail = &grp->next;
  1491.     grp->index = seg_alloc();
  1492.     grp->obj_index = obj_idx;
  1493.     grp->nindices = grp->nentries = 0;
  1494.     grp->name = NULL;
  1496.     obj_grp_needs_update = grp;
  1497.     deflabel (v, grp->index+1, 0L,
  1498.       NULL, FALSE, FALSE, &of_obj, error);
  1499.     obj_grp_needs_update = NULL;
  1501.     while (*q) {
  1502. p = q;
  1503. while (*q && !isspace(*q))
  1504.     q++;
  1505. if (isspace(*q)) {
  1506.     *q++ = '';
  1507.     while (*q && isspace(*q))
  1508. q++;
  1509. }
  1510. /*
  1511.  * Now p contains a segment name. Find it.
  1512.  */
  1513. for (seg = seghead; seg; seg = seg->next)
  1514.     if (!strcmp(seg->name, p))
  1515. break;
  1516. if (seg) {
  1517.     /*
  1518.      * We have a segment index. Shift a name entry
  1519.      * to the end of the array to make room.
  1520.      */
  1521.     grp->segs[grp->nentries++] = grp->segs[grp->nindices];
  1522.     grp->segs[grp->nindices++].index = seg->obj_index;
  1523.     if (seg->grp)
  1524. error(ERR_WARNING, "segment `%s' is already part of"
  1525.       " a group: first one takes precedence",
  1526.       seg->name);
  1527.     else
  1528. seg->grp = grp;
  1529. } else {
  1530.     /*
  1531.      * We have an as-yet undefined segment.
  1532.      * Remember its name, for later.
  1533.      */
  1534.     grp->segs[grp->nentries++].name = nasm_strdup(p);
  1535. }
  1536.     }
  1538.     /*
  1539.      * Walk through the list of externals with unresolved
  1540.      * default-WRT clauses, and resolve any that point at
  1541.      * this group.
  1542.      */
  1543.     extp = &dws;
  1544.     while (*extp) {
  1545. if ((*extp)->defwrt_type == DEFWRT_STRING &&
  1546.     !strcmp((*extp)->defwrt_ptr.string, grp->name)) {
  1547.     nasm_free((*extp)->defwrt_ptr.string);
  1548.     (*extp)->defwrt_type = DEFWRT_GROUP;
  1549.     (*extp)->defwrt_ptr.grp = grp;
  1550.     *extp = (*extp)->next_dws;
  1551.     } else
  1552.     extp = &(*extp)->next_dws;
  1553.     }
  1554. }
  1555. return 1;
  1556.     }
  1557.     if (!strcmp(directive, "uppercase")) {
  1558. obj_uppercase = TRUE;
  1559. return 1;
  1560.     }
  1561.     if (!strcmp(directive, "import")) {
  1562. char *q, *extname, *libname, *impname;
  1564. if (pass == 2)
  1565.     return 1;        /* ignore in pass two */
  1566. extname = q = value;
  1567. while (*q && !isspace(*q))
  1568.     q++;
  1569. if (isspace(*q)) {
  1570.     *q++ = '';
  1571.     while (*q && isspace(*q))
  1572. q++;
  1573. }
  1575. libname = q;
  1576. while (*q && !isspace(*q))
  1577.     q++;
  1578. if (isspace(*q)) {
  1579.     *q++ = '';
  1580.     while (*q && isspace(*q))
  1581. q++;
  1582. }
  1584. impname = q;
  1586. if (!*extname || !*libname)
  1587.     error(ERR_NONFATAL, "`import' directive requires symbol name"
  1588.   " and library name");
  1589. else {
  1590.     struct ImpDef *imp;
  1591.     int err = FALSE;
  1593.     imp = *imptail = nasm_malloc(sizeof(struct ImpDef));
  1594.     imptail = &imp->next;
  1595.     imp->next = NULL;
  1596.     imp->extname = nasm_strdup(extname);
  1597.     imp->libname = nasm_strdup(libname);
  1598.     imp->impindex = readnum(impname, &err);
  1599.     if (!*impname || err)
  1600. imp->impname = nasm_strdup(impname);
  1601.     else
  1602. imp->impname = NULL;
  1603. }
  1605. return 1;
  1606.     }
  1607.     if (!strcmp(directive, "export")) {
  1608. char *q, *extname, *intname, *v;
  1609. struct ExpDef *export;
  1610. int flags = 0;
  1611. unsigned int ordinal = 0;
  1613. if (pass == 2)
  1614.     return 1;        /* ignore in pass two */
  1615. intname = q = value;
  1616. while (*q && !isspace(*q))
  1617.     q++;
  1618. if (isspace(*q)) {
  1619.     *q++ = '';
  1620.     while (*q && isspace(*q))
  1621. q++;
  1622. }
  1624. extname = q;
  1625. while (*q && !isspace(*q))
  1626.     q++;
  1627. if (isspace(*q)) {
  1628.     *q++ = '';
  1629.     while (*q && isspace(*q))
  1630. q++;
  1631. }
  1633. if (!*intname) {
  1634.     error(ERR_NONFATAL, "`export' directive requires export name");
  1635.     return 1;
  1636. }
  1637. if (!*extname) {
  1638.     extname = intname;
  1639.     intname = "";
  1640. }
  1641. while (*q) {
  1642.     v = q;
  1643.     while (*q && !isspace(*q))
  1644. q++;
  1645.     if (isspace(*q)) {
  1646. *q++ = '';
  1647. while (*q && isspace(*q))
  1648.     q++;
  1649.     }
  1650.     if (!nasm_stricmp(v, "resident"))
  1651. flags |= EXPDEF_FLAG_RESIDENT;
  1652.     else if (!nasm_stricmp(v, "nodata"))
  1653. flags |= EXPDEF_FLAG_NODATA;
  1654.     else if (!nasm_strnicmp(v, "parm=", 5)) {
  1655. int err = FALSE;
  1656. flags |= EXPDEF_MASK_PARMCNT & readnum(v+5, &err);
  1657. if (err) {
  1658.     error(ERR_NONFATAL,
  1659.   "value `%s' for `parm' is non-numeric", v+5);
  1660.     return 1;
  1661. }
  1662.     } else {
  1663. int err = FALSE;
  1664. ordinal = readnum(v, &err);
  1665. if (err) {
  1666.     error(ERR_NONFATAL, "unrecognised export qualifier `%s'",
  1667.   v);
  1668.     return 1;
  1669. }
  1670. flags |= EXPDEF_FLAG_ORDINAL;
  1671.     }
  1672. }
  1674. export = *exptail = nasm_malloc(sizeof(struct ExpDef));
  1675. exptail = &export->next;
  1676. export->next = NULL;
  1677. export->extname = nasm_strdup(extname);
  1678. export->intname = nasm_strdup(intname);
  1679. export->ordinal = ordinal;
  1680. export->flags = flags;
  1682. return 1;
  1683.     }
  1684.     return 0;
  1685. }
  1687. static long obj_segbase (long segment) 
  1688. {
  1689.     struct Segment *seg;
  1691.     /*
  1692.      * Find the segment in our list.
  1693.      */
  1694.     for (seg = seghead; seg; seg = seg->next)
  1695. if (seg->index == segment-1)
  1696.     break;
  1698.     if (!seg) {
  1699. /*
  1700.  * Might be an external with a default WRT.
  1701.  */
  1702. long i = segment/2;
  1703. struct ExtBack *eb = ebhead;
  1704. struct External *e;
  1706. while (i > EXT_BLKSIZ) {
  1707.     if (eb)
  1708. eb = eb->next;
  1709.     else
  1710. break;
  1711.     i -= EXT_BLKSIZ;
  1712. }
  1713. if (eb) {
  1714.     e = eb->exts[i];
  1715.     if (e->defwrt_type == DEFWRT_NONE)
  1716. return segment;        /* fine */
  1717.     else if (e->defwrt_type == DEFWRT_SEGMENT)
  1718. return e->defwrt_ptr.seg->index+1;
  1719.     else if (e->defwrt_type == DEFWRT_GROUP)
  1720. return e->defwrt_ptr.grp->index+1;
  1721.     else
  1722. return NO_SEG;        /* can't tell what it is */
  1723. }
  1725. return segment;        /* not one of ours - leave it alone */
  1726.     }
  1728.     if (seg->align >= SEG_ABS)
  1729. return seg->align;        /* absolute segment */
  1730.     if (seg->grp)
  1731. return seg->grp->index+1;      /* grouped segment */
  1733.     return segment;        /* no special treatment */
  1734. }
  1736. static void obj_filename (char *inname, char *outname, efunc error) 
  1737. {
  1738.     strcpy(obj_infile, inname);
  1739.     standard_extension (inname, outname, ".obj", error);
  1740. }
  1742. static void obj_write_file (int debuginfo) 
  1743. {
  1744.     struct Segment *seg, *entry_seg_ptr = 0;
  1745.     struct FileName *fn;
  1746.     struct LineNumber *ln;
  1747.     struct Group *grp;
  1748.     struct Public *pub, *loc;
  1749.     struct External *ext;
  1750.     struct ImpDef *imp;
  1751.     struct ExpDef *export;
  1752.     static char boast[] = "The Netwide Assembler " NASM_VER;
  1753.     int lname_idx;
  1754.     ObjRecord *orp;
  1756.     /*
  1757.      * Write the THEADR module header.
  1758.      */
  1759.     orp = obj_new();
  1760.     orp->type = THEADR;
  1761.     obj_name (orp, obj_infile);
  1762.     obj_emit2 (orp);
  1764.     /*
  1765.      * Write the NASM boast comment.
  1766.      */
  1767.     orp->type = COMENT;
  1768.     obj_rword (orp, 0);   /* comment type zero */
  1769.     obj_name (orp, boast);
  1770.     obj_emit2 (orp);
  1772.     orp->type = COMENT;
  1773.     /*
  1774.      * Write the IMPDEF records, if any.
  1775.      */
  1776.     for (imp = imphead; imp; imp = imp->next) {
  1777. obj_rword (orp, 0xA0);   /* comment class A0 */
  1778. obj_byte (orp, 1);   /* subfunction 1: IMPDEF */
  1779. if (imp->impname)
  1780.     obj_byte (orp, 0);   /* import by name */
  1781. else
  1782.     obj_byte (orp, 1);   /* import by ordinal */
  1783. obj_name (orp, imp->extname);
  1784. obj_name (orp, imp->libname);
  1785. if (imp->impname)
  1786.     obj_name (orp, imp->impname);
  1787. else
  1788.     obj_word (orp, imp->impindex);
  1789. obj_emit2 (orp);
  1790.     }
  1792.     /*
  1793.      * Write the EXPDEF records, if any.
  1794.      */
  1795.     for (export = exphead; export; export = export->next) {
  1796. obj_rword (orp, 0xA0);   /* comment class A0 */
  1797. obj_byte (orp, 2);   /* subfunction 2: EXPDEF */
  1798. obj_byte (orp, export->flags);
  1799. obj_name (orp, export->extname);
  1800. obj_name (orp, export->intname);
  1801. if (export->flags & EXPDEF_FLAG_ORDINAL)
  1802.     obj_word (orp, export->ordinal);
  1803. obj_emit2 (orp);
  1804.     }
  1806.     /* we're using extended OMF if we put in debug info*/
  1807.     if (debuginfo) {
  1808.       orp->type = COMENT;
  1809.       obj_byte (orp, 0x40);
  1810.       obj_byte (orp, dEXTENDED);
  1811.       obj_emit2 (orp);
  1812.     }
  1814.     /*
  1815.      * Write the first LNAMES record, containing LNAME one, which
  1816.      * is null. Also initialise the LNAME counter.
  1817.      */
  1818.     orp->type = LNAMES;
  1819.     obj_byte (orp, 0);
  1820.     lname_idx = 1;
  1821.     /*
  1822.      * Write some LNAMES for the segment names
  1823.      */
  1824.     for (seg = seghead; seg; seg = seg->next) {
  1825. orp = obj_name (orp, seg->name);
  1826. if (seg->segclass)
  1827.     orp = obj_name (orp, seg->segclass);
  1828. if (seg->overlay)
  1829.     orp = obj_name (orp, seg->overlay);
  1830. obj_commit (orp);
  1831.     }
  1832.     /*
  1833.      * Write some LNAMES for the group names
  1834.      */
  1835.     for (grp = grphead; grp; grp = grp->next) {
  1836. orp = obj_name (orp, grp->name);
  1837. obj_commit (orp);
  1838.     }
  1839.     obj_emit (orp);
  1842.     /*
  1843.      * Write the SEGDEF records.
  1844.      */
  1845.     orp->type = SEGDEF;
  1846.     for (seg = seghead; seg; seg = seg->next) {
  1847. int acbp;
  1848. unsigned long seglen = seg->currentpos;
  1850. acbp = (seg->combine << 2);    /* C field */
  1852. if (seg->use32)
  1853.     acbp |= 0x01;        /* P bit is Use32 flag */
  1854. else if (seglen == 0x10000L) {
  1855.     seglen = 0;                /* This special case may be needed for old linkers */
  1856.     acbp |= 0x02;        /* B bit */
  1857. }
  1860. /* A field */
  1861. if (seg->align >= SEG_ABS)
  1862.     /* acbp |= 0x00 */;
  1863. else if (seg->align >= 4096) {
  1864.     if (seg->align > 4096)
  1865. error(ERR_NONFATAL, "segment `%s' requires more alignment"
  1866.       " than OBJ format supports", seg->name);
  1867.     acbp |= 0xC0;        /* PharLap extension */
  1868. } else if (seg->align >= 256) {
  1869.     acbp |= 0x80;
  1870. } else if (seg->align >= 16) {
  1871.     acbp |= 0x60;
  1872. } else if (seg->align >= 4) {
  1873.     acbp |= 0xA0;
  1874. } else if (seg->align >= 2) {
  1875.     acbp |= 0x40;
  1876. } else
  1877.     acbp |= 0x20;
  1879. obj_byte (orp, acbp);
  1880. if (seg->align & SEG_ABS) {
  1881.     obj_x (orp, seg->align - SEG_ABS);  /* Frame */
  1882.     obj_byte (orp, 0);  /* Offset */
  1883. }
  1884. obj_x (orp, seglen);
  1885. obj_index (orp, ++lname_idx);
  1886. obj_index (orp, seg->segclass ? ++lname_idx : 1);
  1887. obj_index (orp, seg->overlay ? ++lname_idx : 1);
  1888. obj_emit2 (orp);
  1889.     }
  1891.     /*
  1892.      * Write the GRPDEF records.
  1893.      */
  1894.     orp->type = GRPDEF;
  1895.     for (grp = grphead; grp; grp = grp->next) {
  1896. int i;
  1898. if (grp->nindices != grp->nentries) {
  1899.     for (i = grp->nindices; i < grp->nentries; i++) {
  1900. error(ERR_NONFATAL, "group `%s' contains undefined segment"
  1901.       " `%s'", grp->name, grp->segs[i].name);
  1902. nasm_free (grp->segs[i].name);
  1903. grp->segs[i].name = NULL;
  1904.     }
  1905. }
  1906. obj_index (orp, ++lname_idx);
  1907. for (i = 0; i < grp->nindices; i++) {
  1908.     obj_byte (orp, 0xFF);
  1909.     obj_index (orp, grp->segs[i].index);
  1910. }
  1911. obj_emit2 (orp);
  1912.     }
  1914.     /*
  1915.      * Write the PUBDEF records: first the ones in the segments,
  1916.      * then the far-absolutes.
  1917.      */
  1918.     orp->type = PUBDEF;
  1919.     orp->ori = ori_pubdef;
  1920.     for (seg = seghead; seg; seg = seg->next) {
  1921. orp->parm[0] = seg->grp ? seg->grp->obj_index : 0;
  1922. orp->parm[1] = seg->obj_index;
  1923. for (pub = seg->pubhead; pub; pub = pub->next) {
  1924.     orp = obj_name (orp, pub->name);
  1925.     orp = obj_x (orp, pub->offset);
  1926.     orp = obj_byte (orp, 0);  /* type index */
  1927.     obj_commit (orp);
  1928. }
  1929. obj_emit (orp);
  1930.     }
  1931.     orp->parm[0] = 0;
  1932.     orp->parm[1] = 0;
  1933.     for (pub = fpubhead; pub; pub = pub->next) {   /* pub-crawl :-) */
  1934. if (orp->parm[2] != pub->segment) {
  1935.     obj_emit (orp);
  1936.     orp->parm[2] = pub->segment;
  1937. }
  1938. orp = obj_name (orp, pub->name);
  1939. orp = obj_x (orp, pub->offset);
  1940. orp = obj_byte (orp, 0);  /* type index */
  1941. obj_commit (orp);
  1942.     }
  1943.     obj_emit (orp);
  1945.     /*
  1946.      * Write the EXTDEF and COMDEF records, in order.
  1947.      */
  1948.     orp->ori = ori_null;
  1949.     for (ext = exthead; ext; ext = ext->next) {
  1950. if (ext->commonsize == 0) {
  1951.     if (orp->type != EXTDEF) {
  1952. obj_emit (orp);
  1953. orp->type = EXTDEF;
  1954.     }
  1955.     orp = obj_name (orp, ext->name);
  1956.     orp = obj_index (orp, 0);
  1957. } else {
  1958.     if (orp->type != COMDEF) {
  1959. obj_emit (orp);
  1960. orp->type = COMDEF;
  1961.     }
  1962.     orp = obj_name (orp, ext->name);
  1963.     orp = obj_index (orp, 0);
  1964.     if (ext->commonelem) {
  1965. orp = obj_byte (orp, 0x61);/* far communal */
  1966. orp = obj_value (orp, (ext->commonsize / ext->commonelem));
  1967. orp = obj_value (orp, ext->commonelem);
  1968.     } else {
  1969. orp = obj_byte (orp, 0x62);/* near communal */
  1970. orp = obj_value (orp, ext->commonsize);
  1971.     }
  1972. }
  1973. obj_commit (orp);
  1974.     }
  1975.     obj_emit (orp);
  1977.     /*
  1978.      * Write a COMENT record stating that the linker's first pass
  1979.      * may stop processing at this point. Exception is if our
  1980.      * MODEND record specifies a start point, in which case,
  1981.      * according to some variants of the documentation, this COMENT
  1982.      * should be omitted. So we'll omit it just in case.
  1983.      * But, TASM puts it in all the time so if we are using
  1984.      * TASM debug stuff we are putting it in
  1985.      */
  1986.     if (debuginfo || obj_entry_seg == NO_SEG) {
  1987. orp->type = COMENT;
  1988.         obj_byte (orp, 0x40);
  1989.         obj_byte (orp, dLINKPASS);
  1990. obj_byte (orp, 1);
  1991. obj_emit2 (orp);
  1992.     } 
  1994.     /*
  1995.      * 1) put out the compiler type
  1996.      * 2) Put out the type info.  The only type we are using is near label #19
  1997.      */
  1998.     if (debuginfo) {
  1999.       int i;
  2000.       struct Array *arrtmp = arrhead;
  2001.       orp->type = COMENT;
  2002.       obj_byte (orp, 0x40);
  2003.       obj_byte (orp, dCOMPDEF);
  2004.       obj_byte (orp, 4);
  2005.       obj_byte (orp, 0);
  2006.       obj_emit2 (orp);
  2008.       obj_byte (orp, 0x40);
  2009.       obj_byte (orp, dTYPEDEF);
  2010.       obj_word (orp, 0x18); /* type # for linking */
  2011.       obj_word (orp, 6);    /* size of type */
  2012.       obj_byte (orp, 0x2a); /* absolute type for debugging */
  2013.       obj_emit2 (orp);
  2014.       obj_byte (orp, 0x40);
  2015.       obj_byte (orp, dTYPEDEF);
  2016.       obj_word (orp, 0x19); /* type # for linking */
  2017.       obj_word (orp, 0);    /* size of type */
  2018.       obj_byte (orp, 0x24); /* absolute type for debugging */
  2019.       obj_byte (orp, 0);    /* near/far specifier */
  2020.       obj_emit2 (orp);
  2021.       obj_byte (orp, 0x40);
  2022.       obj_byte (orp, dTYPEDEF);
  2023.       obj_word (orp, 0x1A); /* type # for linking */
  2024.       obj_word (orp, 0);    /* size of type */
  2025.       obj_byte (orp, 0x24); /* absolute type for debugging */
  2026.       obj_byte (orp, 1);    /* near/far specifier */
  2027.       obj_emit2 (orp);
  2028.       obj_byte (orp, 0x40);
  2029.       obj_byte (orp, dTYPEDEF);
  2030.       obj_word (orp, 0x1b); /* type # for linking */
  2031.       obj_word (orp, 0);    /* size of type */
  2032.       obj_byte (orp, 0x23); /* absolute type for debugging */
  2033.       obj_byte (orp, 0);
  2034.       obj_byte (orp, 0);
  2035.       obj_byte (orp, 0);
  2036.       obj_emit2 (orp);
  2037.       obj_byte (orp, 0x40);
  2038.       obj_byte (orp, dTYPEDEF);
  2039.       obj_word (orp, 0x1c); /* type # for linking */
  2040.       obj_word (orp, 0);    /* size of type */
  2041.       obj_byte (orp, 0x23); /* absolute type for debugging */
  2042.       obj_byte (orp, 0);
  2043.       obj_byte (orp, 4);
  2044.       obj_byte (orp, 0);
  2045.       obj_emit2 (orp);
  2046.       obj_byte (orp, 0x40);
  2047.       obj_byte (orp, dTYPEDEF);
  2048.       obj_word (orp, 0x1d); /* type # for linking */
  2049.       obj_word (orp, 0);    /* size of type */
  2050.       obj_byte (orp, 0x23); /* absolute type for debugging */
  2051.       obj_byte (orp, 0);
  2052.       obj_byte (orp, 1);
  2053.       obj_byte (orp, 0);
  2054.       obj_emit2 (orp);
  2055.       obj_byte (orp, 0x40);
  2056.       obj_byte (orp, dTYPEDEF);
  2057.       obj_word (orp, 0x1e); /* type # for linking */
  2058.       obj_word (orp, 0);    /* size of type */
  2059.       obj_byte (orp, 0x23); /* absolute type for debugging */
  2060.       obj_byte (orp, 0);
  2061.       obj_byte (orp, 5);
  2062.       obj_byte (orp, 0);
  2063.       obj_emit2 (orp);
  2065.       /* put out the array types */
  2066.       for (i= ARRAYBOT; i < arrindex; i++) {
  2067.         obj_byte (orp, 0x40);
  2068.        obj_byte (orp, dTYPEDEF);
  2069.        obj_word (orp, i ); /* type # for linking */
  2070.        obj_word (orp, arrtmp->size);    /* size of type */
  2071.        obj_byte (orp, 0x1A); /* absolute type for debugging (array)*/
  2072.        obj_byte (orp, arrtmp->basetype ); /* base type */
  2073.        obj_emit2 (orp);
  2074.         arrtmp = arrtmp->next ;
  2075.       }
  2076.     }
  2077.     /*
  2078.      * write out line number info with a LINNUM record
  2079.      * switch records when we switch segments, and output the
  2080.      * file in a pseudo-TASM fashion.  The record switch is naive; that
  2081.      * is that one file may have many records for the same segment
  2082.      * if there are lots of segment switches
  2083.      */
  2084.     if (fnhead && debuginfo) {
  2085.      seg = fnhead->lnhead->segment;
  2087.      for (fn = fnhead; fn; fn = fn->next) {
  2088.     /* write out current file name */
  2089.             orp->type = COMENT;
  2090.             orp->ori = ori_null;
  2091.     obj_byte (orp, 0x40);
  2092.     obj_byte (orp, dFILNAME);
  2093.             obj_byte( orp,0);
  2094.             obj_name( orp,fn->name);
  2095.             obj_dword(orp, 0);
  2096.     obj_emit2 (orp);
  2098.     /* write out line numbers this file */
  2100.             orp->type = LINNUM;
  2101.             orp->ori = ori_linnum;
  2102.     for (ln = fn->lnhead; ln; ln = ln->next) {
  2103. if (seg != ln->segment) {
  2104.     /* if we get here have to flush the buffer and start
  2105.                      * a new record for a new segment
  2106.      */
  2107.     seg = ln->segment;
  2108.     obj_emit ( orp );
  2109. }
  2110. orp->parm[0] = seg->grp ? seg->grp->obj_index : 0;
  2111. orp->parm[1] = seg->obj_index;
  2112.         orp = obj_word(orp, ln->lineno);
  2113.                 orp = obj_x(orp, ln->offset);
  2114.         obj_commit (orp);
  2115.     }
  2116.       obj_emit (orp);
  2117. }
  2118.     }
  2119.     /*
  2120.      * we are going to locate the entry point segment now
  2121.      * rather than wait until the MODEND record, because,
  2122.      * then we can output a special symbol to tell where the
  2123.      * entry point is.
  2124.      *
  2125.      */
  2126.     if (obj_entry_seg != NO_SEG) {
  2127. for (seg = seghead; seg; seg = seg->next) {
  2128.     if (seg->index == obj_entry_seg) {
  2129.                 entry_seg_ptr = seg;
  2130. break;
  2131.     }
  2132. }
  2133. if (!seg)
  2134.     error(ERR_NONFATAL, "entry point is not in this module");
  2135.     }
  2137.     /*
  2138.      * get ready to put out symbol records
  2139.      */
  2140.     orp->type = COMENT;
  2141.     orp->ori = ori_local;
  2142.    
  2143.     /*
  2144.      * put out a symbol for the entry point
  2145.      * no dots in this symbol, because, borland does
  2146.      * not (officially) support dots in label names
  2147.      * and I don't know what various versions of TLINK will do
  2148.      */
  2149.     if (debuginfo && obj_entry_seg != NO_SEG) {
  2150.         orp = obj_name (orp,"start_of_program");
  2151. orp = obj_word (orp,0x19);  /* type: near label */
  2152. orp = obj_index (orp, seg->grp ? seg->grp->obj_index : 0);
  2153. orp = obj_index (orp, seg->obj_index);
  2154. orp = obj_x (orp, obj_entry_ofs);
  2155. obj_commit (orp);
  2156.     } 
  2157.  
  2158.     /*
  2159.      * put out the local labels
  2160.      */
  2161.     for (seg = seghead; seg && debuginfo; seg = seg->next) {
  2162.         /* labels this seg */
  2163.         for (loc = seg->lochead; loc; loc = loc->next) {
  2164.             orp = obj_name (orp,loc->name);
  2165.     orp = obj_word (orp, loc->type);
  2166.     orp = obj_index (orp, seg->grp ? seg->grp->obj_index : 0);
  2167.     orp = obj_index (orp, seg->obj_index);
  2168.     orp = obj_x (orp,loc->offset);
  2169.     obj_commit (orp);
  2170.         }
  2171.     }
  2172.     if (orp->used)
  2173.      obj_emit (orp);
  2175.     /*
  2176.      * Write the LEDATA/FIXUPP pairs.
  2177.      */
  2178.     for (seg = seghead; seg; seg = seg->next) {
  2179. obj_emit (seg->orp);
  2180. nasm_free (seg->orp);
  2181.     }
  2183.     /*
  2184.      * Write the MODEND module end marker.
  2185.      */
  2186.     orp->type = MODEND;
  2187.     orp->ori = ori_null;
  2188.     if (entry_seg_ptr) {
  2189. obj_byte (orp, 0xC1);
  2190. seg = entry_seg_ptr;
  2191. if (seg->grp) {
  2192.     obj_byte (orp, 0x10);
  2193.     obj_index (orp, seg->grp->obj_index);
  2194. } else {
  2195.     /*
  2196.      * the below changed to prevent TLINK crashing.
  2197.      * Previous more efficient version read:
  2198.      *
  2199.      *  obj_byte (orp, 0x50);
  2200.      */
  2201.     obj_byte (orp, 0x00);
  2202.     obj_index (orp, seg->obj_index);
  2203. }
  2204. obj_index (orp, seg->obj_index);
  2205. obj_x (orp, obj_entry_ofs);
  2206.     } else
  2207. obj_byte (orp, 0);
  2208.     obj_emit2 (orp);
  2209.     nasm_free (orp);
  2210. }
  2212. void obj_fwrite(ObjRecord *orp) 
  2213. {
  2214.     unsigned int cksum, len;
  2215.     unsigned char *ptr;
  2217.     cksum = orp->type;
  2218.     if (orp->x_size == 32)
  2219. cksum |= 1;
  2220.     fputc (cksum, ofp);
  2221.     len = orp->committed+1;
  2222.     cksum += (len & 0xFF) + ((len>>8) & 0xFF);
  2223.     fwriteshort (len, ofp);
  2224.     fwrite (orp->buf, 1, len-1, ofp);
  2225.     for (ptr=orp->buf; --len; ptr++)
  2226. cksum += *ptr;
  2227.     fputc ( (-cksum) & 0xFF, ofp);
  2228. }
  2230. static char *obj_stdmac[] = {
  2231.     "%define __SECT__ [section .text]",
  2232.     "%imacro group 1+.nolist",
  2233.     "[group %1]",
  2234.     "%endmacro",
  2235.     "%imacro uppercase 0+.nolist",
  2236.     "[uppercase %1]",
  2237.     "%endmacro",
  2238.     "%imacro export 1+.nolist",
  2239.     "[export %1]",
  2240.     "%endmacro",
  2241.     "%imacro import 1+.nolist",
  2242.     "[import %1]",
  2243.     "%endmacro",
  2244.     "%macro __NASM_CDecl__ 1",
  2245.     "%endmacro",
  2246.     NULL
  2247. };
  2249. void dbgbi_init(struct ofmt * of, void * id, FILE * fp, efunc error)
  2250. {
  2251.     (void) of;
  2252.     (void) id;
  2253.     (void) fp;
  2254.     (void) error;
  2256.     fnhead = NULL;
  2257.     fntail = &fnhead;
  2258.     arrindex = ARRAYBOT ;
  2259.     arrhead = NULL;
  2260.     arrtail = &arrhead;
  2261. }
  2262. static void dbgbi_cleanup(void)
  2263. {
  2264.     struct Segment *segtmp;
  2265.     while (fnhead) {
  2266. struct FileName *fntemp = fnhead;
  2267. while (fnhead->lnhead) {
  2268.     struct LineNumber *lntemp = fnhead->lnhead;
  2269.     fnhead->lnhead = lntemp->next;
  2270.     nasm_free( lntemp);
  2271. }
  2272. fnhead = fnhead->next;
  2273. nasm_free (fntemp->name);
  2274. nasm_free (fntemp);
  2275.     }
  2276.     for (segtmp=seghead; segtmp; segtmp=segtmp->next) {
  2277. while (segtmp->lochead) {
  2278.     struct Public *loctmp = segtmp->lochead;
  2279.     segtmp->lochead = loctmp->next;
  2280.     nasm_free (loctmp->name);
  2281.     nasm_free (loctmp);
  2282. }
  2283.     }
  2284.     while (arrhead) {
  2285. struct Array *arrtmp = arrhead;
  2286.         arrhead = arrhead->next;
  2287.         nasm_free (arrtmp);
  2288.     }
  2289. }
  2291. static void dbgbi_linnum (const char *lnfname, long lineno, long segto)
  2292. {
  2293.     struct FileName *fn;
  2294.     struct LineNumber *ln;
  2295.     struct Segment *seg;
  2297.     if (segto == NO_SEG)
  2298. return;
  2300.     /*
  2301.      * If `any_segs' is still FALSE, we must define a default
  2302.      * segment.
  2303.      */
  2304.     if (!any_segs) {
  2305. int tempint;        /* ignored */
  2306. if (segto != obj_segment("__NASMDEFSEG", 2, &tempint))
  2307.     error (ERR_PANIC, "strange segment conditions in OBJ driver");
  2308.     }
  2310.     /*
  2311.      * Find the segment we are targetting.
  2312.      */
  2313.     for (seg = seghead; seg; seg = seg->next)
  2314. if (seg->index == segto)
  2315.     break;
  2316.     if (!seg)
  2317. error (ERR_PANIC, "lineno directed to nonexistent segment?");
  2319.     for (fn = fnhead; fn; fn = fnhead->next)
  2320. if (!nasm_stricmp(lnfname,fn->name))
  2321.     break;
  2322.     if (!fn) {
  2323. fn = nasm_malloc ( sizeof( *fn));
  2324. fn->name = nasm_malloc ( strlen(lnfname) + 1) ;
  2325.         strcpy (fn->name,lnfname);
  2326. fn->lnhead = NULL;
  2327. fn->lntail = & fn->lnhead;
  2328. fn->next = NULL;
  2329. *fntail = fn;
  2330. fntail = &fn->next;
  2331.     }
  2332.     ln = nasm_malloc ( sizeof( *ln));
  2333.     ln->segment = seg;
  2334.     ln->offset = seg->currentpos;
  2335.     ln->lineno = lineno;
  2336.     ln->next = NULL;
  2337.     *fn->lntail = ln;
  2338.     fn->lntail = &ln->next;
  2340. }
  2341. static void dbgbi_deflabel (char *name, long segment,
  2342.   long offset, int is_global, char *special) 
  2343. {
  2344.     struct Segment *seg;
  2346.     (void) special;
  2348.     /*
  2349.      * If it's a special-retry from pass two, discard it.
  2350.      */
  2351.     if (is_global == 3)
  2352. return;
  2354.     /*
  2355.      * First check for the double-period, signifying something
  2356.      * unusual.
  2357.      */
  2358.     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
  2359. return;
  2360.     }
  2362.     /*
  2363.      * Case (i):
  2364.      */
  2365.     if (obj_seg_needs_update) {
  2366. return;
  2367.     } else if (obj_grp_needs_update) {
  2368. return;
  2369.     }
  2370.     if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
  2371. return;
  2373.     if (segment >= SEG_ABS || segment == NO_SEG) {
  2374. return;
  2375.     }
  2377.     /*
  2378.      * If `any_segs' is still FALSE, we might need to define a
  2379.      * default segment, if they're trying to declare a label in
  2380.      * `first_seg'.  But the label should exist due to a prior
  2381.      * call to obj_deflabel so we can skip that.
  2382.      */
  2384.     for (seg = seghead; seg; seg = seg->next)
  2385. if (seg->index == segment) {
  2386.     struct Public *loc = nasm_malloc (sizeof(*loc));
  2387.     /*
  2388.      * Case (ii). Maybe MODPUB someday?
  2389.      */
  2390.     last_defined = *seg->loctail = loc;
  2391.     seg->loctail = &loc->next;
  2392.     loc->next = NULL;
  2393.     loc->name = nasm_strdup(name);
  2394.     loc->offset = offset;
  2395. }
  2396. }
  2397. static void dbgbi_typevalue (long type)
  2398. {
  2399.     int vsize;
  2400.     int elem = TYM_ELEMENTS(type);
  2401.     type = TYM_TYPE(type);
  2403.     if (!last_defined)
  2404. return;
  2406.     switch (type) {
  2407. case TY_BYTE:
  2408.     last_defined->type = 8; /* unsigned char */
  2409.     vsize = 1;
  2410.     break;
  2411. case TY_WORD:
  2412.     last_defined->type = 10; /* unsigned word */
  2413.     vsize = 2;
  2414.     break;
  2415. case TY_DWORD:
  2416.     last_defined->type = 12; /* unsigned dword */
  2417.     vsize = 4;
  2418.     break;
  2419. case TY_FLOAT:
  2420.     last_defined->type = 14; /* float */
  2421.     vsize = 4;
  2422.     break;
  2423. case TY_QWORD:
  2424.     last_defined->type = 15; /* qword */
  2425.     vsize = 8;
  2426.     break;
  2427. case TY_TBYTE:
  2428.     last_defined->type = 16; /* TBYTE */
  2429.     vsize = 10;
  2430.     break;
  2431. default:
  2432.     last_defined->type = 0x19; /*label */
  2433.     vsize = 0;
  2434.     break;
  2435.     }
  2436.                 
  2437.     if (elem > 1) {
  2438.         struct Array *arrtmp = nasm_malloc (sizeof(*arrtmp));
  2439.         int vtype = last_defined->type;
  2440.         arrtmp->size = vsize * elem;
  2441.         arrtmp->basetype = vtype;
  2442.         arrtmp->next = NULL;
  2443.         last_defined->type = arrindex++;
  2444.         *arrtail = arrtmp;
  2445.         arrtail = & (arrtmp->next);
  2446.     }
  2447.     last_defined = NULL;
  2448. }
  2449. static void dbgbi_output (int output_type, void *param)
  2450. {
  2451.     (void) output_type;
  2452.     (void) param;
  2453. }
  2454. static struct dfmt borland_debug_form = {
  2455.     "Borland Debug Records",
  2456.     "borland",
  2457.     dbgbi_init,
  2458.     dbgbi_linnum,
  2459.     dbgbi_deflabel,
  2460.     null_debug_routine,
  2461.     dbgbi_typevalue,
  2462.     dbgbi_output,
  2463.     dbgbi_cleanup,
  2464. };
  2466. static struct dfmt *borland_debug_arr[3] = {
  2467. &borland_debug_form,
  2468. &null_debug_form,
  2469. NULL
  2470. };
  2472. struct ofmt of_obj = {
  2473.     "MS-DOS 16-bit/32-bit OMF object files",
  2474.     "obj",
  2475.     NULL,
  2476.     borland_debug_arr,
  2477.     &null_debug_form,
  2478.     obj_stdmac,
  2479.     obj_init,
  2480.     obj_set_info,
  2481.     obj_out,
  2482.     obj_deflabel,
  2483.     obj_segment,
  2484.     obj_segbase,
  2485.     obj_directive,
  2486.     obj_filename,
  2487.     obj_cleanup
  2488. };
  2489. #endif /* OF_OBJ */