Update our yasm copy to yasm 1.1.0 (Part 1: yasm side)...

third_party/yasm/patched-yasm/modules/objfmts/coff/coff-objfmt.c

 /*
  * COFF (DJGPP) object format
  *
  *  Copyright (C) 2002-2007  Peter Johnson
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #include <util.h>
 #include <time.h>
-/*@unused@*/ RCSID("$Id: coff-objfmt.c 2166 2009-01-02 08:33:21Z peter $");
+/*@unused@*/ RCSID("$Id: coff-objfmt.c 2347 2010-08-01 17:31:12Z peter $");
 
 #include <libyasm.h>
 
 #include "coff-objfmt.h"
 
 
 #define REGULAR_OUTBUF_SIZE     1024
 
 /* Defining this to 0 sets all section VMA's to 0 rather than as the same as
  * the LMA.  According to the DJGPP COFF Spec, this should be set to 1
@@ skipping 115 matching lines @@
     /*@owned@*/ char *fname;        /* filename aux entry */
 } coff_symtab_auxent;
 
 typedef enum coff_symtab_auxtype {
     COFF_SYMTAB_AUX_NONE = 0,
     COFF_SYMTAB_AUX_SECT,
     COFF_SYMTAB_AUX_FILE
 } coff_symtab_auxtype;
 
 typedef struct coff_symrec_data {
+    int forcevis;                       /* force visibility in symbol table */
     unsigned long index;                /* assigned COFF symbol table index */
+    unsigned int type;                  /* type */
     coff_symrec_sclass sclass;          /* storage class */
 
     int numaux;                 /* number of auxiliary entries */
     coff_symtab_auxtype auxtype;    /* type of aux entries */
     coff_symtab_auxent aux[1];  /* actually may be any size (including 0) */
 } coff_symrec_data;
 
 typedef struct yasm_objfmt_coff {
     yasm_objfmt_base objfmt;                /* base structure */
 
@@ skipping 71 matching lines @@
 
 
 static /*@dependent@*/ coff_symrec_data *
 coff_objfmt_sym_set_data(yasm_symrec *sym, coff_symrec_sclass sclass,
                          int numaux, coff_symtab_auxtype auxtype)
 {
     coff_symrec_data *sym_data;
 
     sym_data = yasm_xmalloc(sizeof(coff_symrec_data) +
                             (numaux-1)*sizeof(coff_symtab_auxent));
+    sym_data->forcevis = 0;
     sym_data->index = 0;
+    sym_data->type = 0;
     sym_data->sclass = sclass;
     sym_data->numaux = numaux;
     sym_data->auxtype = auxtype;
 
     yasm_symrec_add_data(sym, &coff_symrec_data_cb, sym_data);
 
     return sym_data;
 }
 
 static yasm_objfmt_coff *
@@ skipping 68 matching lines @@
                                     "amd64") == 0) {
             objfmt_coff->machine = COFF_MACHINE_AMD64;
             objfmt_coff->objfmt.module = &yasm_win64_LTX_objfmt;
             objfmt_coff->win64 = 1;
         } else {
             yasm_xfree(objfmt_coff);
             return NULL;
         }
 
         objfmt_coff->win32 = 1;
+        /* Define a @feat.00 symbol for win32 safeseh handling */
+        if (!objfmt_coff->win64) {
+            yasm_symrec *feat00;
+            coff_symrec_data *sym_data;
+            feat00 = yasm_symtab_define_equ(object->symtab, "@feat.00",
+                yasm_expr_create_ident(yasm_expr_int(
+                    yasm_intnum_create_uint(1)), 0), 0);
+            sym_data = coff_objfmt_sym_set_data(feat00, COFF_SCL_STAT, 0,
+                                                COFF_SYMTAB_AUX_NONE);
+            sym_data->forcevis = 1;
+        }
     }
     return (yasm_objfmt *)objfmt_coff;
 }
 
 static yasm_objfmt *
 win64_objfmt_create(yasm_object *object)
 {
     yasm_objfmt_coff *objfmt_coff = coff_common_create(object);
 
     if (objfmt_coff) {
         /* Support amd64 machine of x86 arch */
         if (yasm__strcasecmp(yasm_arch_get_machine(object->arch),
                              "amd64") == 0) {
             objfmt_coff->machine = COFF_MACHINE_AMD64;
         } else {
             yasm_xfree(objfmt_coff);
             return NULL;
         }
 
         objfmt_coff->objfmt.module = &yasm_win64_LTX_objfmt;
         objfmt_coff->win32 = 1;
         objfmt_coff->win64 = 1;
     }
     return (yasm_objfmt *)objfmt_coff;
 }
 
