output/outrdf2.c

   1 /*
   2  * outrdf2.c    output routines for the Netwide Assembler to produce
   3  *              RDOFF version 2 format object files, which Julian originally
   4  *              planned to use it in his MOSCOW operating system.
   5  *
   6  * The Netwide Assembler is copyright (C) 1996-1998 Simon Tatham and
   7  * Julian Hall. All rights reserved. The software is
   8  * redistributable under the license given in the file "LICENSE"
   9  * distributed in the NASM archive.
  10  */
  11
  12 #include "compiler.h"
  13
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <ctype.h>
  18 #include <assert.h>
  19 #include <inttypes.h>
  20
  21 #include "nasm.h"
  22 #include "nasmlib.h"
  23 #include "saa.h"
  24 #include "output/outform.h"
  25 #include "output/outlib.h"
  26
  27 /* VERBOSE_WARNINGS: define this to add some extra warnings... */
  28 #define VERBOSE_WARNINGS
  29
  30 #ifdef OF_RDF2
  31
  32 #include "rdoff/rdoff.h"
  33
  34 /* This signature is written to start of RDOFF files */
  35 static const char *RDOFF2Id = RDOFF2_SIGNATURE;
  36
  37 /* Note that whenever a segment is referred to in the RDOFF file, its number
  38  * is always half of the segment number that NASM uses to refer to it; this
  39  * is because NASM only allocates even numbered segments, so as to not
  40  * waste any of the 16 bits of segment number written to the file - this
  41  * allows up to 65533 external labels to be defined; otherwise it would be
  42  * 32764. */
  43
  44 #define COUNT_SEGTYPES 9
  45
  46 static char *segmenttypes[COUNT_SEGTYPES] = {
  47     "null", "text", "code", "data",
  48     "comment", "lcomment", "pcomment",
  49     "symdebug", "linedebug"
  50 };
  51
  52 static int segmenttypenumbers[COUNT_SEGTYPES] = {
  53     0, 1, 1, 2, 3, 4, 5, 6, 7
  54 };
  55
  56 /* code for managing buffers needed to separate code and data into individual
  57  * sections until they are ready to be written to the file.
  58  * We'd better hope that it all fits in memory else we're buggered... */
  59
  60 #define BUF_BLOCK_LEN 4088      /* selected to match page size (4096)
  61                                  * on 80x86 machines for efficiency */
  62
  63 /***********************************************************************
  64  * Actual code to deal with RDOFF2 ouput format begins here...
  65  */
  66
  67 /* global variables set during the initialisation phase */
  68
  69 static struct SAA *seg[RDF_MAXSEGS];    /* seg 0 = code, seg 1 = data */
  70 static struct SAA *header;      /* relocation/import/export records */
  71
  72 static FILE *ofile;
  73
  74 static efunc error;
  75
  76 static struct seginfo {
  77     char *segname;
  78     int segnumber;
  79     uint16_t segtype;
  80     uint16_t segreserved;
  81     int32_t seglength;
  82 } segments[RDF_MAXSEGS];
  83
  84 static int nsegments;
  85
  86 static int32_t bsslength;
  87 static int32_t headerlength;
  88
  89 static void rdf2_init(FILE * fp, efunc errfunc, ldfunc ldef, evalfunc eval)
  90 {
  91     int segtext, segdata, segbss;
  92
  93     (void)ldef;
  94     (void)eval;
  95
  96     maxbits = 64;
  97
  98     /* set up the initial segments */
  99     segments[0].segname = ".text";
 100     segments[0].segnumber = 0;
 101     segments[0].segtype = 1;
 102     segments[0].segreserved = 0;
 103     segments[0].seglength = 0;
 104
 105     segments[1].segname = ".data";
 106     segments[1].segnumber = 1;
 107     segments[1].segtype = 2;
 108     segments[1].segreserved = 0;
 109     segments[1].seglength = 0;
 110
 111     segments[2].segname = ".bss";
 112     segments[2].segnumber = 2;
 113     segments[2].segtype = 0xFFFF;       /* reserved - should never be produced */
 114     segments[2].segreserved = 0;
 115     segments[2].seglength = 0;
 116
 117     nsegments = 3;
 118
 119     ofile = fp;
 120     error = errfunc;
 121
 122     seg[0] = saa_init(1L);
 123     seg[1] = saa_init(1L);
 124     seg[2] = NULL;              /* special case! */
 125
 126     header = saa_init(1L);
 127
 128     segtext = seg_alloc();
 129     segdata = seg_alloc();
 130     segbss = seg_alloc();
 131     if (segtext != 0 || segdata != 2 || segbss != 4)
 132         error(ERR_PANIC,
 133               "rdf segment numbers not allocated as expected (%d,%d,%d)",
 134               segtext, segdata, segbss);
 135     bsslength = 0;
 136     headerlength = 0;
 137 }
 138
 139 static int32_t rdf2_section_names(char *name, int pass, int *bits)
 140 {
 141     int i;
 142     bool err;
 143     char *p, *q;
 144     int code = -1;
 145     int reserved = 0;
 146
 147     (void)pass;
 148
 149     /*
 150      * Default is 32 bits, in the text segment.
 151      */
 152     if (!name) {
 153         *bits = 32;
 154         return 0;
 155     }
 156
 157     /* look for segment type code following segment name */
 158     p = name;
 159     while (*p && !nasm_isspace(*p))
 160         p++;
 161     if (*p) {                   /* we're now in whitespace */
 162         *p++ = '\0';
 163         while (*p && nasm_isspace(80))
 164             *p++ = '\0';
 165     }
 166     if (*p) {                   /* we're now in an attribute value */
 167         /*
 168          * see if we have an optional ',number' following the type code
 169          */
 170         if ((q = strchr(p, ','))) {
 171             *q++ = '\0';
 172
 173             reserved = readnum(q, &err);
 174             if (err) {
 175                 error(ERR_NONFATAL,
 176                       "value following comma must be numeric");
 177                 reserved = 0;
 178             }
 179         }
 180         /*
 181          * check it against the text strings in segmenttypes
 182          */
 183
 184         for (i = 0; i < COUNT_SEGTYPES; i++)
 185             if (!nasm_stricmp(p, segmenttypes[i])) {
 186                 code = segmenttypenumbers[i];
 187                 break;
 188             }
 189         if (code == -1) {       /* didn't find anything */
 190             code = readnum(p, &err);
 191             if (err) {
 192                 error(ERR_NONFATAL, "unrecognised RDF segment type (%s)",
 193                       p);
 194                 code = 3;
 195             }
 196         }
 197     }
 198     for (i = 0; i < nsegments; i++) {
 199         if (!strcmp(name, segments[i].segname)) {
 200             if (code != -1 || reserved != 0)
 201                 error(ERR_NONFATAL, "segment attributes specified on"
 202                       " redeclaration of segment");
 203             return segments[i].segnumber * 2;
 204         }
 205     }
 206
 207     /* declaring a new segment! */
 208
 209     if (code == -1) {
 210         error(ERR_NONFATAL, "new segment declared without type code");
 211         code = 3;
 212     }
 213     if (nsegments == RDF_MAXSEGS) {
 214         error(ERR_FATAL, "reached compiled-in maximum segment limit (%d)",
 215               RDF_MAXSEGS);
 216         return NO_SEG;
 217     }
 218
 219     segments[nsegments].segname = nasm_strdup(name);
 220     i = seg_alloc();
 221     if (i % 2 != 0)
 222         error(ERR_PANIC, "seg_alloc() returned odd number");
 223     segments[nsegments].segnumber = i >> 1;
 224     segments[nsegments].segtype = code;
 225     segments[nsegments].segreserved = reserved;
 226     segments[nsegments].seglength = 0;
 227
 228     seg[nsegments] = saa_init(1L);
 229
 230     return i;
 231 }
 232
 233 /*
 234  * Write relocation record
 235  */
 236 static void write_reloc_rec(struct RelocRec *r)
 237 {
 238     char buf[4], *b;
 239
 240     if (r->refseg != (uint16_t) NO_SEG && (r->refseg & 1))        /* segment base ref */
 241         r->type = RDFREC_SEGRELOC;
 242
 243     r->refseg >>= 1;            /* adjust segment nos to RDF rather than NASM */
 244
 245     saa_wbytes(header, &r->type, 1);
 246     saa_wbytes(header, &r->reclen, 1);
 247     saa_wbytes(header, &r->segment, 1);
 248     b = buf;
 249     WRITELONG(b, r->offset);
 250     saa_wbytes(header, buf, 4);
 251     saa_wbytes(header, &r->length, 1);
 252     b = buf;
 253     WRITESHORT(b, r->refseg);
 254     saa_wbytes(header, buf, 2);
 255     headerlength += r->reclen + 2;
 256 }
 257
 258 /*
 259  * Write export record
 260  */
 261 static void write_export_rec(struct ExportRec *r)
 262 {
 263     char buf[4], *b;
 264
 265     r->segment >>= 1;
 266
 267     saa_wbytes(header, &r->type, 1);
 268     saa_wbytes(header, &r->reclen, 1);
 269     saa_wbytes(header, &r->flags, 1);
 270     saa_wbytes(header, &r->segment, 1);
 271     b = buf;
 272     WRITELONG(b, r->offset);
 273     saa_wbytes(header, buf, 4);
 274     saa_wbytes(header, r->label, strlen(r->label) + 1);
 275     headerlength += r->reclen + 2;
 276 }
 277
 278 static void write_import_rec(struct ImportRec *r)
 279 {
 280     char buf[4], *b;
 281
 282     r->segment >>= 1;
 283
 284     saa_wbytes(header, &r->type, 1);
 285     saa_wbytes(header, &r->reclen, 1);
 286     saa_wbytes(header, &r->flags, 1);
 287     b = buf;
 288     WRITESHORT(b, r->segment);
 289     saa_wbytes(header, buf, 2);
 290     saa_wbytes(header, r->label, strlen(r->label) + 1);
 291     headerlength += r->reclen + 2;
 292 }
 293
 294 /*
 295  * Write BSS record
 296  */
 297 static void write_bss_rec(struct BSSRec *r)
 298 {
 299     char buf[4], *b;
 300
 301     saa_wbytes(header, &r->type, 1);
 302     saa_wbytes(header, &r->reclen, 1);
 303     b = buf;
 304     WRITELONG(b, r->amount);
 305     saa_wbytes(header, buf, 4);
 306     headerlength += r->reclen + 2;
 307 }
 308
 309 /*
 310  * Write common variable record
 311  */
 312 static void write_common_rec(struct CommonRec *r)
 313 {
 314     char buf[4], *b;
 315
 316     r->segment >>= 1;
 317
 318     saa_wbytes(header, &r->type, 1);
 319     saa_wbytes(header, &r->reclen, 1);
 320     b = buf;
 321     WRITESHORT(b, r->segment);
 322     saa_wbytes(header, buf, 2);
 323     b = buf;
 324     WRITELONG(b, r->size);
 325     saa_wbytes(header, buf, 4);
 326     b = buf;
 327     WRITESHORT(b, r->align);
 328     saa_wbytes(header, buf, 2);
 329     saa_wbytes(header, r->label, strlen(r->label) + 1);
 330     headerlength += r->reclen + 2;
 331 }
 332
 333 /*
 334  * Write library record
 335  */
 336 static void write_dll_rec(struct DLLRec *r)
 337 {
 338     saa_wbytes(header, &r->type, 1);
 339     saa_wbytes(header, &r->reclen, 1);
 340     saa_wbytes(header, r->libname, strlen(r->libname) + 1);
 341     headerlength += r->reclen + 2;
 342 }
 343
 344 /*
 345  * Write module name record
 346  */
 347 static void write_modname_rec(struct ModRec *r)
 348 {
 349     saa_wbytes(header, &r->type, 1);
 350     saa_wbytes(header, &r->reclen, 1);
 351     saa_wbytes(header, r->modname, strlen(r->modname) + 1);
 352     headerlength += r->reclen + 2;
 353 }
 354
 355 /*
 356  * Handle export, import and common records.
 357  */
 358 static void rdf2_deflabel(char *name, int32_t segment, int64_t offset,
 359                           int is_global, char *special)
 360 {
 361     struct ExportRec r;
 362     struct ImportRec ri;
 363     struct CommonRec ci;
 364     static int farsym = 0;
 365     static int i;
 366     char symflags = 0;
 367     int len;
 368
 369     /* Check if the label length is OK */
 370     if ((len = strlen(name)) >= EXIM_LABEL_MAX) {
 371         error(ERR_NONFATAL, "label size exceeds %d bytes", EXIM_LABEL_MAX);
 372         return;
 373     }
 374     if (!len) {
 375         error(ERR_NONFATAL, "zero-length label");
 376         return;
 377     }
 378
 379     if (is_global == 2) {
 380         /* Common variable */
 381         ci.type = RDFREC_COMMON;
 382         ci.size = offset;
 383         ci.segment = segment;
 384         strcpy(ci.label, name);
 385         ci.reclen = 9 + len;
 386         ci.align = 0;
 387
 388         /*
 389          * Check the special text to see if it's a valid number and power
 390          * of two; if so, store it as the alignment for the common variable.
 391          */
 392         if (special) {
 393             bool err;
 394             ci.align = readnum(special, &err);
 395             if (err)
 396                 error(ERR_NONFATAL, "alignment constraint `%s' is not a"
 397                       " valid number", special);
 398             else if ((ci.align | (ci.align - 1)) != 2 * ci.align - 1)
 399                 error(ERR_NONFATAL, "alignment constraint `%s' is not a"
 400                       " power of two", special);
 401         }
 402         write_common_rec(&ci);
 403     }
 404
 405     /* We don't care about local labels or fix-up hints */
 406     if (is_global != 1)
 407         return;
 408
 409     if (special) {
 410         while (*special == ' ' || *special == '\t')
 411             special++;
 412
 413         if (!nasm_strnicmp(special, "export", 6)) {
 414             special += 6;
 415             symflags |= SYM_GLOBAL;
 416         } else if (!nasm_strnicmp(special, "import", 6)) {
 417             special += 6;
 418             symflags |= SYM_IMPORT;
 419         }
 420
 421         if (*special) {
 422             while (nasm_isspace(*special))
 423                 special++;
 424             if (!nasm_stricmp(special, "far")) {
 425                 farsym = 1;
 426             } else if (!nasm_stricmp(special, "near")) {
 427                 farsym = 0;
 428             } else if (!nasm_stricmp(special, "proc") ||
 429                        !nasm_stricmp(special, "function")) {
 430                 symflags |= SYM_FUNCTION;
 431             } else if (!nasm_stricmp(special, "data") ||
 432                        !nasm_stricmp(special, "object")) {
 433                 symflags |= SYM_DATA;
 434             } else
 435                 error(ERR_NONFATAL, "unrecognised symbol type `%s'",
 436                       special);
 437         }
 438     }
 439
 440     if (name[0] == '.' && name[1] == '.' && name[2] != '@') {
 441         error(ERR_NONFATAL, "unrecognised special symbol `%s'", name);
 442         return;
 443     }
 444
 445     for (i = 0; i < nsegments; i++) {
 446         if (segments[i].segnumber == segment >> 1)
 447             break;
 448     }
 449
 450     if (i >= nsegments) {       /* EXTERN declaration */
 451         ri.type = farsym ? RDFREC_FARIMPORT : RDFREC_IMPORT;
 452         if (symflags & SYM_GLOBAL)
 453             error(ERR_NONFATAL,
 454                   "symbol type conflict - EXTERN cannot be EXPORT");
 455         ri.flags = symflags;
 456         ri.segment = segment;
 457         strcpy(ri.label, name);
 458         ri.reclen = 4 + len;
 459         write_import_rec(&ri);
 460     } else if (is_global) {
 461         r.type = RDFREC_GLOBAL; /* GLOBAL declaration */
 462         if (symflags & SYM_IMPORT)
 463             error(ERR_NONFATAL,
 464                   "symbol type conflict - GLOBAL cannot be IMPORT");
 465         r.flags = symflags;
 466         r.segment = segment;
 467         r.offset = offset;
 468         strcpy(r.label, name);
 469         r.reclen = 7 + len;
 470         write_export_rec(&r);
 471     }
 472 }
 473
 474 static void membufwrite(int segment, const void *data, int bytes)
 475 {
 476     int i;
 477     char buf[4], *b;
 478
 479     for (i = 0; i < nsegments; i++) {
 480         if (segments[i].segnumber == segment)
 481             break;
 482     }
 483     if (i == nsegments)
 484         error(ERR_PANIC, "can't find segment %d", segment);
 485
 486     if (bytes < 0) {
 487         b = buf;
 488         if (bytes == -2)
 489             WRITESHORT(b, *(int16_t *)data);
 490         else
 491             WRITELONG(b, *(int32_t *)data);
 492         data = buf;
 493         bytes = -bytes;
 494     }
 495     segments[i].seglength += bytes;
 496     saa_wbytes(seg[i], data, bytes);
 497 }
 498
 499 static int getsegmentlength(int segment)
 500 {
 501     int i;
 502     for (i = 0; i < nsegments; i++) {
 503         if (segments[i].segnumber == segment)
 504             break;
 505     }
 506     if (i == nsegments)
 507         error(ERR_PANIC, "can't find segment %d", segment);
 508
 509     return segments[i].seglength;
 510 }
 511
 512 static void rdf2_out(int32_t segto, const void *data,
 513                      enum out_type type, uint64_t size,
 514                      int32_t segment, int32_t wrt)
 515 {
 516     struct RelocRec rr;
 517     uint8_t databuf[8], *pd;
 518     int seg;
 519
 520     if (segto == NO_SEG) {
 521         if (type != OUT_RESERVE)
 522             error(ERR_NONFATAL,
 523                   "attempt to assemble code in ABSOLUTE space");
 524         return;
 525     }
 526
 527     segto >>= 1;                /* convert NASM segment no to RDF number */
 528
 529     for (seg = 0; seg < nsegments; seg++) {
 530         if (segments[seg].segnumber == segto)
 531             break;
 532     }
 533     if (seg >= nsegments) {
 534         error(ERR_NONFATAL,
 535               "specified segment not supported by rdf output format");
 536         return;
 537     }
 538
 539     if (wrt != NO_SEG) {
 540         wrt = NO_SEG;           /* continue to do _something_ */
 541         error(ERR_NONFATAL, "WRT not supported by rdf output format");
 542     }
 543
 544     if (segto == 2 && type != OUT_RESERVE) {
 545         error(ERR_NONFATAL, "BSS segments may not be initialized");
 546
 547         /* just reserve the space for now... */
 548
 549         if (type == OUT_REL2ADR)
 550             size = 2;
 551         else
 552             size = 4;
 553         type = OUT_RESERVE;
 554     }
 555
 556     if (type == OUT_RESERVE) {
 557         if (segto == 2)         /* BSS segment space reserverd */
 558             bsslength += size;
 559         else
 560             while (size--)
 561                 membufwrite(segto, databuf, 1);
 562     } else if (type == OUT_RAWDATA) {
 563         if (segment != NO_SEG)
 564             error(ERR_PANIC, "OUT_RAWDATA with other than NO_SEG");
 565
 566         membufwrite(segto, data, size);
 567     } else if (type == OUT_ADDRESS) {
 568
 569         /* if segment == NO_SEG then we are writing an address of an
 570            object within the same segment - do not produce reloc rec. */
 571
 572         /* FIXME - is this behaviour sane? at first glance it doesn't
 573            appear to be. Must test this thoroughly...! */
 574
 575         if (segment != NO_SEG) {
 576             /* it's an address, so we must write a relocation record */
 577
 578             rr.type = RDFREC_RELOC;     /* type signature */
 579             rr.reclen = 8;
 580             rr.segment = segto; /* segment we're currently in */
 581             rr.offset = getsegmentlength(segto);        /* current offset */
 582             rr.length = size;  /* length of reference */
 583             rr.refseg = segment;        /* segment referred to */
 584             write_reloc_rec(&rr);
 585         }
 586
 587         pd = databuf;           /* convert address to little-endian */
 588         WRITEADDR(pd, *(int64_t *)data, size);
 589         membufwrite(segto, databuf, size);
 590     } else if (type == OUT_REL2ADR) {
 591         if (segment == segto)
 592             error(ERR_PANIC, "intra-segment OUT_REL2ADR");
 593
 594         rr.reclen = 8;
 595         rr.offset = getsegmentlength(segto);    /* current offset */
 596         rr.length = 2;          /* length of reference */
 597         rr.refseg = segment;    /* segment referred to (will be >>1'd) */
 598
 599         if (segment != NO_SEG && segment % 2) {
 600             rr.type = RDFREC_SEGRELOC;
 601             rr.segment = segto; /* memory base refs *aren't ever* relative! */
 602             write_reloc_rec(&rr);
 603
 604             /* what do we put in the code? Simply the data. This should almost
 605              * always be zero, unless someone's doing segment arithmetic...
 606              */
 607             rr.offset = *(int64_t *)data;
 608         } else {
 609             rr.type = RDFREC_RELOC;     /* type signature */
 610             rr.segment = segto + 64;    /* segment we're currently in + rel flag */
 611             write_reloc_rec(&rr);
 612
 613             /* work out what to put in the code: offset of the end of this operand,
 614              * subtracted from any data specified, so that loader can just add
 615              * address of imported symbol onto it to get address relative to end of
 616              * instruction: import_address + data(offset) - end_of_instrn */
 617
 618             rr.offset = *(int32_t *)data - (rr.offset + size);
 619         }
 620
 621         membufwrite(segto, &rr.offset, -2);
 622     } else if (type == OUT_REL4ADR) {
 623         if ((segment == segto) && (globalbits != 64))
 624             error(ERR_PANIC, "intra-segment OUT_REL4ADR");
 625         if (segment != NO_SEG && segment % 2) {
 626             error(ERR_PANIC, "erm... 4 byte segment base ref?");
 627         }
 628
 629         rr.type = RDFREC_RELOC; /* type signature */
 630         rr.segment = segto + 64;        /* segment we're currently in + rel tag */
 631         rr.offset = getsegmentlength(segto);    /* current offset */
 632         rr.length = 4;          /* length of reference */
 633         rr.refseg = segment;    /* segment referred to */
 634         rr.reclen = 8;
 635         write_reloc_rec(&rr);
 636
 637         rr.offset = *(int64_t *)data - (rr.offset + size);
 638
 639         membufwrite(segto, &rr.offset, -4);
 640     }
 641 }
 642
 643 static void rdf2_cleanup(int debuginfo)
 644 {
 645     int32_t l;
 646     struct BSSRec bs;
 647     int i;
 648
 649     (void)debuginfo;
 650
 651     /* should write imported & exported symbol declarations to header here */
 652
 653     /* generate the output file... */
 654     fwrite(RDOFF2Id, 6, 1, ofile);      /* file type magic number */
 655
 656     if (bsslength != 0) {       /* reserve BSS */
 657         bs.type = RDFREC_BSS;
 658         bs.amount = bsslength;
 659         bs.reclen = 4;
 660         write_bss_rec(&bs);
 661     }
 662
 663     /*
 664      * calculate overall length of the output object
 665      */
 666     l = headerlength + 4;
 667
 668     for (i = 0; i < nsegments; i++) {
 669         if (i == 2)
 670             continue;           /* skip BSS segment */
 671         l += 10 + segments[i].seglength;
 672     }
 673     l += 10;                    /* null segment */
 674
 675     fwriteint32_t(l, ofile);
 676
 677     fwriteint32_t(headerlength, ofile);
 678     saa_fpwrite(header, ofile); /* dump header */
 679     saa_free(header);
 680
 681     for (i = 0; i < nsegments; i++) {
 682         if (i == 2)
 683             continue;
 684
 685         fwriteint16_t(segments[i].segtype, ofile);
 686         fwriteint16_t(segments[i].segnumber, ofile);
 687         fwriteint16_t(segments[i].segreserved, ofile);
 688         fwriteint32_t(segments[i].seglength, ofile);
 689
 690         saa_fpwrite(seg[i], ofile);
 691         saa_free(seg[i]);
 692     }
 693
 694     /* null segment - write 10 bytes of zero */
 695     fwriteint32_t(0, ofile);
 696     fwriteint32_t(0, ofile);
 697     fwriteint16_t(0, ofile);
 698
 699     fclose(ofile);
 700 }
 701
 702 static int32_t rdf2_segbase(int32_t segment)
 703 {
 704     return segment;
 705 }
 706
 707 /*
 708  * Handle RDOFF2 specific directives
 709  */
 710 static int rdf2_directive(char *directive, char *value, int pass)
 711 {
 712     int n;
 713
 714     /* Check if the name length is OK */
 715     if ((n = strlen(value)) >= MODLIB_NAME_MAX) {
 716         error(ERR_NONFATAL, "name size exceeds %d bytes", MODLIB_NAME_MAX);
 717         return 0;
 718     }
 719
 720     if (!strcmp(directive, "library")) {
 721         if (pass == 1) {
 722             struct DLLRec r;
 723             r.type = RDFREC_DLL;
 724             r.reclen = n + 1;
 725             strcpy(r.libname, value);
 726             write_dll_rec(&r);
 727         }
 728         return 1;
 729     }
 730
 731     if (!strcmp(directive, "module")) {
 732         if (pass == 1) {
 733             struct ModRec r;
 734             r.type = RDFREC_MODNAME;
 735             r.reclen = n + 1;
 736             strcpy(r.modname, value);
 737             write_modname_rec(&r);
 738         }
 739         return 1;
 740     }
 741
 742     return 0;
 743 }
 744
 745 static void rdf2_filename(char *inname, char *outname, efunc error)
 746 {
 747     standard_extension(inname, outname, ".rdf", error);
 748 }
 749
 750 extern macros_t rdf2_stdmac[];
 751
 752 static int rdf2_set_info(enum geninfo type, char **val)
 753 {
 754     (void)type;
 755     (void)val;
 756     return 0;
 757 }
 758
 759 struct ofmt of_rdf2 = {
 760     "Relocatable Dynamic Object File Format v2.0",
 761     "rdf",
 762     NULL,
 763     null_debug_arr,
 764     &null_debug_form,
 765     rdf2_stdmac,
 766     rdf2_init,
 767     rdf2_set_info,
 768     rdf2_out,
 769     rdf2_deflabel,
 770     rdf2_section_names,
 771     rdf2_segbase,
 772     rdf2_directive,
 773     rdf2_filename,
 774     rdf2_cleanup
 775 };
 776
 777 #endif                          /* OF_RDF2 */