Update Yasm to 1.2.0 (Yasm Part 1/3)

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 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 136 matching lines @@
     yasm_objfmt_base objfmt;                /* base structure */
 
     unsigned int parse_scnum;               /* sect numbering in parser */
     int win32;                              /* nonzero for win32/64 output */
     int win64;                              /* nonzero for win64 output */
 
     unsigned int machine;                   /* COFF machine to use */
 
     coff_symrec_data *filesym_data;         /* Data for .file symbol */
 
+    /* data for .def/.endef and related directives */
+    coff_symrec_data *def_sym;              /* symbol specified by .def */
+
     /* data for win64 proc_frame and related directives */
     unsigned long proc_frame;   /* Line number of start of proc, or 0 */
     unsigned long done_prolog;  /* Line number of end of prologue, or 0 */
     /*@null@*/ coff_unwind_info *unwind;        /* Unwind info */
+
+    yasm_symrec *ssym_imagebase;            /* ..imagebase symbol for win64 */
 } yasm_objfmt_coff;
 
 typedef struct coff_objfmt_output_info {
     yasm_object *object;
     yasm_objfmt_coff *objfmt_coff;
     yasm_errwarns *errwarns;
     /*@dependent@*/ FILE *f;
     /*@only@*/ unsigned char *buf;
     yasm_section *sect;
     /*@dependent@*/ coff_section_data *csd;
@@ skipping 20 matching lines @@
     coff_symrec_data_print
 };
 
 /* Bytecode callback function prototypes */
 static void win32_sxdata_bc_destroy(void *contents);
 static void win32_sxdata_bc_print(const void *contents, FILE *f,
                                   int indent_level);
 static int win32_sxdata_bc_calc_len
     (yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
 static int win32_sxdata_bc_tobytes
-    (yasm_bytecode *bc, unsigned char **bufp, void *d,
+    (yasm_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, void *d,
      yasm_output_value_func output_value,
      /*@null@*/ yasm_output_reloc_func output_reloc);
 
 /* Bytecode callback structures */
 static const yasm_bytecode_callback win32_sxdata_bc_callback = {
     win32_sxdata_bc_destroy,
     win32_sxdata_bc_print,
     yasm_bc_finalize_common,
     NULL,
     win32_sxdata_bc_calc_len,
@@ skipping 46 matching lines @@
                                          YASM_SYM_GLOBAL);
     objfmt_coff->filesym_data =
         coff_objfmt_sym_set_data(filesym, COFF_SCL_FILE, 1,
                                  COFF_SYMTAB_AUX_FILE);
     /* Filename is set in coff_objfmt_output */
     objfmt_coff->filesym_data->aux[0].fname = NULL;
 
     objfmt_coff->proc_frame = 0;
     objfmt_coff->done_prolog = 0;
     objfmt_coff->unwind = NULL;
+    objfmt_coff->ssym_imagebase = NULL;
 
     return objfmt_coff;
 }
 
 static yasm_objfmt *
 coff_objfmt_create(yasm_object *object)
 {
     yasm_objfmt_coff *objfmt_coff = coff_common_create(object);
 
     if (objfmt_coff) {
@@ skipping 66 matching lines @@
                              "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;
+        objfmt_coff->ssym_imagebase =
+            yasm_symtab_define_label(object->symtab, "..imagebase", NULL, 0, 0);
     }
     return (yasm_objfmt *)objfmt_coff;
 }
 
 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;
@@ skipping 87 matching lines @@
         return 1;
     }
 
     intn_val = 0;
     intn_minus = 0;
     if (value->rel) {
         yasm_sym_vis vis = yasm_symrec_get_visibility(value->rel);
         /*@dependent@*/ /*@null@*/ yasm_symrec *sym = value->rel;
         unsigned long addr;
         coff_reloc *reloc;
+        int nobase = info->csd->flags2 & COFF_FLAG_NOBASE;
 
         /* Sometimes we want the relocation to be generated against one
          * symbol but the value generated correspond to a different symbol.
          * This is done through (sym being referenced) WRT (sym used for
          * reloc).  Note both syms need to be in the same section!
          */
-        if (value->wrt) {
+        if (value->wrt && value->wrt == objfmt_coff->ssym_imagebase)
+            nobase = 1;
+        else if (value->wrt) {
             /*@dependent@*/ /*@null@*/ yasm_bytecode *rel_precbc, *wrt_precbc;
+
             if (!yasm_symrec_get_label(sym, &rel_precbc)
                 || !yasm_symrec_get_label(value->wrt, &wrt_precbc)) {
                 yasm_error_set(YASM_ERROR_TOO_COMPLEX,
                                N_("coff: wrt expression too complex"));
                 return 1;
             }
             dist = yasm_calc_bc_dist(wrt_precbc, rel_precbc);
             if (!dist) {
                 yasm_error_set(YASM_ERROR_TOO_COMPLEX,
                                N_("coff: cannot wrt across sections"));
@@ skipping 54 matching lines @@
              * taken care of by special relocation types.
              */
             if (objfmt_coff->win64 && value->ip_rel)
                 intn_val += bc->len*bc->mult_int;
             else if (objfmt_coff->win32)
                 intn_val += offset+destsize;
             else
                 intn_minus = bc->offset;
         }
 
-        if (value->seg_of || value->section_rel) {
-            /* Segment or section-relative generation; zero value. */
+        if (value->seg_of) {
+            /* Segment generation; zero value. */
             intn_val = 0;
             intn_minus = 0;
         }
 
         /* Generate reloc */
         reloc = yasm_xmalloc(sizeof(coff_reloc));
         addr = bc->offset + offset;
         if (COFF_SET_VMA)
             addr += info->addr;
         reloc->reloc.addr = yasm_intnum_create_uint(addr);
@@ skipping 51 matching lines @@
                 yasm_internal_error(N_("coff objfmt: unrecognized machine"));
         } else if (value->section_rel) {
             if (objfmt_coff->machine == COFF_MACHINE_I386)
                 reloc->type = COFF_RELOC_I386_SECREL;
             else if (objfmt_coff->machine == COFF_MACHINE_AMD64)
                 reloc->type = COFF_RELOC_AMD64_SECREL;
             else
                 yasm_internal_error(N_("coff objfmt: unrecognized machine"));
         } else {
             if (objfmt_coff->machine == COFF_MACHINE_I386) {
-                if (info->csd->flags2 & COFF_FLAG_NOBASE)
+                if (nobase)
                     reloc->type = COFF_RELOC_I386_ADDR32NB;
                 else
                     reloc->type = COFF_RELOC_I386_ADDR32;
             } else if (objfmt_coff->machine == COFF_MACHINE_AMD64) {
                 if (valsize == 32) {
-                    if (info->csd->flags2 & COFF_FLAG_NOBASE)
+                    if (nobase)
                         reloc->type = COFF_RELOC_AMD64_ADDR32NB;
                     else
                         reloc->type = COFF_RELOC_AMD64_ADDR32;
                 } else if (valsize == 64)
                     reloc->type = COFF_RELOC_AMD64_ADDR64;
                 else {
                     yasm_error_set(YASM_ERROR_TYPE,
                                    N_("coff: invalid relocation size"));
                     return 1;
                 }
@@ skipping 843 matching lines @@
         data.flags = COFF_STYP_INFO;
         if (objfmt_coff->win32)
             data.flags |= COFF_STYP_DISCARD | COFF_STYP_READ;
     } else if (objfmt_coff->win64 && strcmp(sectname, ".pdata") == 0) {
         data.flags = COFF_STYP_DATA | COFF_STYP_READ;
         align = 4;
         data.flags2 = COFF_FLAG_NOBASE;
     } else if (objfmt_coff->win64 && strcmp(sectname, ".xdata") == 0) {
         data.flags = COFF_STYP_DATA | COFF_STYP_READ;
         align = 8;
+        data.flags2 = COFF_FLAG_NOBASE;
     } else if (objfmt_coff->win32 && strcmp(sectname, ".sxdata") == 0) {
         data.flags = COFF_STYP_INFO;
     } else if (strcmp(sectname, ".comment") == 0) {
         data.flags = COFF_STYP_INFO | COFF_STYP_DISCARD | COFF_STYP_READ;
     } else if (yasm__strncasecmp(sectname, ".debug", 6)==0) {
         data.flags = COFF_STYP_DATA | COFF_STYP_DISCARD | COFF_STYP_READ;
         align = 1;
     } else {
         /* Default to code, but set a flag so if we get gasflags we can
          * change it (NASM and GAS have different defaults).
@@ skipping 62 matching lines @@
     return retval;
 }
 
 static /*@observer@*/ /*@null@*/ yasm_symrec *
 coff_objfmt_get_special_sym(yasm_object *object, const char *name,
                             const char *parser)
 {
     return NULL;
 }
 
+static /*@observer@*/ /*@null@*/ yasm_symrec *
+win64_objfmt_get_special_sym(yasm_object *object, const char *name,
+                             const char *parser)
+{
+    if (yasm__strcasecmp(name, "imagebase") == 0) {
+        yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
+        return objfmt_coff->ssym_imagebase;
+    }
+    return NULL;
+}
+
 static void
 coff_section_data_destroy(void *data)
 {
     yasm_xfree(data);
 }
 
 static void
 coff_section_data_print(void *data, FILE *f, int indent_level)
 {
     coff_section_data *csd = (coff_section_data *)data;
@@ skipping 144 matching lines @@
 
 static int
 win32_sxdata_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
                          void *add_span_data)
 {
     bc->len += 4;
     return 0;
 }
 
 static int
-win32_sxdata_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+win32_sxdata_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
+                        unsigned char *bufstart, void *d,
                         yasm_output_value_func output_value,
                         yasm_output_reloc_func output_reloc)
 {
     yasm_symrec *sym = (yasm_symrec *)bc->contents;
     unsigned char *buf = *bufp;
     coff_symrec_data *csymd;
 
     csymd = yasm_symrec_get_data(sym, &coff_symrec_data_cb);
     if (!csymd)
         yasm_internal_error(N_("coff: no symbol data for SAFESEH symbol"));
@@ skipping 61 matching lines @@
         }
         yasm_dvs_append(&dvs,
                         yasm_dv_create_string(yasm__xstrdup(s), strlen(s)));
     } while ((vp = yasm_vps_next(vp)));
 
     yasm_section_bcs_append(comment,
         yasm_bc_create_data(&dvs, 1, 1, object->arch, line));
 }
 
 static void
+dir_secrel32(yasm_object *object, yasm_valparamhead *valparams,
+             yasm_valparamhead *objext_valparams, unsigned long line)
+{
+    yasm_datavalhead dvs;
+    yasm_valparam *vp;
+
+    if (!object->cur_section) {
+        yasm_error_set(YASM_ERROR_SYNTAX,
+                       N_(".secrel32 can only be used inside of a section"));
+        return;
+    }
+
+    vp = yasm_vps_first(valparams);
+    yasm_dvs_initialize(&dvs);
+    do {
+        yasm_expr *e = yasm_vp_expr(vp, object->symtab, line);
+        yasm_dataval *dv;
+        if (!e) {
+            yasm_error_set(YASM_ERROR_VALUE,
+                           N_(".secrel32 requires expressions"));
+            yasm_dvs_delete(&dvs);
+            return;
+        }
+        dv = yasm_dv_create_expr(e);
+        yasm_dv_get_value(dv)->section_rel = 1;
+        yasm_dvs_append(&dvs, dv);
+    } while ((vp = yasm_vps_next(vp)));
+
+    yasm_section_bcs_append(object->cur_section,
+        yasm_bc_create_data(&dvs, 4, 0, object->arch, line));
+}
+
+static void
+dir_def(yasm_object *object, yasm_valparamhead *valparams,
+        yasm_valparamhead *objext_valparams, unsigned long line)
+{
+    yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
+    yasm_valparam *vp;
+    const char *symname;
+    yasm_symrec *sym;
+    coff_symrec_data *sym_data;
+
+    if (objfmt_coff->def_sym) {
+        yasm_warn_set(YASM_WARN_GENERAL,
+                      N_(".def pseudo-op used inside of .def/.endef; ignored"));
+        return;
+    }
+
+    vp = yasm_vps_first(valparams);
+    symname = yasm_vp_id(vp);
+    if (!symname) {
+        yasm_error_set(YASM_ERROR_SYNTAX,
+                       N_("argument to SAFESEH must be symbol name"));
+        return;
+    }
+
+    sym = yasm_symtab_use(object->symtab, symname, 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);
+    }
+    objfmt_coff->def_sym = sym_data;
+}
+
+static void
+dir_scl(yasm_object *object, yasm_valparamhead *valparams,
+        yasm_valparamhead *objext_valparams, unsigned long line)
+{
+    yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
+    yasm_intnum *intn = NULL;
+
+    if (!objfmt_coff->def_sym) {
+        yasm_warn_set(YASM_WARN_GENERAL,
+                      N_("%s pseudo-op used outside of .def/.endef; ignored"),
+                      ".scl");
+        return;
+    }
+
+    if (yasm_dir_helper_intn(object, yasm_vps_first(valparams), line,
+                             &intn, 0) < 0)
+        return;
+    if (!intn)
+        return;
+    objfmt_coff->def_sym->sclass = yasm_intnum_get_uint(intn);
+    yasm_intnum_destroy(intn);
+}
+
+static void
+dir_type(yasm_object *object, yasm_valparamhead *valparams,
+         yasm_valparamhead *objext_valparams, unsigned long line)
+{
+    yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
+    yasm_intnum *intn = NULL;
+
+    if (!objfmt_coff->def_sym) {
+        yasm_warn_set(YASM_WARN_GENERAL,
+                      N_("%s pseudo-op used outside of .def/.endef; ignored"),
+                      ".type");
+        return;
+    }
+
+    if (yasm_dir_helper_intn(object, yasm_vps_first(valparams), line,
+                             &intn, 0) < 0)
+        return;
+    if (!intn)
+        return;
+    objfmt_coff->def_sym->type = yasm_intnum_get_uint(intn);
+    yasm_intnum_destroy(intn);
+}
+
+static void
+dir_endef(yasm_object *object, yasm_valparamhead *valparams,
+          yasm_valparamhead *objext_valparams, unsigned long line)
+{
+    yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
+    if (!objfmt_coff->def_sym) {
+        yasm_warn_set(YASM_WARN_GENERAL,
+                      N_(".endef pseudo-op used before .def; ignored"));
+        return;
+    }
+    objfmt_coff->def_sym = NULL;
+}
+
+static void
 dir_proc_frame(yasm_object *object, /*@null@*/ yasm_valparamhead *valparams,
                yasm_valparamhead *objext_valparams, unsigned long line)
 {
     yasm_objfmt_coff *objfmt_coff = (yasm_objfmt_coff *)object->objfmt;
     yasm_valparam *vp = yasm_vps_first(valparams);
     const char *name = yasm_vp_id(vp);
 
     if (objfmt_coff->proc_frame) {
         yasm_error_set_xref(objfmt_coff->proc_frame,
                             N_("previous procedure started here"));
@@ skipping 334 matching lines @@
 /* Define valid debug formats to use with this object format */
 static const char *coff_objfmt_dbgfmt_keywords[] = {
     "null",
     "dwarf2",
     NULL
 };
 
 static const yasm_directive coff_objfmt_directives[] = {
     { ".ident",         "gas",  dir_ident,      YASM_DIR_ANY },
     { "ident",          "nasm", dir_ident,      YASM_DIR_ANY },
+    { ".def",           "gas",  dir_def,        YASM_DIR_ID_REQUIRED },
+    { ".endef",         "gas",  dir_endef,      YASM_DIR_ANY },
+    { ".scl",           "gas",  dir_scl,        YASM_DIR_ARG_REQUIRED },
+    { ".type",          "gas",  dir_type,       YASM_DIR_ARG_REQUIRED },
+    { ".secrel32",      "gas",  dir_secrel32,   YASM_DIR_ARG_REQUIRED },
     { NULL, NULL, NULL, 0 }
 };
 
 /* Define objfmt structure -- see objfmt.h for details */
 yasm_objfmt_module yasm_coff_LTX_objfmt = {
     "COFF (DJGPP)",
     "coff",
     "o",
     32,
     0,
@@ skipping 14 matching lines @@
 static const char *winXX_objfmt_dbgfmt_keywords[] = {
     "null",
     "dwarf2",
     "cv8",
     NULL
 };
 
 static const yasm_directive win32_objfmt_directives[] = {
     { ".ident",         "gas",  dir_ident,      YASM_DIR_ANY },
     { "ident",          "nasm", dir_ident,      YASM_DIR_ANY },
+    { ".def",           "gas",  dir_def,        YASM_DIR_ID_REQUIRED },
+    { ".endef",         "gas",  dir_endef,      YASM_DIR_ANY },
+    { ".scl",           "gas",  dir_scl,        YASM_DIR_ARG_REQUIRED },
+    { ".type",          "gas",  dir_type,       YASM_DIR_ARG_REQUIRED },
+    { ".secrel32",      "gas",  dir_secrel32,   YASM_DIR_ARG_REQUIRED },
     { ".export",        "gas",  dir_export,     YASM_DIR_ID_REQUIRED },
     { "export",         "nasm", dir_export,     YASM_DIR_ID_REQUIRED },
     { ".safeseh",       "gas",  dir_safeseh,    YASM_DIR_ID_REQUIRED },
     { "safeseh",        "nasm", dir_safeseh,    YASM_DIR_ID_REQUIRED },
     { NULL, NULL, NULL, 0 }
 };
 
 static const char *win32_nasm_stdmac[] = {
     "%imacro export 1+.nolist",
     "[export %1]",
@@ skipping 25 matching lines @@
     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 },
+    { ".def",           "gas",  dir_def,        YASM_DIR_ID_REQUIRED },
+    { ".endef",         "gas",  dir_endef,      YASM_DIR_ANY },
+    { ".scl",           "gas",  dir_scl,        YASM_DIR_ARG_REQUIRED },
+    { ".type",          "gas",  dir_type,       YASM_DIR_ARG_REQUIRED },
+    { ".secrel32",      "gas",  dir_secrel32,   YASM_DIR_ARG_REQUIRED },
     { ".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 },
     { "proc_frame",     "nasm", dir_proc_frame, YASM_DIR_ID_REQUIRED },
     { ".pushreg",       "gas",  dir_pushreg,    YASM_DIR_ARG_REQUIRED },
     { "pushreg",        "nasm", dir_pushreg,    YASM_DIR_ARG_REQUIRED },
     { ".setframe",      "gas",  dir_setframe,   YASM_DIR_ARG_REQUIRED },
     { "setframe",       "nasm", dir_setframe,   YASM_DIR_ARG_REQUIRED },
     { ".allocstack",    "gas",  dir_allocstack, YASM_DIR_ARG_REQUIRED },
     { "allocstack",     "nasm", dir_allocstack, YASM_DIR_ARG_REQUIRED },
@@ skipping 29 matching lines @@
     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
+    win64_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
+    win64_objfmt_get_special_sym
 };