-static coff_section_data *
-coff_objfmt_init_new_section(yasm_object *object, yasm_section *sect,
-                             const char *sectname, unsigned long line)
+static void
+coff_objfmt_init_new_section(yasm_section *sect, unsigned long line)
 {
+    yasm_object *object = yasm_section_get_object(sect);
+    const char *sectname = yasm_section_get_name(sect);
     yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
     coff_section_data *data;
     yasm_symrec *sym;
 
     data = yasm_xmalloc(sizeof(coff_section_data));
     data->scnum = objfmt_coff->parse_scnum++;
     data->flags = 0;
     data->addr = 0;
     data->scnptr = 0;
     data->size = 0;
     data->relptr = 0;
     data->nreloc = 0;
     data->flags2 = 0;
     data->strtab_name = 0;
     data->isdebug = 0;
+
+    if (yasm__strncasecmp(sectname, ".debug", 6)==0) {
+        data->flags = COFF_STYP_DATA;
+        if (objfmt_coff->win32)
+            data->flags |= COFF_STYP_DISCARD|COFF_STYP_READ;
+        data->isdebug = 1;
+    } else
+        data->flags = COFF_STYP_TEXT;
+
     yasm_section_add_data(sect, &coff_section_data_cb, data);
 
     sym = yasm_symtab_define_label(object->symtab, sectname,
                                    yasm_section_bcs_first(sect), 1, line);
     yasm_symrec_declare(sym, YASM_SYM_GLOBAL, line);
     coff_objfmt_sym_set_data(sym, COFF_SCL_STAT, 1, COFF_SYMTAB_AUX_SECT);
     data->sym = sym;
-    return data;
-}
-
-static int
-coff_objfmt_init_remaining_section(yasm_section *sect, /*@null@*/ void *d)
-{
-    /*@null@*/ coff_objfmt_output_info *info = (coff_objfmt_output_info *)d;
-    /*@dependent@*/ /*@null@*/ coff_section_data *csd;
-
-    assert(info != NULL);
-    csd = yasm_section_get_data(sect, &coff_section_data_cb);
-    if (!csd) {
-        /* Initialize new one */
-        const char *sectname = yasm_section_get_name(sect);
-        csd = coff_objfmt_init_new_section(info->object, sect, sectname, 0);
-        if (yasm__strncasecmp(sectname, ".debug", 6)==0) {
-            csd->flags = COFF_STYP_DATA;
-            if (info->objfmt_coff->win32)
-                csd->flags |= COFF_STYP_DISCARD|COFF_STYP_READ;
-            csd->isdebug = 1;
-        } else
-            csd->flags = COFF_STYP_TEXT;
-    }
-
-    return 0;
 }
 
 static int
 coff_objfmt_set_section_addr(yasm_section *sect, /*@null@*/ void *d)
 {
     /*@null@*/ coff_objfmt_output_info *info = (coff_objfmt_output_info *)d;
     /*@dependent@*/ /*@null@*/ coff_section_data *csd;
 
     assert(info != NULL);
     csd = yasm_section_get_data(sect, &coff_section_data_cb);
@@ skipping 353 matching lines @@
             /*@notreached@*/
             return 1;
         }
 
         info->sect = sect;
         info->csd = csd;
         yasm_section_bcs_traverse(sect, info->errwarns, info,
                                   coff_objfmt_output_bytecode);
 
         /* Sanity check final section size */
-        if (csd->size != yasm_bc_next_offset(yasm_section_bcs_last(sect)))
+        if (yasm_errwarns_num_errors(info->errwarns, 0) == 0 &&
+            csd->size != yasm_bc_next_offset(yasm_section_bcs_last(sect)))
             yasm_internal_error(
                 N_("coff: section computed size did not match actual size"));
     }
 
     /* Empty?  Go on to next section */
     if (csd->size == 0)
         return 0;
 
     if (!csd->isdebug)
         info->addr += csd->size;
