output/outieee.c

   1 /* outieee.c    output routines for the Netwide Assembler to produce
   2  *              IEEE-std 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  */
   9
  10 /* notes: I have tried to make this correspond to the IEEE version
  11  * of the standard, specifically the primary ASCII version.  It should
  12  * be trivial to create the binary version given this source (which is
  13  * one of MANY things that have to be done to make this correspond to
  14  * the hp-microtek version of the standard).
  15  *
  16  * 16-bit support is assumed to use 24-bit addresses
  17  * The linker can sort out segmentation-specific stuff
  18  * if it keeps track of externals
  19  * in terms of being relative to section bases
  20  *
  21  * A non-standard variable type, the 'Yn' variable, has been introduced.
  22  * Basically it is a reference to extern 'n'- denoting the low limit
  23  * (L-variable) of the section that extern 'n' is defined in.  Like the
  24  * x variable, there may be no explicit assignment to it, it is derived
  25  * from the public definition corresponding to the extern name.  This
  26  * is required because the one thing the mufom guys forgot to do well was
  27  * take into account segmented architectures.
  28  *
  29  * I use comment classes for various things and these are undefined by
  30  * the standard.
  31  *
  32  * Debug info should be considered totally non-standard (local labels are
  33  * standard but linenum records are not covered by the standard.
  34  * Type defs have the standard format but absolute meanings for ordinal
  35  * types are not covered by the standard.)
  36  *
  37  * David Lindauer, LADsoft
  38  */
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <time.h>
  43 #include <stdarg.h>             /* Note: we need the ANSI version of stdarg.h */
  44 #include <ctype.h>
  45 #include <inttypes.h>
  46
  47 #include "nasm.h"
  48 #include "nasmlib.h"
  49 #include "outform.h"
  50
  51 #ifdef OF_IEEE
  52
  53 #define ARRAY_BOT 0x1
  54
  55 static int8_t ieee_infile[FILENAME_MAX];
  56 static int ieee_uppercase;
  57
  58 static efunc error;
  59 static ldfunc deflabel;
  60 static FILE *ofp;
  61 static int any_segs;
  62 static int arrindex;
  63
  64 #define HUNKSIZE 1024           /* Size of the data hunk */
  65 #define EXT_BLKSIZ 512
  66 #define LDPERLINE 32            /* bytes per line in output */
  67
  68 struct ieeeSection;
  69
  70 struct LineNumber {
  71     struct LineNumber *next;
  72     struct ieeeSection *segment;
  73     int32_t offset;
  74     int32_t lineno;
  75 };
  76
  77 static struct FileName {
  78     struct FileName *next;
  79     int8_t *name;
  80     int32_t index;
  81 } *fnhead, **fntail;
  82
  83 static struct Array {
  84     struct Array *next;
  85     unsigned size;
  86     int basetype;
  87 } *arrhead, **arrtail;
  88
  89 static struct ieeePublic {
  90     struct ieeePublic *next;
  91     int8_t *name;
  92     int32_t offset;
  93     int32_t segment;               /* only if it's far-absolute */
  94     int32_t index;
  95     int type;                   /* for debug purposes */
  96 } *fpubhead, **fpubtail, *last_defined;
  97
  98 static struct ieeeExternal {
  99     struct ieeeExternal *next;
 100     int8_t *name;
 101     int32_t commonsize;
 102 } *exthead, **exttail;
 103
 104 static int externals;
 105
 106 static struct ExtBack {
 107     struct ExtBack *next;
 108     int index[EXT_BLKSIZ];
 109 } *ebhead, **ebtail;
 110
 111 /* NOTE: the first segment MUST be the lineno segment */
 112 static struct ieeeSection {
 113     struct ieeeObjData *data, *datacurr;
 114     struct ieeeSection *next;
 115     struct ieeeFixupp *fptr, *flptr;
 116     int32_t index;                 /* the NASM segment id */
 117     int32_t ieee_index;            /* the OBJ-file segment index */
 118     int32_t currentpos;
 119     int32_t align;                 /* can be SEG_ABS + absolute addr */
 120     int32_t startpos;
 121     enum {
 122         CMB_PRIVATE = 0,
 123         CMB_PUBLIC = 2,
 124         CMB_COMMON = 6
 125     } combine;
 126     int32_t use32;                 /* is this segment 32-bit? */
 127     struct ieeePublic *pubhead, **pubtail, *lochead, **loctail;
 128     int8_t *name;
 129 } *seghead, **segtail, *ieee_seg_needs_update;
 130
 131 struct ieeeObjData {
 132     struct ieeeObjData *next;
 133     uint8_t data[HUNKSIZE];
 134 };
 135
 136 struct ieeeFixupp {
 137     struct ieeeFixupp *next;
 138     enum {
 139         FT_SEG = 0,
 140         FT_REL = 1,
 141         FT_OFS = 2,
 142         FT_EXT = 3,
 143         FT_WRT = 4,
 144         FT_EXTREL = 5,
 145         FT_EXTWRT = 6,
 146         FT_EXTSEG = 7
 147     } ftype;
 148     int16_t size;
 149     int32_t id1;
 150     int32_t id2;
 151     int32_t offset;
 152     int32_t addend;
 153 };
 154
 155 static int32_t ieee_entry_seg, ieee_entry_ofs;
 156 static int checksum;
 157
 158 extern struct ofmt of_ieee;
 159
 160 static void ieee_data_new(struct ieeeSection *);
 161 static void ieee_write_fixup(int32_t, int32_t, struct ieeeSection *,
 162                              int, uint32_t, int32_t);
 163 static void ieee_install_fixup(struct ieeeSection *, struct ieeeFixupp *);
 164 static int32_t ieee_segment(int8_t *, int, int *);
 165 static void ieee_write_file(int debuginfo);
 166 static void ieee_write_byte(struct ieeeSection *, int);
 167 static void ieee_write_word(struct ieeeSection *, int);
 168 static void ieee_write_dword(struct ieeeSection *, int32_t);
 169 static void ieee_putascii(int8_t *, ...);
 170 static void ieee_putcs(int);
 171 static int32_t ieee_putld(int32_t, int32_t, uint8_t *);
 172 static int32_t ieee_putlr(struct ieeeFixupp *);
 173 static void ieee_unqualified_name(int8_t *, int8_t *);
 174
 175 /*
 176  * pup init
 177  */
 178 static void ieee_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
 179 {
 180     (void)eval;
 181     ofp = fp;
 182     error = errfunc;
 183     deflabel = ldef;
 184     any_segs = FALSE;
 185     fpubhead = NULL;
 186     fpubtail = &fpubhead;
 187     exthead = NULL;
 188     exttail = &exthead;
 189     externals = 1;
 190     ebhead = NULL;
 191     ebtail = &ebhead;
 192     seghead = ieee_seg_needs_update = NULL;
 193     segtail = &seghead;
 194     ieee_entry_seg = NO_SEG;
 195     ieee_uppercase = FALSE;
 196     checksum = 0;
 197     of_ieee.current_dfmt->init(&of_ieee, NULL, fp, errfunc);
 198 }
 199 static int ieee_set_info(enum geninfo type, int8_t **val)
 200 {
 201     (void)type;
 202     (void)val;
 203
 204     return 0;
 205 }
 206
 207 /*
 208  * Rundown
 209  */
 210 static void ieee_cleanup(int debuginfo)
 211 {
 212     ieee_write_file(debuginfo);
 213     of_ieee.current_dfmt->cleanup();
 214     fclose(ofp);
 215     while (seghead) {
 216         struct ieeeSection *segtmp = seghead;
 217         seghead = seghead->next;
 218         while (segtmp->pubhead) {
 219             struct ieeePublic *pubtmp = segtmp->pubhead;
 220             segtmp->pubhead = pubtmp->next;
 221             nasm_free(pubtmp);
 222         }
 223         while (segtmp->fptr) {
 224             struct ieeeFixupp *fixtmp = segtmp->fptr;
 225             segtmp->fptr = fixtmp->next;
 226             nasm_free(fixtmp);
 227         }
 228         while (segtmp->data) {
 229             struct ieeeObjData *dattmp = segtmp->data;
 230             segtmp->data = dattmp->next;
 231             nasm_free(dattmp);
 232         }
 233         nasm_free(segtmp);
 234     }
 235     while (fpubhead) {
 236         struct ieeePublic *pubtmp = fpubhead;
 237         fpubhead = fpubhead->next;
 238         nasm_free(pubtmp);
 239     }
 240     while (exthead) {
 241         struct ieeeExternal *exttmp = exthead;
 242         exthead = exthead->next;
 243         nasm_free(exttmp);
 244     }
 245     while (ebhead) {
 246         struct ExtBack *ebtmp = ebhead;
 247         ebhead = ebhead->next;
 248         nasm_free(ebtmp);
 249     }
 250 }
 251
 252 /*
 253  * callback for labels
 254  */
 255 static void ieee_deflabel(int8_t *name, int32_t segment,
 256                           int32_t offset, int is_global, int8_t *special)
 257 {
 258     /*
 259      * We have three cases:
 260      *
 261      * (i) `segment' is a segment-base. If so, set the name field
 262      * for the segment structure it refers to, and then
 263      * return.
 264      *
 265      * (ii) `segment' is one of our segments, or a SEG_ABS segment.
 266      * Save the label position for later output of a PUBDEF record.
 267      *
 268      *
 269      * (iii) `segment' is not one of our segments. Save the label
 270      * position for later output of an EXTDEF.
 271      */
 272     struct ieeeExternal *ext;
 273     struct ExtBack *eb;
 274     struct ieeeSection *seg;
 275     int i;
 276
 277     if (special) {
 278         error(ERR_NONFATAL, "unrecognised symbol type `%s'", special);
 279     }
 280     /*
 281      * First check for the double-period, signifying something
 282      * unusual.
 283      */
 284     if (name[0] == '.' && name[1] == '.') {
 285         if (!strcmp(name, "..start")) {
 286             ieee_entry_seg = segment;
 287             ieee_entry_ofs = offset;
 288         }
 289         return;
 290     }
 291
 292     /*
 293      * Case (i):
 294      */
 295     if (ieee_seg_needs_update) {
 296         ieee_seg_needs_update->name = name;
 297         return;
 298     }
 299     if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
 300         return;
 301
 302     /*
 303      * case (ii)
 304      */
 305     if (segment >= SEG_ABS) {
 306         /*
 307          * SEG_ABS subcase of (ii).
 308          */
 309         if (is_global) {
 310             struct ieeePublic *pub;
 311
 312             pub = *fpubtail = nasm_malloc(sizeof(*pub));
 313             fpubtail = &pub->next;
 314             pub->next = NULL;
 315             pub->name = name;
 316             pub->offset = offset;
 317             pub->segment = segment & ~SEG_ABS;
 318         }
 319         return;
 320     }
 321
 322     for (seg = seghead; seg && is_global; seg = seg->next)
 323         if (seg->index == segment) {
 324             struct ieeePublic *pub;
 325
 326             last_defined = pub = *seg->pubtail = nasm_malloc(sizeof(*pub));
 327             seg->pubtail = &pub->next;
 328             pub->next = NULL;
 329             pub->name = name;
 330             pub->offset = offset;
 331             pub->index = seg->ieee_index;
 332             pub->segment = -1;
 333             return;
 334         }
 335
 336     /*
 337      * Case (iii).
 338      */
 339     if (is_global) {
 340         ext = *exttail = nasm_malloc(sizeof(*ext));
 341         ext->next = NULL;
 342         exttail = &ext->next;
 343         ext->name = name;
 344         if (is_global == 2)
 345             ext->commonsize = offset;
 346         else
 347             ext->commonsize = 0;
 348         i = segment / 2;
 349         eb = ebhead;
 350         if (!eb) {
 351             eb = *ebtail = nasm_malloc(sizeof(*eb));
 352             eb->next = NULL;
 353             ebtail = &eb->next;
 354         }
 355         while (i > EXT_BLKSIZ) {
 356             if (eb && eb->next)
 357                 eb = eb->next;
 358             else {
 359                 eb = *ebtail = nasm_malloc(sizeof(*eb));
 360                 eb->next = NULL;
 361                 ebtail = &eb->next;
 362             }
 363             i -= EXT_BLKSIZ;
 364         }
 365         eb->index[i] = externals++;
 366     }
 367
 368 }
 369
 370 /*
 371  * Put data out
 372  */
 373 static void ieee_out(int32_t segto, const void *data, uint32_t type,
 374                      int32_t segment, int32_t wrt)
 375 {
 376     uint32_t size, realtype;
 377     const uint8_t *ucdata;
 378     int32_t ldata;
 379     struct ieeeSection *seg;
 380
 381     /*
 382      * handle absolute-assembly (structure definitions)
 383      */
 384     if (segto == NO_SEG) {
 385         if ((type & OUT_TYPMASK) != OUT_RESERVE)
 386             error(ERR_NONFATAL, "attempt to assemble code in [ABSOLUTE]"
 387                   " space");
 388         return;
 389     }
 390
 391     /*
 392      * If `any_segs' is still FALSE, we must define a default
 393      * segment.
 394      */
 395     if (!any_segs) {
 396         int tempint;            /* ignored */
 397         if (segto != ieee_segment("__NASMDEFSEG", 2, &tempint))
 398             error(ERR_PANIC, "strange segment conditions in IEEE driver");
 399     }
 400
 401     /*
 402      * Find the segment we are targetting.
 403      */
 404     for (seg = seghead; seg; seg = seg->next)
 405         if (seg->index == segto)
 406             break;
 407     if (!seg)
 408         error(ERR_PANIC, "code directed to nonexistent segment?");
 409
 410     size = type & OUT_SIZMASK;
 411     realtype = type & OUT_TYPMASK;
 412     if (realtype == OUT_RAWDATA) {
 413         ucdata = data;
 414         while (size--)
 415             ieee_write_byte(seg, *ucdata++);
 416     } else if (realtype == OUT_ADDRESS || realtype == OUT_REL2ADR ||
 417                realtype == OUT_REL4ADR) {
 418         if (segment == NO_SEG && realtype != OUT_ADDRESS)
 419             error(ERR_NONFATAL, "relative call to absolute address not"
 420                   " supported by IEEE format");
 421         ldata = *(int32_t *)data;
 422         if (realtype == OUT_REL2ADR)
 423             ldata += (size - 2);
 424         if (realtype == OUT_REL4ADR)
 425             ldata += (size - 4);
 426         ieee_write_fixup(segment, wrt, seg, size, realtype, ldata);
 427         if (size == 2)
 428             ieee_write_word(seg, ldata);
 429         else
 430             ieee_write_dword(seg, ldata);
 431     } else if (realtype == OUT_RESERVE) {
 432         while (size--)
 433             ieee_write_byte(seg, 0);
 434     }
 435 }
 436
 437 static void ieee_data_new(struct ieeeSection *segto)
 438 {
 439
 440     if (!segto->data)
 441         segto->data = segto->datacurr =
 442             nasm_malloc(sizeof(*(segto->datacurr)));
 443     else
 444         segto->datacurr = segto->datacurr->next =
 445             nasm_malloc(sizeof(*(segto->datacurr)));
 446     segto->datacurr->next = NULL;
 447 }
 448
 449 /*
 450  * this routine is unalduterated bloatware.  I usually don't do this
 451  * but I might as well see what it is like on a harmless program.
 452  * If anyone wants to optimize this is a good canditate!
 453  */
 454 static void ieee_write_fixup(int32_t segment, int32_t wrt,
 455                              struct ieeeSection *segto, int size,
 456                              uint32_t realtype, int32_t offset)
 457 {
 458     struct ieeeSection *target;
 459     struct ieeeFixupp s;
 460
 461     /* Don't put a fixup for things NASM can calculate */
 462     if (wrt == NO_SEG && segment == NO_SEG)
 463         return;
 464
 465     s.ftype = -1;
 466     /* if it is a WRT offset */
 467     if (wrt != NO_SEG) {
 468         s.ftype = FT_WRT;
 469         s.addend = offset;
 470         if (wrt >= SEG_ABS)
 471             s.id1 = -(wrt - SEG_ABS);
 472         else {
 473             if (wrt % 2 && realtype != OUT_REL2ADR
 474                 && realtype != OUT_REL4ADR) {
 475                 wrt--;
 476
 477                 for (target = seghead; target; target = target->next)
 478                     if (target->index == wrt)
 479                         break;
 480                 if (target) {
 481                     s.id1 = target->ieee_index;
 482                     for (target = seghead; target; target = target->next)
 483                         if (target->index == segment)
 484                             break;
 485
 486                     if (target)
 487                         s.id2 = target->ieee_index;
 488                     else {
 489                         /*
 490                          * Now we assume the segment field is being used
 491                          * to hold an extern index
 492                          */
 493                         int32_t i = segment / 2;
 494                         struct ExtBack *eb = ebhead;
 495                         while (i > EXT_BLKSIZ) {
 496                             if (eb)
 497                                 eb = eb->next;
 498                             else
 499                                 break;
 500                             i -= EXT_BLKSIZ;
 501                         }
 502                         /* if we have an extern decide the type and make a record
 503                          */
 504                         if (eb) {
 505                             s.ftype = FT_EXTWRT;
 506                             s.addend = 0;
 507                             s.id2 = eb->index[i];
 508                         } else
 509                             error(ERR_NONFATAL,
 510                                   "Source of WRT must be an offset");
 511                     }
 512
 513                 } else
 514                     error(ERR_PANIC,
 515                           "unrecognised WRT value in ieee_write_fixup");
 516             } else
 517                 error(ERR_NONFATAL, "target of WRT must be a section ");
 518         }
 519         s.size = size;
 520         ieee_install_fixup(segto, &s);
 521         return;
 522     }
 523     /* Pure segment fixup ? */
 524     if (segment != NO_SEG) {
 525         s.ftype = FT_SEG;
 526         s.id1 = 0;
 527         if (segment >= SEG_ABS) {
 528             /* absolute far segment fixup */
 529             s.id1 = -(segment - ~SEG_ABS);
 530         } else if (segment % 2) {
 531             /* fixup to named segment */
 532             /* look it up */
 533             for (target = seghead; target; target = target->next)
 534                 if (target->index == segment - 1)
 535                     break;
 536             if (target)
 537                 s.id1 = target->ieee_index;
 538             else {
 539                 /*
 540                  * Now we assume the segment field is being used
 541                  * to hold an extern index
 542                  */
 543                 int32_t i = segment / 2;
 544                 struct ExtBack *eb = ebhead;
 545                 while (i > EXT_BLKSIZ) {
 546                     if (eb)
 547                         eb = eb->next;
 548                     else
 549                         break;
 550                     i -= EXT_BLKSIZ;
 551                 }
 552                 /* if we have an extern decide the type and make a record
 553                  */
 554                 if (eb) {
 555                     if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
 556                         error(ERR_PANIC,
 557                               "Segment of a rel not supported in ieee_write_fixup");
 558                     } else {
 559                         /* If we want the segment */
 560                         s.ftype = FT_EXTSEG;
 561                         s.addend = 0;
 562                         s.id1 = eb->index[i];
 563                     }
 564
 565                 } else
 566                     /* If we get here the seg value doesn't make sense */
 567                     error(ERR_PANIC,
 568                           "unrecognised segment value in ieee_write_fixup");
 569             }
 570
 571         } else {
 572             /* Assume we are offsetting directly from a section
 573              * So look up the target segment
 574              */
 575             for (target = seghead; target; target = target->next)
 576                 if (target->index == segment)
 577                     break;
 578             if (target) {
 579                 if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
 580                     /* PC rel to a known offset */
 581                     s.id1 = target->ieee_index;
 582                     s.ftype = FT_REL;
 583                     s.size = size;
 584                     s.addend = offset;
 585                 } else {
 586                     /* We were offsetting from a seg */
 587                     s.id1 = target->ieee_index;
 588                     s.ftype = FT_OFS;
 589                     s.size = size;
 590                     s.addend = offset;
 591                 }
 592             } else {
 593                 /*
 594                  * Now we assume the segment field is being used
 595                  * to hold an extern index
 596                  */
 597                 int32_t i = segment / 2;
 598                 struct ExtBack *eb = ebhead;
 599                 while (i > EXT_BLKSIZ) {
 600                     if (eb)
 601                         eb = eb->next;
 602                     else
 603                         break;
 604                     i -= EXT_BLKSIZ;
 605                 }
 606                 /* if we have an extern decide the type and make a record
 607                  */
 608                 if (eb) {
 609                     if (realtype == OUT_REL2ADR || realtype == OUT_REL4ADR) {
 610                         s.ftype = FT_EXTREL;
 611                         s.addend = 0;
 612                         s.id1 = eb->index[i];
 613                     } else {
 614                         /* else we want the external offset */
 615                         s.ftype = FT_EXT;
 616                         s.addend = 0;
 617                         s.id1 = eb->index[i];
 618                     }
 619
 620                 } else
 621                     /* If we get here the seg value doesn't make sense */
 622                     error(ERR_PANIC,
 623                           "unrecognised segment value in ieee_write_fixup");
 624             }
 625         }
 626         if (size != 2 && s.ftype == FT_SEG)
 627             error(ERR_NONFATAL, "IEEE format can only handle 2-byte"
 628                   " segment base references");
 629         s.size = size;
 630         ieee_install_fixup(segto, &s);
 631         return;
 632     }
 633     /* should never get here */
 634 }
 635 static void ieee_install_fixup(struct ieeeSection *seg,
 636                                struct ieeeFixupp *fix)
 637 {
 638     struct ieeeFixupp *f;
 639     f = nasm_malloc(sizeof(struct ieeeFixupp));
 640     memcpy(f, fix, sizeof(struct ieeeFixupp));
 641     f->offset = seg->currentpos;
 642     seg->currentpos += fix->size;
 643     f->next = NULL;
 644     if (seg->fptr)
 645         seg->flptr = seg->flptr->next = f;
 646     else
 647         seg->fptr = seg->flptr = f;
 648
 649 }
 650
 651 /*
 652  * segment registry
 653  */
 654 static int32_t ieee_segment(int8_t *name, int pass, int *bits)
 655 {
 656     /*
 657      * We call the label manager here to define a name for the new
 658      * segment, and when our _own_ label-definition stub gets
 659      * called in return, it should register the new segment name
 660      * using the pointer it gets passed. That way we save memory,
 661      * by sponging off the label manager.
 662      */
 663     if (!name) {
 664         *bits = 16;
 665         if (!any_segs)
 666             return 0;
 667         return seghead->index;
 668     } else {
 669         struct ieeeSection *seg;
 670         int ieee_idx, attrs, rn_error;
 671         int8_t *p;
 672
 673         /*
 674          * Look for segment attributes.
 675          */
 676         attrs = 0;
 677         while (*name == '.')
 678             name++;             /* hack, but a documented one */
 679         p = name;
 680         while (*p && !isspace(*p))
 681             p++;
 682         if (*p) {
 683             *p++ = '\0';
 684             while (*p && isspace(*p))
 685                 *p++ = '\0';
 686         }
 687         while (*p) {
 688             while (*p && !isspace(*p))
 689                 p++;
 690             if (*p) {
 691                 *p++ = '\0';
 692                 while (*p && isspace(*p))
 693                     *p++ = '\0';
 694             }
 695
 696             attrs++;
 697         }
 698
 699         ieee_idx = 1;
 700         for (seg = seghead; seg; seg = seg->next) {
 701             ieee_idx++;
 702             if (!strcmp(seg->name, name)) {
 703                 if (attrs > 0 && pass == 1)
 704                     error(ERR_WARNING, "segment attributes specified on"
 705                           " redeclaration of segment: ignoring");
 706                 if (seg->use32)
 707                     *bits = 32;
 708                 else
 709                     *bits = 16;
 710                 return seg->index;
 711             }
 712         }
 713
 714         *segtail = seg = nasm_malloc(sizeof(*seg));
 715         seg->next = NULL;
 716         segtail = &seg->next;
 717         seg->index = seg_alloc();
 718         seg->ieee_index = ieee_idx;
 719         any_segs = TRUE;
 720         seg->name = NULL;
 721         seg->currentpos = 0;
 722         seg->align = 1;         /* default */
 723         seg->use32 = *bits == 32;       /* default to user spec */
 724         seg->combine = CMB_PUBLIC;      /* default */
 725         seg->pubhead = NULL;
 726         seg->pubtail = &seg->pubhead;
 727         seg->data = NULL;
 728         seg->fptr = NULL;
 729         seg->lochead = NULL;
 730         seg->loctail = &seg->lochead;
 731
 732         /*
 733          * Process the segment attributes.
 734          */
 735         p = name;
 736         while (attrs--) {
 737             p += strlen(p);
 738             while (!*p)
 739                 p++;
 740
 741             /*
 742              * `p' contains a segment attribute.
 743              */
 744             if (!nasm_stricmp(p, "private"))
 745                 seg->combine = CMB_PRIVATE;
 746             else if (!nasm_stricmp(p, "public"))
 747                 seg->combine = CMB_PUBLIC;
 748             else if (!nasm_stricmp(p, "common"))
 749                 seg->combine = CMB_COMMON;
 750             else if (!nasm_stricmp(p, "use16"))
 751                 seg->use32 = FALSE;
 752             else if (!nasm_stricmp(p, "use32"))
 753                 seg->use32 = TRUE;
 754             else if (!nasm_strnicmp(p, "align=", 6)) {
 755                 seg->align = readnum(p + 6, &rn_error);
 756                 if (seg->align == 0)
 757                     seg->align = 1;
 758                 if (rn_error) {
 759                     seg->align = 1;
 760                     error(ERR_NONFATAL, "segment alignment should be"
 761                           " numeric");
 762                 }
 763                 switch ((int)seg->align) {
 764                 case 1:        /* BYTE */
 765                 case 2:        /* WORD */
 766                 case 4:        /* DWORD */
 767                 case 16:       /* PARA */
 768                 case 256:      /* PAGE */
 769                 case 8:
 770                 case 32:
 771                 case 64:
 772                 case 128:
 773                     break;
 774                 default:
 775                     error(ERR_NONFATAL, "invalid alignment value %d",
 776                           seg->align);
 777                     seg->align = 1;
 778                     break;
 779                 }
 780             } else if (!nasm_strnicmp(p, "absolute=", 9)) {
 781                 seg->align = SEG_ABS + readnum(p + 9, &rn_error);
 782                 if (rn_error)
 783                     error(ERR_NONFATAL, "argument to `absolute' segment"
 784                           " attribute should be numeric");
 785             }
 786         }
 787
 788         ieee_seg_needs_update = seg;
 789         if (seg->align >= SEG_ABS)
 790             deflabel(name, NO_SEG, seg->align - SEG_ABS,
 791                      NULL, FALSE, FALSE, &of_ieee, error);
 792         else
 793             deflabel(name, seg->index + 1, 0L,
 794                      NULL, FALSE, FALSE, &of_ieee, error);
 795         ieee_seg_needs_update = NULL;
 796
 797         if (seg->use32)
 798             *bits = 32;
 799         else
 800             *bits = 16;
 801         return seg->index;
 802     }
 803 }
 804
 805 /*
 806  * directives supported
 807  */
 808 static int ieee_directive(int8_t *directive, int8_t *value, int pass)
 809 {
 810
 811     (void)value;
 812     (void)pass;
 813     if (!strcmp(directive, "uppercase")) {
 814         ieee_uppercase = TRUE;
 815         return 1;
 816     }
 817     return 0;
 818 }
 819
 820 /*
 821  * Return segment data
 822  */
 823 static int32_t ieee_segbase(int32_t segment)
 824 {
 825     struct ieeeSection *seg;
 826
 827     /*
 828      * Find the segment in our list.
 829      */
 830     for (seg = seghead; seg; seg = seg->next)
 831         if (seg->index == segment - 1)
 832             break;
 833
 834     if (!seg)
 835         return segment;         /* not one of ours - leave it alone */
 836
 837     if (seg->align >= SEG_ABS)
 838         return seg->align;      /* absolute segment */
 839
 840     return segment;             /* no special treatment */
 841 }
 842
 843 /*
 844  * filename
 845  */
 846 static void ieee_filename(int8_t *inname, int8_t *outname, efunc error)
 847 {
 848     strcpy(ieee_infile, inname);
 849     standard_extension(inname, outname, ".o", error);
 850 }
 851
 852 static void ieee_write_file(int debuginfo)
 853 {
 854     struct tm *thetime;
 855     time_t reltime;
 856     struct FileName *fn;
 857     struct ieeeSection *seg;
 858     struct ieeePublic *pub, *loc;
 859     struct ieeeExternal *ext;
 860     struct ieeeObjData *data;
 861     struct ieeeFixupp *fix;
 862     struct Array *arr;
 863     static int8_t boast[] = "The Netwide Assembler " NASM_VER;
 864     int i;
 865
 866     /*
 867      * Write the module header
 868      */
 869     ieee_putascii("MBFNASM,%02X%s.\r\n", strlen(ieee_infile), ieee_infile);
 870
 871     /*
 872      * Write the NASM boast comment.
 873      */
 874     ieee_putascii("CO0,%02X%s.\r\n", strlen(boast), boast);
 875
 876     /*
 877      * write processor-specific information
 878      */
 879     ieee_putascii("AD8,4,L.\r\n");
 880
 881     /*
 882      * date and time
 883      */
 884     time(&reltime);
 885     thetime = localtime(&reltime);
 886     ieee_putascii("DT%04d%02d%02d%02d%02d%02d.\r\n",
 887                   1900 + thetime->tm_year, thetime->tm_mon + 1,
 888                   thetime->tm_mday, thetime->tm_hour, thetime->tm_min,
 889                   thetime->tm_sec);
 890     /*
 891      * if debugging, dump file names
 892      */
 893     for (fn = fnhead; fn && debuginfo; fn = fn->next) {
 894         ieee_putascii("C0105,%02X%s.\r\n", strlen(fn->name), fn->name);
 895     }
 896
 897     ieee_putascii("CO101,07ENDHEAD.\r\n");
 898     /*
 899      * the standard doesn't specify when to put checksums,
 900      * we'll just do it periodically.
 901      */
 902     ieee_putcs(FALSE);
 903
 904     /*
 905      * Write the section headers
 906      */
 907     seg = seghead;
 908     if (!debuginfo && !strcmp(seg->name, "??LINE"))
 909         seg = seg->next;
 910     while (seg) {
 911         int8_t buf[256];
 912         int8_t attrib;
 913         switch (seg->combine) {
 914         case CMB_PUBLIC:
 915         default:
 916             attrib = 'C';
 917             break;
 918         case CMB_PRIVATE:
 919             attrib = 'S';
 920             break;
 921         case CMB_COMMON:
 922             attrib = 'M';
 923             break;
 924         }
 925         ieee_unqualified_name(buf, seg->name);
 926         if (seg->align >= SEG_ABS) {
 927             ieee_putascii("ST%X,A,%02X%s.\r\n", seg->ieee_index,
 928                           strlen(buf), buf);
 929             ieee_putascii("ASL%X,%lX.\r\n", seg->ieee_index,
 930                           (seg->align - SEG_ABS) * 16);
 931         } else {
 932             ieee_putascii("ST%X,%c,%02X%s.\r\n", seg->ieee_index, attrib,
 933                           strlen(buf), buf);
 934             ieee_putascii("SA%X,%lX.\r\n", seg->ieee_index, seg->align);
 935             ieee_putascii("ASS%X,%X.\r\n", seg->ieee_index,
 936                           seg->currentpos);
 937         }
 938         seg = seg->next;
 939     }
 940     /*
 941      * write the start address if there is one
 942      */
 943     if (ieee_entry_seg) {
 944         for (seg = seghead; seg; seg = seg->next)
 945             if (seg->index == ieee_entry_seg)
 946                 break;
 947         if (!seg)
 948             error(ERR_PANIC, "Start address records are incorrect");
 949         else
 950             ieee_putascii("ASG,R%X,%lX,+.\r\n", seg->ieee_index,
 951                           ieee_entry_ofs);
 952     }
 953
 954     ieee_putcs(FALSE);
 955     /*
 956      * Write the publics
 957      */
 958     i = 1;
 959     for (seg = seghead; seg; seg = seg->next) {
 960         for (pub = seg->pubhead; pub; pub = pub->next) {
 961             int8_t buf[256];
 962             ieee_unqualified_name(buf, pub->name);
 963             ieee_putascii("NI%X,%02X%s.\r\n", i, strlen(buf), buf);
 964             if (pub->segment == -1)
 965                 ieee_putascii("ASI%X,R%X,%lX,+.\r\n", i, pub->index,
 966                               pub->offset);
 967             else
 968                 ieee_putascii("ASI%X,%lX,%lX,+.\r\n", i, pub->segment * 16,
 969                               pub->offset);
 970             if (debuginfo) {
 971                 if (pub->type >= 0x100)
 972                     ieee_putascii("ATI%X,T%X.\r\n", i, pub->type - 0x100);
 973                 else
 974                     ieee_putascii("ATI%X,%X.\r\n", i, pub->type);
 975             }
 976             i++;
 977         }
 978     }
 979     pub = fpubhead;
 980     i = 1;
 981     while (pub) {
 982         int8_t buf[256];
 983         ieee_unqualified_name(buf, pub->name);
 984         ieee_putascii("NI%X,%02X%s.\r\n", i, strlen(buf), buf);
 985         if (pub->segment == -1)
 986             ieee_putascii("ASI%X,R%X,%lX,+.\r\n", i, pub->index,
 987                           pub->offset);
 988         else
 989             ieee_putascii("ASI%X,%lX,%lX,+.\r\n", i, pub->segment * 16,
 990                           pub->offset);
 991         if (debuginfo) {
 992             if (pub->type >= 0x100)
 993                 ieee_putascii("ATI%X,T%X.\r\n", i, pub->type - 0x100);
 994             else
 995                 ieee_putascii("ATI%X,%X.\r\n", i, pub->type);
 996         }
 997         i++;
 998         pub = pub->next;
 999     }
1000     /*
1001      * Write the externals
1002      */
1003     ext = exthead;
1004     i = 1;
1005     while (ext) {
1006         int8_t buf[256];
1007         ieee_unqualified_name(buf, ext->name);
1008         ieee_putascii("NX%X,%02X%s.\r\n", i++, strlen(buf), buf);
1009         ext = ext->next;
1010     }
1011     ieee_putcs(FALSE);
1012
1013     /*
1014      * IEEE doesn't have a standard pass break record
1015      * so use the ladsoft variant
1016      */
1017     ieee_putascii("CO100,06ENDSYM.\r\n");
1018
1019     /*
1020      * now put types
1021      */
1022     i = ARRAY_BOT;
1023     for (arr = arrhead; arr && debuginfo; arr = arr->next) {
1024         ieee_putascii("TY%X,20,%X,%lX.\r\n", i++, arr->basetype,
1025                       arr->size);
1026     }
1027     /*
1028      * now put locals
1029      */
1030     i = 1;
1031     for (seg = seghead; seg && debuginfo; seg = seg->next) {
1032         for (loc = seg->lochead; loc; loc = loc->next) {
1033             int8_t buf[256];
1034             ieee_unqualified_name(buf, loc->name);
1035             ieee_putascii("NN%X,%02X%s.\r\n", i, strlen(buf), buf);
1036             if (loc->segment == -1)
1037                 ieee_putascii("ASN%X,R%X,%lX,+.\r\n", i, loc->index,
1038                               loc->offset);
1039             else
1040                 ieee_putascii("ASN%X,%lX,%lX,+.\r\n", i, loc->segment * 16,
1041                               loc->offset);
1042             if (debuginfo) {
1043                 if (loc->type >= 0x100)
1044                     ieee_putascii("ATN%X,T%X.\r\n", i, loc->type - 0x100);
1045                 else
1046                     ieee_putascii("ATN%X,%X.\r\n", i, loc->type);
1047             }
1048             i++;
1049         }
1050     }
1051
1052     /*
1053      *  put out section data;
1054      */
1055     seg = seghead;
1056     if (!debuginfo && !strcmp(seg->name, "??LINE"))
1057         seg = seg->next;
1058     while (seg) {
1059         if (seg->currentpos) {
1060             int32_t size, org = 0;
1061             data = seg->data;
1062             ieee_putascii("SB%X.\r\n", seg->ieee_index);
1063             fix = seg->fptr;
1064             while (fix) {
1065                 size = HUNKSIZE - (org % HUNKSIZE);
1066                 size =
1067                     size + org >
1068                     seg->currentpos ? seg->currentpos - org : size;
1069                 size = fix->offset - org > size ? size : fix->offset - org;
1070                 org = ieee_putld(org, org + size, data->data);
1071                 if (org % HUNKSIZE == 0)
1072                     data = data->next;
1073                 if (org == fix->offset) {
1074                     org += ieee_putlr(fix);
1075                     fix = fix->next;
1076                 }
1077             }
1078             while (org < seg->currentpos && data) {
1079                 size =
1080                     seg->currentpos - org >
1081                     HUNKSIZE ? HUNKSIZE : seg->currentpos - org;
1082                 org = ieee_putld(org, org + size, data->data);
1083                 data = data->next;
1084             }
1085             ieee_putcs(FALSE);
1086
1087         }
1088         seg = seg->next;
1089     }
1090     /*
1091      * module end record
1092      */
1093     ieee_putascii("ME.\r\n");
1094 }
1095
1096 static void ieee_write_byte(struct ieeeSection *seg, int data)
1097 {
1098     int temp;
1099     if (!(temp = seg->currentpos++ % HUNKSIZE))
1100         ieee_data_new(seg);
1101     seg->datacurr->data[temp] = data;
1102 }
1103
1104 static void ieee_write_word(struct ieeeSection *seg, int data)
1105 {
1106     ieee_write_byte(seg, data & 0xFF);
1107     ieee_write_byte(seg, (data >> 8) & 0xFF);
1108 }
1109
1110 static void ieee_write_dword(struct ieeeSection *seg, int32_t data)
1111 {
1112     ieee_write_byte(seg, data & 0xFF);
1113     ieee_write_byte(seg, (data >> 8) & 0xFF);
1114     ieee_write_byte(seg, (data >> 16) & 0xFF);
1115     ieee_write_byte(seg, (data >> 24) & 0xFF);
1116 }
1117 static void ieee_putascii(int8_t *format, ...)
1118 {
1119     int8_t buffer[256];
1120     int i, l;
1121     va_list ap;
1122
1123     va_start(ap, format);
1124     vsnprintf(buffer, sizeof(buffer), format, ap);
1125     l = strlen(buffer);
1126     for (i = 0; i < l; i++)
1127         if ((buffer[i] & 0xff) > 31)
1128             checksum += buffer[i];
1129     va_end(ap);
1130     fprintf(ofp, buffer);
1131 }
1132
1133 /*
1134  * put out a checksum record */
1135 static void ieee_putcs(int toclear)
1136 {
1137     if (toclear) {
1138         ieee_putascii("CS.\r\n");
1139     } else {
1140         checksum += 'C';
1141         checksum += 'S';
1142         ieee_putascii("CS%02X.\r\n", checksum & 127);
1143     }
1144     checksum = 0;
1145 }
1146
1147 static int32_t ieee_putld(int32_t start, int32_t end, uint8_t *buf)
1148 {
1149     int32_t val;
1150     if (start == end)
1151         return (start);
1152     val = start % HUNKSIZE;
1153     /* fill up multiple lines */
1154     while (end - start >= LDPERLINE) {
1155         int i;
1156         ieee_putascii("LD");
1157         for (i = 0; i < LDPERLINE; i++) {
1158             ieee_putascii("%02X", buf[val++]);
1159             start++;
1160         }
1161         ieee_putascii(".\r\n");
1162     }
1163     /* if no partial lines */
1164     if (start == end)
1165         return (start);
1166     /* make a partial line */
1167     ieee_putascii("LD");
1168     while (start < end) {
1169         ieee_putascii("%02X", buf[val++]);
1170         start++;
1171     }
1172     ieee_putascii(".\r\n");
1173     return (start);
1174 }
1175 static int32_t ieee_putlr(struct ieeeFixupp *p)
1176 {
1177 /*
1178  * To deal with the vagaries of segmentation the LADsoft linker
1179  * defines two types of segments: absolute and virtual.  Note that
1180  * 'absolute' in this context is a different thing from the IEEE
1181  * definition of an absolute segment type, which is also supported. If a
1182  * sement is linked in virtual mode the low limit (L-var) is
1183  * subtracted from each R,X, and P variable which appears in an
1184  * expression, so that we can have relative offsets.  Meanwhile
1185  * in the ABSOLUTE mode this subtraction is not done and
1186  * so we can use absolute offsets from 0.  In the LADsoft linker
1187  * this configuration is not done in the assemblker source but in
1188  * a source the linker reads.  Generally this type of thing only
1189  * becomes an issue if real mode code is used.  A pure 32-bit linker could
1190  * get away without defining the virtual mode...
1191  */
1192     int8_t buf[40];
1193     int32_t size = p->size;
1194     switch (p->ftype) {
1195     case FT_SEG:
1196         if (p->id1 < 0)
1197             sprintf(buf, "%lX", -p->id1);
1198         else
1199             sprintf(buf, "L%lX,10,/", p->id1);
1200         break;
1201     case FT_OFS:
1202         sprintf(buf, "R%lX,%lX,+", p->id1, p->addend);
1203         break;
1204     case FT_REL:
1205         sprintf(buf, "R%lX,%lX,+,P,-,%X,-", p->id1, p->addend, p->size);
1206         break;
1207
1208     case FT_WRT:
1209         if (p->id2 < 0)
1210             sprintf(buf, "R%lX,%lX,+,L%lX,+,%lX,-", p->id2, p->addend,
1211                     p->id2, -p->id1 * 16);
1212         else
1213             sprintf(buf, "R%lX,%lX,+,L%lX,+,L%lX,-", p->id2, p->addend,
1214                     p->id2, p->id1);
1215         break;
1216     case FT_EXT:
1217         sprintf(buf, "X%lX", p->id1);
1218         break;
1219     case FT_EXTREL:
1220         sprintf(buf, "X%lX,P,-,%lX,-", p->id1, size);
1221         break;
1222     case FT_EXTSEG:
1223         /* We needed a non-ieee hack here.
1224          * We introduce the Y variable, which is the low
1225          * limit of the native segment the extern resides in
1226          */
1227         sprintf(buf, "Y%lX,10,/", p->id1);
1228         break;
1229     case FT_EXTWRT:
1230         if (p->id2 < 0)
1231             sprintf(buf, "X%lX,Y%lX,+,%lX,-", p->id2, p->id2,
1232                     -p->id1 * 16);
1233         else
1234             sprintf(buf, "X%lX,Y%lX,+,L%lX,-", p->id2, p->id2, p->id1);
1235         break;
1236     }
1237     ieee_putascii("LR(%s,%lX).\r\n", buf, size);
1238
1239     return (size);
1240 }
1241
1242 /* Dump all segment data (text and fixups )*/
1243
1244 static void ieee_unqualified_name(int8_t *dest, int8_t *source)
1245 {
1246     if (ieee_uppercase) {
1247         while (*source)
1248             *dest++ = toupper(*source++);
1249         *dest = 0;
1250     } else
1251         strcpy(dest, source);
1252 }
1253 void dbgls_init(struct ofmt *of, void *id, FILE * fp, efunc error)
1254 {
1255     int tempint;
1256     (void)of;
1257     (void)id;
1258     (void)fp;
1259     (void)error;
1260
1261     fnhead = NULL;
1262     fntail = &fnhead;
1263     arrindex = ARRAY_BOT;
1264     arrhead = NULL;
1265     arrtail = &arrhead;
1266     ieee_segment("??LINE", 2, &tempint);
1267     any_segs = FALSE;
1268 }
1269 static void dbgls_cleanup(void)
1270 {
1271     struct ieeeSection *segtmp;
1272     while (fnhead) {
1273         struct FileName *fntemp = fnhead;
1274         fnhead = fnhead->next;
1275         nasm_free(fntemp->name);
1276         nasm_free(fntemp);
1277     }
1278     for (segtmp = seghead; segtmp; segtmp = segtmp->next) {
1279         while (segtmp->lochead) {
1280             struct ieeePublic *loctmp = segtmp->lochead;
1281             segtmp->lochead = loctmp->next;
1282             nasm_free(loctmp->name);
1283             nasm_free(loctmp);
1284         }
1285     }
1286     while (arrhead) {
1287         struct Array *arrtmp = arrhead;
1288         arrhead = arrhead->next;
1289         nasm_free(arrtmp);
1290     }
1291 }
1292
1293 /*
1294  * because this routine is not bracketed in
1295  * the main program, this routine will be called even if there
1296  * is no request for debug info
1297  * so, we have to make sure the ??LINE segment is avaialbe
1298  * as the first segment when this debug format is selected
1299  */
1300 static void dbgls_linnum(const int8_t *lnfname, int32_t lineno, int32_t segto)
1301 {
1302     struct FileName *fn;
1303     struct ieeeSection *seg;
1304     int i = 0;
1305     if (segto == NO_SEG)
1306         return;
1307
1308     /*
1309      * If `any_segs' is still FALSE, we must define a default
1310      * segment.
1311      */
1312     if (!any_segs) {
1313         int tempint;            /* ignored */
1314         if (segto != ieee_segment("__NASMDEFSEG", 2, &tempint))
1315             error(ERR_PANIC, "strange segment conditions in OBJ driver");
1316     }
1317
1318     /*
1319      * Find the segment we are targetting.
1320      */
1321     for (seg = seghead; seg; seg = seg->next)
1322         if (seg->index == segto)
1323             break;
1324     if (!seg)
1325         error(ERR_PANIC, "lineno directed to nonexistent segment?");
1326
1327     for (fn = fnhead; fn; fn = fn->next) {
1328         if (!nasm_stricmp(lnfname, fn->name))
1329             break;
1330         i++;
1331     }
1332     if (!fn) {
1333         fn = nasm_malloc(sizeof(*fn));
1334         fn->name = nasm_malloc(strlen(lnfname) + 1);
1335         fn->index = i;
1336         strcpy(fn->name, lnfname);
1337         fn->next = NULL;
1338         *fntail = fn;
1339         fntail = &fn->next;
1340     }
1341     ieee_write_byte(seghead, fn->index);
1342     ieee_write_word(seghead, lineno);
1343     ieee_write_fixup(segto, NO_SEG, seghead, 4, OUT_ADDRESS,
1344                      seg->currentpos);
1345
1346 }
1347 static void dbgls_deflabel(int8_t *name, int32_t segment,
1348                            int32_t offset, int is_global, int8_t *special)
1349 {
1350     struct ieeeSection *seg;
1351     int used_special;           /* have we used the special text? */
1352
1353     /* Keep compiler from warning about special and used_special */
1354     used_special = special ? FALSE : FALSE;
1355
1356     /*
1357      * If it's a special-retry from pass two, discard it.
1358      */
1359     if (is_global == 3)
1360         return;
1361
1362     /*
1363      * First check for the double-period, signifying something
1364      * unusual.
1365      */
1366     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
1367         return;
1368     }
1369
1370     /*
1371      * Case (i):
1372      */
1373     if (ieee_seg_needs_update)
1374         return;
1375     if (segment < SEG_ABS && segment != NO_SEG && segment % 2)
1376         return;
1377
1378     if (segment >= SEG_ABS || segment == NO_SEG) {
1379         return;
1380     }
1381
1382     /*
1383      * If `any_segs' is still FALSE, we might need to define a
1384      * default segment, if they're trying to declare a label in
1385      * `first_seg'.  But the label should exist due to a prior
1386      * call to ieee_deflabel so we can skip that.
1387      */
1388
1389     for (seg = seghead; seg; seg = seg->next)
1390         if (seg->index == segment) {
1391             struct ieeePublic *loc;
1392             /*
1393              * Case (ii). Maybe MODPUB someday?
1394              */
1395             if (!is_global) {
1396                 last_defined = loc = nasm_malloc(sizeof(*loc));
1397                 *seg->loctail = loc;
1398                 seg->loctail = &loc->next;
1399                 loc->next = NULL;
1400                 loc->name = nasm_strdup(name);
1401                 loc->offset = offset;
1402                 loc->segment = -1;
1403                 loc->index = seg->ieee_index;
1404             }
1405         }
1406 }
1407 static void dbgls_typevalue(int32_t type)
1408 {
1409     int elem = TYM_ELEMENTS(type);
1410     type = TYM_TYPE(type);
1411
1412     if (!last_defined)
1413         return;
1414
1415     switch (type) {
1416     case TY_BYTE:
1417         last_defined->type = 1; /* uint8_t */
1418         break;
1419     case TY_WORD:
1420         last_defined->type = 3; /* unsigned word */
1421         break;
1422     case TY_DWORD:
1423         last_defined->type = 5; /* unsigned dword */
1424         break;
1425     case TY_FLOAT:
1426         last_defined->type = 9; /* float */
1427         break;
1428     case TY_QWORD:
1429         last_defined->type = 10;        /* qword */
1430         break;
1431     case TY_TBYTE:
1432         last_defined->type = 11;        /* TBYTE */
1433         break;
1434     default:
1435         last_defined->type = 0x10;      /* near label */
1436         break;
1437     }
1438
1439     if (elem > 1) {
1440         struct Array *arrtmp = nasm_malloc(sizeof(*arrtmp));
1441         int vtype = last_defined->type;
1442         arrtmp->size = elem;
1443         arrtmp->basetype = vtype;
1444         arrtmp->next = NULL;
1445         last_defined->type = arrindex++ + 0x100;
1446         *arrtail = arrtmp;
1447         arrtail = &(arrtmp->next);
1448     }
1449     last_defined = NULL;
1450 }
1451 static void dbgls_output(int output_type, void *param)
1452 {
1453     (void)output_type;
1454     (void)param;
1455 }
1456 static struct dfmt ladsoft_debug_form = {
1457     "LADsoft Debug Records",
1458     "ladsoft",
1459     dbgls_init,
1460     dbgls_linnum,
1461     dbgls_deflabel,
1462     null_debug_routine,
1463     dbgls_typevalue,
1464     dbgls_output,
1465     dbgls_cleanup,
1466 };
1467 static struct dfmt *ladsoft_debug_arr[3] = {
1468     &ladsoft_debug_form,
1469     &null_debug_form,
1470     NULL
1471 };
1472 struct ofmt of_ieee = {
1473     "IEEE-695 (LADsoft variant) object file format",
1474     "ieee",
1475     NULL,
1476     ladsoft_debug_arr,
1477     &null_debug_form,
1478     NULL,
1479     ieee_init,
1480     ieee_set_info,
1481     ieee_out,
1482     ieee_deflabel,
1483     ieee_segment,
1484     ieee_segbase,
1485     ieee_directive,
1486     ieee_filename,
1487     ieee_cleanup
1488 };
1489
1490 #endif                          /* OF_IEEE */