output/codeview.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2017 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * codeview.c Codeview Debug Format support for COFF
  36  */
  37
  38 #include "version.h"
  39 #include "compiler.h"
  40
  41
  42 #include "nasm.h"
  43 #include "nasmlib.h"
  44 #include "error.h"
  45 #include "preproc.h"
  46 #include "saa.h"
  47 #include "hashtbl.h"
  48 #include "outlib.h"
  49 #include "pecoff.h"
  50 #include "md5.h"
  51
  52 static void cv8_init(void);
  53 static void cv8_linenum(const char *filename, int32_t linenumber,
  54         int32_t segto);
  55 static void cv8_deflabel(char *name, int32_t segment, int64_t offset,
  56         int is_global, char *special);
  57 static void cv8_typevalue(int32_t type);
  58 static void cv8_output(int type, void *param);
  59 static void cv8_cleanup(void);
  60
  61 const struct dfmt df_cv8 = {
  62     "Codeview 8",               /* .fullname */
  63     "cv8",                      /* .shortname */
  64     cv8_init,                   /* .init */
  65     cv8_linenum,                /* .linenum */
  66     cv8_deflabel,               /* .debug_deflabel */
  67     null_debug_directive,       /* .debug_directive */
  68     cv8_typevalue,              /* .debug_typevalue */
  69     cv8_output,                 /* .debug_output */
  70     cv8_cleanup,                /* .cleanup */
  71     NULL                        /* pragma list */
  72 };
  73
  74 /*******************************************************************************
  75  * dfmt callbacks
  76  ******************************************************************************/
  77 struct source_file;
  78
  79 struct source_file {
  80     const char *filename;
  81     char *fullname;
  82     uint32_t fullnamelen;
  83
  84     struct source_file *next;
  85
  86     uint32_t filetbl_off;
  87     uint32_t sourcetbl_off;
  88
  89     struct SAA *lines;
  90     uint32_t num_lines;
  91
  92     unsigned char md5sum[MD5_HASHBYTES];
  93 };
  94
  95 struct linepair {
  96     uint32_t file_offset;
  97     uint32_t linenumber;
  98 };
  99
 100 enum symbol_type {
 101     SYMTYPE_CODE,
 102     SYMTYPE_PROC,
 103     SYMTYPE_LDATA,
 104     SYMTYPE_GDATA,
 105
 106     SYMTYPE_MAX
 107 };
 108
 109 struct cv8_symbol {
 110     enum symbol_type type;
 111     char *name;
 112
 113     uint32_t secrel;
 114     uint16_t section;
 115     uint32_t size;
 116     uint32_t typeindex;
 117
 118     enum symtype {
 119         TYPE_UNREGISTERED = 0x0000, /* T_NOTYPE */
 120         TYPE_BYTE = 0x0020,
 121         TYPE_WORD = 0x0021,
 122         TYPE_DWORD= 0x0022,
 123         TYPE_QUAD = 0x0023,
 124
 125         TYPE_REAL32 = 0x0040,
 126         TYPE_REAL64 = 0x0041,
 127         TYPE_REAL80 = 0x0042,
 128         TYPE_REAL128= 0x0043,
 129         TYPE_REAL256= 0x0044,
 130         TYPE_REAL512= 0x0045
 131     } symtype;
 132 };
 133
 134 struct cv8_state {
 135     int symbol_sect;
 136     int type_sect;
 137
 138     uint32_t text_offset;
 139
 140     struct source_file *source_files, **source_files_tail;
 141     const char *last_filename;
 142     struct source_file *last_source_file;
 143     struct hash_table file_hash;
 144     unsigned num_files;
 145     uint32_t total_filename_len;
 146
 147
 148     unsigned total_lines;
 149
 150     struct SAA *symbols;
 151     struct cv8_symbol *last_sym;
 152     unsigned num_syms[SYMTYPE_MAX];
 153     unsigned symbol_lengths;
 154     unsigned total_syms;
 155
 156     struct {
 157         char *name;
 158         size_t namebytes;
 159     } outfile;
 160 };
 161 struct cv8_state cv8_state;
 162
 163 static void cv8_init(void)
 164 {
 165     const uint32_t sect_flags =     IMAGE_SCN_MEM_READ |
 166                     IMAGE_SCN_MEM_DISCARDABLE |
 167                     IMAGE_SCN_CNT_INITIALIZED_DATA |
 168                     IMAGE_SCN_ALIGN_1BYTES;
 169
 170     cv8_state.symbol_sect = coff_make_section(".debug$S", sect_flags);
 171     cv8_state.type_sect = coff_make_section(".debug$T", sect_flags);
 172
 173     cv8_state.text_offset = 0;
 174
 175     cv8_state.source_files = NULL;
 176     cv8_state.source_files_tail = &cv8_state.source_files;
 177
 178     cv8_state.num_files = 0;
 179     cv8_state.total_filename_len = 0;
 180
 181     cv8_state.total_lines = 0;
 182
 183     cv8_state.symbols = saa_init(sizeof(struct cv8_symbol));
 184     cv8_state.last_sym = NULL;
 185 }
 186
 187 static struct source_file *register_file(const char *filename);
 188 static struct coff_Section *find_section(int32_t segto);
 189
 190 static void cv8_linenum(const char *filename, int32_t linenumber,
 191         int32_t segto)
 192 {
 193     struct coff_Section *s;
 194     struct linepair *li;
 195     struct source_file *file;
 196
 197     file = register_file(filename);
 198
 199     s = find_section(segto);
 200     if (s == NULL)
 201         return;
 202
 203     if ((s->flags & IMAGE_SCN_MEM_EXECUTE) == 0)
 204         return;
 205
 206     li = saa_wstruct(file->lines);
 207     li->file_offset = cv8_state.text_offset;
 208     li->linenumber = linenumber;
 209
 210     file->num_lines++;
 211     cv8_state.total_lines++;
 212 }
 213
 214 static void cv8_deflabel(char *name, int32_t segment, int64_t offset,
 215         int is_global, char *special)
 216 {
 217     struct cv8_symbol *sym;
 218     struct coff_Section *s;
 219
 220     (void)special;
 221
 222     s = find_section(segment);
 223     if (s == NULL)
 224         return;
 225
 226     sym = saa_wstruct(cv8_state.symbols);
 227
 228     if (s->flags & IMAGE_SCN_MEM_EXECUTE)
 229         sym->type = is_global ? SYMTYPE_PROC : SYMTYPE_CODE;
 230     else
 231         sym->type = is_global ?  SYMTYPE_GDATA : SYMTYPE_LDATA;
 232     cv8_state.num_syms[sym->type]++;
 233     cv8_state.total_syms++;
 234
 235     sym->section = segment;
 236     sym->secrel = offset;
 237     sym->symtype = TYPE_UNREGISTERED;
 238     sym->size = 0;
 239     sym->typeindex = 0;
 240
 241     sym->name = nasm_strdup(name);
 242     cv8_state.symbol_lengths += strlen(sym->name) + 1;
 243
 244     if (cv8_state.last_sym && cv8_state.last_sym->section == segment)
 245         cv8_state.last_sym->size = offset - cv8_state.last_sym->secrel;
 246     cv8_state.last_sym = sym;
 247 }
 248
 249 static void cv8_typevalue(int32_t type)
 250 {
 251     if (!cv8_state.last_sym)
 252         return;
 253     if (cv8_state.last_sym->symtype != TYPE_UNREGISTERED)
 254         return;
 255
 256     switch (TYM_TYPE(type)) {
 257     case TY_BYTE:
 258         cv8_state.last_sym->symtype = TYPE_BYTE;
 259         break;
 260     case TY_WORD:
 261         cv8_state.last_sym->symtype = TYPE_WORD;
 262         break;
 263     case TY_DWORD:
 264         cv8_state.last_sym->symtype = TYPE_DWORD;
 265         break;
 266     case TY_QWORD:
 267         cv8_state.last_sym->symtype = TYPE_QUAD;
 268         break;
 269     case TY_FLOAT:
 270         cv8_state.last_sym->symtype = TYPE_REAL32;
 271         break;
 272     case TY_TBYTE:
 273         cv8_state.last_sym->symtype = TYPE_REAL80;
 274         break;
 275     case TY_OWORD:
 276         cv8_state.last_sym->symtype = TYPE_REAL128;
 277         break;
 278     case TY_YWORD:
 279         cv8_state.last_sym->symtype = TYPE_REAL256;
 280         break;
 281     case TY_ZWORD:
 282         cv8_state.last_sym->symtype = TYPE_REAL512;
 283         break;
 284     case TY_UNKNOWN:
 285         break;
 286     case TY_LABEL:
 287         break;
 288     }
 289 }
 290
 291 static void cv8_output(int type, void *param)
 292 {
 293     struct coff_DebugInfo *dinfo = param;
 294
 295     (void)type;
 296
 297     if (dinfo->section && dinfo->section->name &&
 298     !strncmp(dinfo->section->name, ".text", 5))
 299         cv8_state.text_offset += dinfo->size;
 300 }
 301
 302 static void build_symbol_table(struct coff_Section *const sect);
 303 static void build_type_table(struct coff_Section *const sect);
 304
 305 static void cv8_cleanup(void)
 306 {
 307     struct cv8_symbol *sym;
 308     struct source_file *file;
 309
 310     struct coff_Section *symbol_sect = coff_sects[cv8_state.symbol_sect];
 311     struct coff_Section *type_sect = coff_sects[cv8_state.type_sect];
 312
 313     cv8_state.outfile.name = nasm_realpath(outname);
 314     cv8_state.outfile.namebytes = strlen(cv8_state.outfile.name) + 1;
 315
 316     build_symbol_table(symbol_sect);
 317     build_type_table(type_sect);
 318
 319     list_for_each(file, cv8_state.source_files) {
 320         nasm_free(file->fullname);
 321         saa_free(file->lines);
 322         free(file);
 323     }
 324     hash_free(&cv8_state.file_hash);
 325
 326     saa_rewind(cv8_state.symbols);
 327     while ((sym = saa_rstruct(cv8_state.symbols)))
 328         nasm_free(sym->name);
 329     saa_free(cv8_state.symbols);
 330
 331     nasm_free(cv8_state.outfile.name);
 332 }
 333
 334 /*******************************************************************************
 335  * implementation
 336  ******************************************************************************/
 337 static void calc_md5(const char *const filename,
 338         unsigned char sum[MD5_HASHBYTES])
 339 {
 340     int success = 0;
 341     unsigned char *file_buf;
 342     FILE *f;
 343     MD5_CTX ctx;
 344
 345     f = pp_input_fopen(filename, NF_BINARY);
 346     if (!f)
 347         goto done;
 348
 349     file_buf = nasm_zalloc(BUFSIZ);
 350
 351     MD5Init(&ctx);
 352     while (!feof(f)) {
 353         size_t i = fread(file_buf, 1, BUFSIZ, f);
 354         if (ferror(f))
 355             goto done_0;
 356         else if (i == 0)
 357             break;
 358         MD5Update(&ctx, file_buf, i);
 359     }
 360     MD5Final(sum, &ctx);
 361
 362     success = 1;
 363 done_0:
 364     nasm_free(file_buf);
 365     fclose(f);
 366 done:
 367     if (!success) {
 368         nasm_nonfatal("unable to hash file %s. "
 369                       "Debug information may be unavailable.",
 370                       filename);
 371     }
 372     return;
 373 }
 374
 375 static struct source_file *register_file(const char *filename)
 376 {
 377     struct source_file *file;
 378     void **filep;
 379     char *fullpath;
 380     struct hash_insert hi;
 381
 382     /*
 383      * The common case is that we are invoked with the same filename
 384      * as we were last time.  Make this a pointer comparison: this is
 385      * safe because the NASM core code allocates each filename once
 386      * and never frees it.
 387      */
 388     if (likely(cv8_state.last_filename == filename))
 389         return cv8_state.last_source_file;
 390
 391     cv8_state.last_filename = filename;
 392
 393     filep = hash_find(&cv8_state.file_hash, filename, &hi);
 394     if (likely(filep)) {
 395         file = *filep;
 396     } else {
 397         /* New filename encounter */
 398
 399         fullpath = nasm_realpath(filename);
 400
 401         file = nasm_zalloc(sizeof(*file));
 402
 403         file->filename = filename;
 404         file->fullname = fullpath;
 405         file->fullnamelen = strlen(fullpath);
 406         file->lines = saa_init(sizeof(struct linepair));
 407         *cv8_state.source_files_tail = file;
 408         cv8_state.source_files_tail = &file->next;
 409         calc_md5(fullpath, file->md5sum);
 410
 411         hash_add(&hi, filename, file);
 412
 413         cv8_state.num_files++;
 414         cv8_state.total_filename_len += file->fullnamelen + 1;
 415     }
 416
 417     cv8_state.last_source_file = file;
 418     return file;
 419 }
 420
 421 static struct coff_Section *find_section(int32_t segto)
 422 {
 423     int i;
 424
 425     for (i = 0; i < coff_nsects; i++) {
 426         struct coff_Section *sec;
 427
 428         sec = coff_sects[i];
 429         if (segto == sec->index)
 430             return sec;
 431     }
 432     return NULL;
 433 }
 434
 435 static void register_reloc(struct coff_Section *const sect,
 436         char *sym, uint32_t addr, uint16_t type)
 437 {
 438     struct coff_Reloc *r;
 439     struct coff_Section *sec;
 440     uint32_t i;
 441
 442     r = *sect->tail = nasm_malloc(sizeof(struct coff_Reloc));
 443     sect->tail = &r->next;
 444     r->next = NULL;
 445     sect->nrelocs++;
 446
 447     r->address = addr;
 448     r->symbase = SECT_SYMBOLS;
 449     r->type = type;
 450
 451     r->symbol = 0;
 452     for (i = 0; i < (uint32_t)coff_nsects; i++) {
 453         sec = coff_sects[i];
 454         if (!strcmp(sym, sec->name)) {
 455             return;
 456         }
 457         r->symbol += 2;
 458     }
 459
 460     saa_rewind(coff_syms);
 461     for (i = 0; i < coff_nsyms; i++) {
 462         struct coff_Symbol *s = saa_rstruct(coff_syms);
 463         r->symbol++;
 464         if (s->strpos == -1 && !strcmp(sym, s->name)) {
 465             return;
 466         } else if (s->strpos != -1) {
 467             int res;
 468             char *symname;
 469
 470             symname = nasm_malloc(s->namlen + 1);
 471             saa_fread(coff_strs, s->strpos-4, symname, s->namlen);
 472             symname[s->namlen] = '\0';
 473             res = strcmp(sym, symname);
 474             nasm_free(symname);
 475             if (!res)
 476                 return;
 477         }
 478     }
 479     nasm_panic("codeview: relocation for unregistered symbol: %s", sym);
 480 }
 481
 482 static inline void section_write32(struct coff_Section *sect, uint32_t val)
 483 {
 484     saa_write32(sect->data, val);
 485     sect->len += 4;
 486 }
 487
 488 static inline void section_write16(struct coff_Section *sect, uint16_t val)
 489 {
 490     saa_write16(sect->data, val);
 491     sect->len += 2;
 492 }
 493
 494 static inline void section_write8(struct coff_Section *sect, uint8_t val)
 495 {
 496     saa_write8(sect->data, val);
 497     sect->len++;
 498 }
 499
 500 static inline void section_wbytes(struct coff_Section *sect, const void *buf,
 501         size_t len)
 502 {
 503     saa_wbytes(sect->data, buf, len);
 504     sect->len += len;
 505 }
 506
 507 static void write_filename_table(struct coff_Section *const sect)
 508 {
 509     uint32_t field_length;
 510     uint32_t tbl_off = 1;    /* offset starts at 1 to skip NULL entry */
 511     struct source_file *file;
 512
 513     nasm_assert(cv8_state.source_files != NULL);
 514     nasm_assert(cv8_state.num_files > 0);
 515     nasm_assert(cv8_state.total_filename_len > 0);
 516
 517     field_length = 1 + cv8_state.total_filename_len;
 518
 519     section_write32(sect, 0x000000F3);
 520     section_write32(sect, field_length);
 521
 522     section_write8(sect, 0);
 523
 524     list_for_each(file, cv8_state.source_files) {
 525         section_wbytes(sect, file->fullname, file->fullnamelen + 1);
 526         file->filetbl_off = tbl_off;
 527         tbl_off += file->fullnamelen + 1;
 528     }
 529 }
 530
 531 static void write_sourcefile_table(struct coff_Section *const sect)
 532 {
 533     const uint32_t entry_size = 4 + 2 + MD5_HASHBYTES + 2;
 534
 535     uint32_t field_length = 0;
 536     uint32_t tbl_off = 0;
 537     struct source_file *file;
 538
 539     field_length = entry_size * cv8_state.num_files;
 540
 541     section_write32(sect, 0x000000F4);
 542     section_write32(sect, field_length);
 543
 544     list_for_each(file, cv8_state.source_files) {
 545         nasm_assert(file->filetbl_off > 0);
 546         section_write32(sect, file->filetbl_off);
 547         section_write16(sect, 0x0110);
 548         section_wbytes(sect, file->md5sum, MD5_HASHBYTES);
 549         section_write16(sect, 0);
 550
 551         file->sourcetbl_off = tbl_off;
 552         tbl_off += entry_size;
 553     }
 554 }
 555
 556 static void write_linenumber_table(struct coff_Section *const sect)
 557 {
 558     const uint32_t file_field_len = 12;
 559     const uint32_t line_field_len = 8;
 560
 561     int i;
 562     uint32_t field_length = 0;
 563     size_t field_base;
 564     struct source_file *file;
 565     struct coff_Section *s;
 566
 567     for (i = 0; i < coff_nsects; i++) {
 568         if (!strncmp(coff_sects[i]->name, ".text", 5))
 569             break;
 570     }
 571
 572     if (i == coff_nsects)
 573         return;
 574     s = coff_sects[i];
 575
 576     field_length = 12;
 577     field_length += (cv8_state.num_files * file_field_len);
 578     field_length += (cv8_state.total_lines * line_field_len);
 579
 580     section_write32(sect, 0x000000F2);
 581     section_write32(sect, field_length);
 582
 583     field_base = sect->len;
 584     section_write32(sect, 0); /* SECREL, updated by relocation */
 585     section_write16(sect, 0); /* SECTION, updated by relocation*/
 586     section_write16(sect, 0); /* pad */
 587     section_write32(sect, s->len);
 588
 589     register_reloc(sect, ".text", field_base,
 590         win64 ? IMAGE_REL_AMD64_SECREL : IMAGE_REL_I386_SECREL);
 591
 592     register_reloc(sect, ".text", field_base + 4,
 593         win64 ? IMAGE_REL_AMD64_SECTION : IMAGE_REL_I386_SECTION);
 594
 595     list_for_each(file, cv8_state.source_files) {
 596         struct linepair *li;
 597
 598         /* source mapping */
 599         section_write32(sect, file->sourcetbl_off);
 600         section_write32(sect, file->num_lines);
 601         section_write32(sect, file_field_len + (file->num_lines * line_field_len));
 602
 603         /* the pairs */
 604         saa_rewind(file->lines);
 605         while ((li = saa_rstruct(file->lines))) {
 606             section_write32(sect, li->file_offset);
 607             section_write32(sect, li->linenumber |= 0x80000000);
 608         }
 609     }
 610 }
 611
 612 static uint16_t write_symbolinfo_obj(struct coff_Section *sect)
 613 {
 614     uint16_t obj_len;
 615
 616     obj_len = 2 + 4 + cv8_state.outfile.namebytes;
 617
 618     section_write16(sect, obj_len);
 619     section_write16(sect, 0x1101);
 620     section_write32(sect, 0); /* ASM language */
 621     section_wbytes(sect, cv8_state.outfile.name, cv8_state.outfile.namebytes);
 622
 623     return obj_len;
 624 }
 625
 626 static uint16_t write_symbolinfo_properties(struct coff_Section *sect,
 627         const char *const creator_str)
 628 {
 629     /* https://github.com/Microsoft/microsoft-pdb/blob/1d60e041/include/cvinfo.h#L3313 */
 630     uint16_t creator_len;
 631
 632     creator_len = 2 + 4 + 2 + 3*2 + 3*2 + strlen(creator_str)+1 + 2;
 633
 634     /*
 635      * We used to use a language ID of 3 for "MASM", since it's closest of the
 636      * options available; however, BinScope from WACK (the Windows Application
 637      * Certification Kit) tests for specific minimum MASM versions and trying to
 638      * match an increasing sequence of random MASM version/build numbers seems
 639      * like a fool's errand.
 640      *
 641      * Instead, use a different language ID (NASM is, after all, not MASM
 642      * syntax) and just write the actual NASM version number. BinScope appears
 643      * to be happy with that.
 644      */
 645
 646     section_write16(sect, creator_len);
 647     section_write16(sect, 0x1116);
 648     section_write32(sect, 'N'); /* language: 'N' (0x4e) for "NASM"; flags are 0 */
 649     if (win64)
 650         section_write16(sect, 0x00D0); /* machine */
 651     else if (win32)
 652         section_write16(sect, 0x0006); /* machine */
 653     else
 654         nasm_panic("neither win32 nor win64 are set!");
 655     section_write16(sect, 0); /* verFEMajor */
 656     section_write16(sect, 0); /* verFEMinor */
 657     section_write16(sect, 0); /* verFEBuild */
 658
 659     /* BinScope/WACK insist on version >= 8.0.50727 */
 660     section_write16(sect, NASM_MAJOR_VER); /* verMajor */
 661     section_write16(sect, NASM_MINOR_VER); /* verMinor */
 662     section_write16(sect, NASM_SUBMINOR_VER*100 + NASM_PATCHLEVEL_VER); /* verBuild */
 663
 664     section_wbytes(sect, creator_str, strlen(creator_str)+1); /* verSt */
 665     /*
 666      * normally there would be key/value pairs here, but they aren't
 667      * necessary. They are terminated by 2B
 668      */
 669     section_write16(sect, 0);
 670
 671     return creator_len;
 672 }
 673
 674 static uint16_t write_symbolinfo_symbols(struct coff_Section *sect)
 675 {
 676     uint16_t len = 0, field_len;
 677     uint32_t field_base;
 678     struct cv8_symbol *sym;
 679
 680     saa_rewind(cv8_state.symbols);
 681     while ((sym = saa_rstruct(cv8_state.symbols))) {
 682         switch (sym->type) {
 683         case SYMTYPE_LDATA:
 684         case SYMTYPE_GDATA:
 685             field_len = 12 + strlen(sym->name) + 1;
 686             len += field_len - 2;
 687             section_write16(sect, field_len);
 688             if (sym->type == SYMTYPE_LDATA)
 689                 section_write16(sect, 0x110C);
 690             else
 691                 section_write16(sect, 0x110D);
 692             section_write32(sect, sym->symtype);
 693
 694             field_base = sect->len;
 695             section_write32(sect, 0); /* SECREL */
 696             section_write16(sect, 0); /* SECTION */
 697             break;
 698         case SYMTYPE_PROC:
 699         case SYMTYPE_CODE:
 700             field_len = 9 + strlen(sym->name) + 1;
 701             len += field_len - 2;
 702             section_write16(sect, field_len);
 703             section_write16(sect, 0x1105);
 704
 705             field_base = sect->len;
 706             section_write32(sect, 0); /* SECREL */
 707             section_write16(sect, 0); /* SECTION */
 708             section_write8(sect, 0); /* FLAG */
 709             break;
 710         default:
 711             nasm_panic("unknown symbol type");
 712         }
 713
 714         section_wbytes(sect, sym->name, strlen(sym->name) + 1);
 715
 716         register_reloc(sect, sym->name, field_base,
 717             win64 ? IMAGE_REL_AMD64_SECREL :
 718                 IMAGE_REL_I386_SECREL);
 719         register_reloc(sect, sym->name, field_base + 4,
 720             win64 ? IMAGE_REL_AMD64_SECTION :
 721                 IMAGE_REL_I386_SECTION);
 722     }
 723
 724     return len;
 725 }
 726
 727 static void write_symbolinfo_table(struct coff_Section *const sect)
 728 {
 729     static const char creator_str[] = "The Netwide Assembler " NASM_VER;
 730     uint16_t obj_length, creator_length, sym_length;
 731     uint32_t field_length = 0, out_len;
 732
 733     nasm_assert(cv8_state.outfile.namebytes);
 734
 735     /* signature, language, outfile NULL */
 736     obj_length = 2 + 4 + cv8_state.outfile.namebytes;
 737     creator_length = 2 + 4 + 2 + 3*2 + 3*2 + strlen(creator_str)+1 + 2;
 738
 739     sym_length =    ( cv8_state.num_syms[SYMTYPE_CODE] *  7) +
 740             ( cv8_state.num_syms[SYMTYPE_PROC] *  7) +
 741             ( cv8_state.num_syms[SYMTYPE_LDATA] * 10) +
 742             ( cv8_state.num_syms[SYMTYPE_GDATA] * 10) +
 743             cv8_state.symbol_lengths;
 744
 745     field_length = 2 + obj_length +
 746                2 + creator_length +
 747                (4 * cv8_state.total_syms) + sym_length;
 748
 749     section_write32(sect, 0x000000F1);
 750     section_write32(sect, field_length);
 751
 752     /* for sub fields, length preceeds type */
 753
 754     out_len = write_symbolinfo_obj(sect);
 755     nasm_assert(out_len == obj_length);
 756
 757     out_len = write_symbolinfo_properties(sect, creator_str);
 758     nasm_assert(out_len == creator_length);
 759
 760     out_len = write_symbolinfo_symbols(sect);
 761     nasm_assert(out_len == sym_length);
 762 }
 763
 764 static inline void align4_table(struct coff_Section *const sect)
 765 {
 766     unsigned diff;
 767     uint32_t zero = 0;
 768     struct SAA *data = sect->data;
 769
 770     if (data->wptr % 4 == 0)
 771         return;
 772
 773     diff = 4 - (data->wptr % 4);
 774     if (diff)
 775         section_wbytes(sect, &zero, diff);
 776 }
 777
 778 static void build_symbol_table(struct coff_Section *const sect)
 779 {
 780     section_write32(sect, 0x00000004);
 781
 782     write_filename_table(sect);
 783     align4_table(sect);
 784     write_sourcefile_table(sect);
 785     align4_table(sect);
 786     write_linenumber_table(sect);
 787     align4_table(sect);
 788     write_symbolinfo_table(sect);
 789     align4_table(sect);
 790 }
 791
 792 static void build_type_table(struct coff_Section *const sect)
 793 {
 794     uint16_t field_len;
 795     struct cv8_symbol *sym;
 796
 797     section_write32(sect, 0x00000004);
 798
 799     saa_rewind(cv8_state.symbols);
 800     while ((sym = saa_rstruct(cv8_state.symbols))) {
 801         if (sym->type != SYMTYPE_PROC)
 802             continue;
 803
 804         /* proc leaf */
 805
 806         field_len = 2 + 4 + 4 + 4 + 2;
 807         section_write16(sect, field_len);
 808         section_write16(sect, 0x1008); /* PROC type */
 809
 810         section_write32(sect, 0x00000003); /* return type */
 811         section_write32(sect, 0); /* calling convention (default) */
 812         section_write32(sect, sym->typeindex);
 813         section_write16(sect, 0); /* # params */
 814
 815         /* arglist */
 816
 817         field_len = 2 + 4;
 818         section_write16(sect, field_len);
 819         section_write16(sect, 0x1201); /* ARGLIST */
 820         section_write32(sect, 0); /*num params */
 821     }
 822 }