@@ skipping 133 matching lines @@
 static int
 coff_objfmt_count_sym(yasm_symrec *sym, /*@null@*/ void *d)
 {
     /*@null@*/ coff_objfmt_output_info *info = (coff_objfmt_output_info *)d;
     yasm_sym_vis vis = yasm_symrec_get_visibility(sym);
     coff_symrec_data *sym_data;
 
     assert(info != NULL);
 
     sym_data = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
-    if ((vis & (YASM_SYM_EXTERN|YASM_SYM_GLOBAL|YASM_SYM_COMMON)) && !sym_data)
-        sym_data = coff_objfmt_sym_set_data(sym, COFF_SCL_EXT, 0,
-                             COFF_SYMTAB_AUX_NONE);
 
-    if (info->all_syms || vis != YASM_SYM_LOCAL || yasm_symrec_is_abs(sym)) {
+    if (info->all_syms || vis != YASM_SYM_LOCAL || yasm_symrec_is_abs(sym) ||
+        (sym_data && sym_data->forcevis)) {
         /* Save index in symrec data */
-        if (!sym_data) {
-            sym_data = coff_objfmt_sym_set_data(sym, COFF_SCL_STAT, 0,
+        if (!sym_data)
+            sym_data = coff_objfmt_sym_set_data(sym, COFF_SCL_NULL, 0,
                                                 COFF_SYMTAB_AUX_NONE);
+        /* Set storage class based on visibility if not already set */
+        if (sym_data->sclass == COFF_SCL_NULL) {
+            if (vis & (YASM_SYM_EXTERN|YASM_SYM_GLOBAL|YASM_SYM_COMMON))
+                sym_data->sclass = COFF_SCL_EXT;
+            else
+                sym_data->sclass = COFF_SCL_STAT;
         }
+
         sym_data->index = info->indx;
 
         info->indx += sym_data->numaux + 1;
     }
     return 0;
 }
 
 static int
 coff_objfmt_output_sym(yasm_symrec *sym, /*@null@*/ void *d)
 {
     /*@null@*/ coff_objfmt_output_info *info = (coff_objfmt_output_info *)d;
     yasm_sym_vis vis = yasm_symrec_get_visibility(sym);
     int is_abs = yasm_symrec_is_abs(sym);
+    /*@dependent@*/ /*@null@*/ coff_symrec_data *csymd;
+    csymd = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
 
     assert(info != NULL);
 
     /* Don't output local syms unless outputting all syms */
-    if (info->all_syms || vis != YASM_SYM_LOCAL || is_abs) {
+    if (info->all_syms || vis != YASM_SYM_LOCAL || is_abs ||
+        (csymd && csymd->forcevis)) {
         /*@only*/ char *name;
         const yasm_expr *equ_val;
         const yasm_intnum *intn;
         unsigned char *localbuf;
         size_t len;
         int aux;
-        /*@dependent@*/ /*@null@*/ coff_symrec_data *csymd;
         unsigned long value = 0;
         unsigned int scnum = 0xfffe;    /* -2 = debugging symbol */
         /*@dependent@*/ /*@null@*/ yasm_section *sect;
         /*@dependent@*/ /*@null@*/ yasm_bytecode *precbc;
         unsigned long scnlen = 0;   /* for sect auxent */
         unsigned long nreloc = 0;   /* for sect auxent */
         yasm_objfmt_coff *objfmt_coff = info->objfmt_coff;
 
         if (is_abs)
             name = yasm__xstrdup(".absolut");
         else
             name = yasm_symrec_get_global_name(sym, info->object);
         len = strlen(name);
 
         /* Get symrec's of_data (needed for storage class) */
-        csymd = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
         if (!csymd)
             yasm_internal_error(N_("coff: expected sym data to be present"));
 
         /* Look at symrec for value/scnum/etc. */
         if (yasm_symrec_get_label(sym, &precbc)) {
             if (precbc)
                 sect = yasm_bc_get_section(precbc);
             else
                 sect = NULL;
             /* it's a label: get value and offset.
@@ skipping 51 matching lines @@
             YASM_WRITE_32_L(localbuf, 0);       /* "zeros" field */
             YASM_WRITE_32_L(localbuf, info->strtab_offset); /* strtab offset */
             info->strtab_offset += (unsigned long)(len+1);
         } else {
             /* <8 chars, so no string table entry needed */
             strncpy((char *)localbuf, name, 8);
             localbuf += 8;
         }
         YASM_WRITE_32_L(localbuf, value);       /* value */
         YASM_WRITE_16_L(localbuf, scnum);       /* section number */
-        YASM_WRITE_16_L(localbuf, 0);       /* type is always zero (for now) */
+        YASM_WRITE_16_L(localbuf, csymd->type); /* type */
         YASM_WRITE_8(localbuf, csymd->sclass);  /* storage class */
         YASM_WRITE_8(localbuf, csymd->numaux);  /* number of aux entries */
         fwrite(info->buf, 18, 1, info->f);
         for (aux=0; aux<csymd->numaux; aux++) {
             localbuf = info->buf;
             memset(localbuf, 0, 18);
             switch (csymd->auxtype) {
                 case COFF_SYMTAB_AUX_NONE:
                     break;
                 case COFF_SYMTAB_AUX_SECT:
@@ skipping 19 matching lines @@
         yasm_xfree(name);
     }
     return 0;
 }
 
 static int
 coff_objfmt_output_str(yasm_symrec *sym, /*@null@*/ void *d)
 {
     /*@null@*/ coff_objfmt_output_info *info = (coff_objfmt_output_info *)d;
     yasm_sym_vis vis = yasm_symrec_get_visibility(sym);
+    /*@dependent@*/ /*@null@*/ coff_symrec_data *csymd;
+    csymd = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
 
     assert(info != NULL);
 
     /* Don't output local syms unless outputting all syms */
-    if (info->all_syms || vis != YASM_SYM_LOCAL) {
+    if (info->all_syms || vis != YASM_SYM_LOCAL ||
+        (csymd && csymd->forcevis)) {
         /*@only@*/ char *name = yasm_symrec_get_global_name(sym, info->object);
-        /*@dependent@*/ /*@null@*/ coff_symrec_data *csymd;
         size_t len = strlen(name);
         int aux;
 
-        csymd = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
         if (!csymd)
             yasm_internal_error(N_("coff: expected sym data to be present"));
 
         if (len > 8)
             fwrite(name, len+1, 1, info->f);
         for (aux=0; aux<csymd->numaux; aux++) {
             switch (csymd->auxtype) {
                 case COFF_SYMTAB_AUX_FILE:
                     len = strlen(csymd->aux[0].fname);
                     if (len > 14)
@@ skipping 41 matching lines @@
      */
     all_syms |= objfmt_coff->win64;
 
     info.strtab_offset = 4;
     info.object = object;
     info.objfmt_coff = objfmt_coff;
     info.errwarns = errwarns;
     info.f = f;
     info.buf = yasm_xmalloc(REGULAR_OUTBUF_SIZE);
 
-    /* Initialize section data (and count in parse_scnum) any sections that
-     * we've not initialized so far.
-     */
-    yasm_object_sections_traverse(object, &info,
-                                  coff_objfmt_init_remaining_section);
-
     /* Allocate space for headers by seeking forward */
     if (fseek(f, (long)(20+40*(objfmt_coff->parse_scnum-1)), SEEK_SET) < 0) {
         yasm__fatal(N_("could not seek on output file"));
         /*@notreached@*/
         return;
     }
 
     /* Finalize symbol table (assign index to each symbol) */
     info.indx = 0;
     info.all_syms = all_syms;
@@ skipping 80 matching lines @@
 static yasm_section *
 coff_objfmt_add_default_section(yasm_object *object)
 {
     yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
     yasm_section *retval;
     coff_section_data *csd;
     int isnew;
 
     retval = yasm_object_get_general(object, ".text", 16, 1, 0, &isnew, 0);
     if (isnew) {
-        csd = coff_objfmt_init_new_section(object, retval, ".text", 0);
+        csd = yasm_section_get_data(retval, &coff_section_data_cb);
         csd->flags = COFF_STYP_TEXT;
         if (objfmt_coff->win32)
             csd->flags |= COFF_STYP_EXECUTE | COFF_STYP_READ;
         yasm_section_set_default(retval, 1);
     }
     return retval;
 }
 
 struct coff_section_switch_data {
     int isdefault;
@@ skipping 262 matching lines @@
          * files via "/nnnn" (where nnnn is decimal offset into string table),
          * so only warn for regular COFF.
          */
         yasm_warn_set(YASM_WARN_GENERAL,
             N_("COFF section names limited to 8 characters: truncating"));
         realname[8] = '\0';
     }
 
     retval = yasm_object_get_general(object, realname, align, iscode,
                                      resonly, &isnew, line);
+    yasm_xfree(realname);
 
-    if (isnew)
-        csd = coff_objfmt_init_new_section(object, retval, realname, line);
-    else
-        csd = yasm_section_get_data(retval, &coff_section_data_cb);
-
-    yasm_xfree(realname);
+    csd = yasm_section_get_data(retval, &coff_section_data_cb);
 
     if (isnew || yasm_section_is_default(retval)) {
         yasm_section_set_default(retval, 0);
         csd->flags = data.flags;
         csd->flags2 = data.flags2;
         yasm_section_set_align(retval, align, line);
     } else if (flags_override && !data.gasflags)
         yasm_warn_set(YASM_WARN_GENERAL,
                       N_("section flags ignored on section redeclaration"));
     return retval;
@@ skipping 78 matching lines @@
                        N_("argument to EXPORT must be symbol name"));
         return;
     }
 
     /* Add to end of linker directives */
     sect = yasm_object_get_general(object, ".drectve", 0, 0, 0, &isnew, line);
 
     /* Initialize directive section if needed */
     if (isnew) {
         coff_section_data *csd;
-        csd = coff_objfmt_init_new_section(object, sect,
-                                           yasm_section_get_name(sect), line);
+        csd = yasm_section_get_data(sect, &coff_section_data_cb);
         csd->flags = COFF_STYP_INFO | COFF_STYP_DISCARD | COFF_STYP_READ;
     }
 
     /* Add text as data bytecode */
     yasm_dvs_initialize(&dvs);
     yasm_dvs_append(&dvs, yasm_dv_create_string(yasm__xstrdup("-export:"),
                                                 strlen("-export:")));
     yasm_dvs_append(&dvs, yasm_dv_create_string(yasm__xstrdup(symname),
                                                 strlen(symname)));
     yasm_dvs_append(&dvs, yasm_dv_create_string(yasm__xstrdup(" "), 1));
     yasm_section_bcs_append(sect, yasm_bc_create_data(&dvs, 1, 0, NULL, line));
 }
 
 static void
 dir_safeseh(yasm_object *object, yasm_valparamhead *valparams,
             yasm_valparamhead *objext_valparams, unsigned long line)
 {
     yasm_valparam *vp;
     /*@null@*/ const char *symname;
     yasm_symrec *sym;
     int isnew;
     yasm_section *sect;
 
     /* Reference symbol (to generate error if not declared).
-     * Also, symbol must be externally visible, so force global.
+     * Also, symbol must be externally visible, so force it.
      */
     vp = yasm_vps_first(valparams);
     symname = yasm_vp_id(vp);
     if (symname) {
+        coff_symrec_data *sym_data;
         sym = yasm_symtab_use(object->symtab, symname, line);
-        yasm_symrec_declare(sym, YASM_SYM_GLOBAL, line);
+        sym_data = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
+        if (!sym_data) {
+            sym_data = coff_objfmt_sym_set_data(sym, COFF_SCL_NULL, 0,
+                                                COFF_SYMTAB_AUX_NONE);
+        }
+        sym_data->forcevis = 1;
+        sym_data->type = 0x20; /* function */
     } else {
         yasm_error_set(YASM_ERROR_SYNTAX,
                        N_("argument to SAFESEH must be symbol name"));
         return;
     }
 
     /*
      * Add symbol number to end of .sxdata section.
      */
 
     sect = yasm_object_get_general(object, ".sxdata", 0, 0, 0, &isnew, line);
 
     /* Initialize sxdata section if needed */
     if (isnew) {
         coff_section_data *csd;
-        csd = coff_objfmt_init_new_section(object, sect, ".sxdata", line);
+        csd = yasm_section_get_data(sect, &coff_section_data_cb);
         csd->flags = COFF_STYP_INFO;
     }
 
     /* Add as sxdata bytecode */
     yasm_section_bcs_append(sect,
                             yasm_bc_create_common(&win32_sxdata_bc_callback,
                                                   sym, line));
 }
 
 static void
@@ skipping 389 matching lines @@
     curpos = get_curpos(object, "ENDPROC_FRAME", line);
 
     /*
      * Add unwind info to end of .xdata section.
      */
 
     sect = yasm_object_get_general(object, ".xdata", 0, 0, 0, &isnew, line);
 
     /* Initialize xdata section if needed */
     if (isnew) {
-        csd = coff_objfmt_init_new_section(object, sect, ".xdata", line);
+        csd = yasm_section_get_data(sect, &coff_section_data_cb);
         csd->flags = COFF_STYP_DATA | COFF_STYP_READ;
         yasm_section_set_align(sect, 8, line);
     }
 
     /* Get current position in .xdata section */
     unwindpos = yasm_symtab_define_curpos(object->symtab, "$",
         yasm_section_bcs_last(sect), line);
     /* Get symbol for .xdata as we'll want to reference it with WRT */
     csd = yasm_section_get_data(sect, &coff_section_data_cb);
     xdata_sym = csd->sym;
 
     /* Add unwind info.  Use line number of start of procedure. */
     yasm_win64__unwind_generate(sect, objfmt_coff->unwind,
                                 objfmt_coff->proc_frame);
     objfmt_coff->unwind = NULL; /* generate keeps the unwind pointer */
 
     /*
      * Add function lookup to end of .pdata section.
      */
 
     sect = yasm_object_get_general(object, ".pdata", 0, 0, 0, &isnew, line);
 
     /* Initialize pdata section if needed */
     if (isnew) {
-        csd = coff_objfmt_init_new_section(object, sect, ".pdata", line);
+        csd = yasm_section_get_data(sect, &coff_section_data_cb);
         csd->flags = COFF_STYP_DATA | COFF_STYP_READ;
         csd->flags2 = COFF_FLAG_NOBASE;
         yasm_section_set_align(sect, 4, line);
     }
 
     /* Add function structure as data bytecode */
     yasm_dvs_initialize(&dvs);
     yasm_dvs_append(&dvs, yasm_dv_create_expr(
         yasm_expr_create_ident(yasm_expr_sym(proc_sym), line)));
     yasm_dvs_append(&dvs, yasm_dv_create_expr(
@@ skipping 29 matching lines @@
     32,
     0,
     coff_objfmt_dbgfmt_keywords,
     "null",
     coff_objfmt_directives,
     NULL,   /* no standard macros */
     coff_objfmt_create,
     coff_objfmt_output,
     coff_objfmt_destroy,
     coff_objfmt_add_default_section,
+    coff_objfmt_init_new_section,
     coff_objfmt_section_switch,
     coff_objfmt_get_special_sym
 };
 
 /* Define valid debug formats to use with this object format */
 static const char *winXX_objfmt_dbgfmt_keywords[] = {
     "null",
     "dwarf2",
     "cv8",
     NULL
@@ skipping 32 matching lines @@
     32,
     1,
     winXX_objfmt_dbgfmt_keywords,
     "null",
     win32_objfmt_directives,
     win32_objfmt_stdmacs,
     win32_objfmt_create,
     coff_objfmt_output,
     coff_objfmt_destroy,
     coff_objfmt_add_default_section,
+    coff_objfmt_init_new_section,
     coff_objfmt_section_switch,
     coff_objfmt_get_special_sym
 };
 
 static const yasm_directive win64_objfmt_directives[] = {
     { ".ident",         "gas",  dir_ident,      YASM_DIR_ANY },
     { "ident",          "nasm", dir_ident,      YASM_DIR_ANY },
     { ".export",        "gas",  dir_export,     YASM_DIR_ID_REQUIRED },
     { "export",         "nasm", dir_export,     YASM_DIR_ID_REQUIRED },
     { ".proc_frame",    "gas",  dir_proc_frame, YASM_DIR_ID_REQUIRED },
@@ skipping 34 matching lines @@
     64,
     1,
     winXX_objfmt_dbgfmt_keywords,
     "null",
     win64_objfmt_directives,
     win64_objfmt_stdmacs,
     win64_objfmt_create,
     coff_objfmt_output,
     coff_objfmt_destroy,
     coff_objfmt_add_default_section,
+    coff_objfmt_init_new_section,
     coff_objfmt_section_switch,
     coff_objfmt_get_special_sym
 };
 yasm_objfmt_module yasm_x64_LTX_objfmt = {
     "Win64",
     "x64",
     "obj",
     64,
     1,
     winXX_objfmt_dbgfmt_keywords,
     "null",
     win64_objfmt_directives,
     win64_objfmt_stdmacs,
     win64_objfmt_create,
     coff_objfmt_output,
     coff_objfmt_destroy,
     coff_objfmt_add_default_section,
+    coff_objfmt_init_new_section,
     coff_objfmt_section_switch,
     coff_objfmt_get_special_sym
 };