Update Yasm to 1.2.0 (Yasm Part 1/3)

third_party/yasm/patched-yasm/libyasm/bc-data.c

 /*
  * Data (and LEB128) bytecode
  *
  *  Copyright (C) 2001-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"
-/*@unused@*/ RCSID("$Id: bc-data.c 2133 2008-10-07 05:59:29Z peter $");
 
 #include "libyasm-stdint.h"
 #include "coretype.h"
 
 #include "errwarn.h"
 #include "intnum.h"
 #include "expr.h"
 #include "value.h"
 
 #include "bytecode.h"
@@ skipping 24 matching lines @@
 
     int item_size;
 } bytecode_data;
 
 static void bc_data_destroy(void *contents);
 static void bc_data_print(const void *contents, FILE *f, int indent_level);
 static void bc_data_finalize(yasm_bytecode *bc, yasm_bytecode *prev_bc);
 static int bc_data_item_size(yasm_bytecode *bc);
 static int bc_data_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
                             void *add_span_data);
-static int bc_data_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+static int bc_data_tobytes(yasm_bytecode *bc, unsigned char **bufp,
+                           unsigned char *bufstart, void *d,
                            yasm_output_value_func output_value,
                            /*@null@*/ yasm_output_reloc_func output_reloc);
 
 static const yasm_bytecode_callback bc_data_callback = {
     bc_data_destroy,
     bc_data_print,
     bc_data_finalize,
     bc_data_item_size,
     bc_data_calc_len,
     yasm_bc_expand_common,
@@ skipping 112 matching lines @@
         if (!yasm_dv_get_multiple(dv, &multiple))
             len *= multiple;
 
         bc->len += len;
     }
 
     return 0;
 }
 
 static int
-bc_data_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+bc_data_tobytes(yasm_bytecode *bc, unsigned char **bufp,
+                unsigned char *bufstart, void *d,
                 yasm_output_value_func output_value,
                 /*@unused@*/ yasm_output_reloc_func output_reloc)
 {
     bytecode_data *bc_data = (bytecode_data *)bc->contents;
     yasm_dataval *dv;
-    unsigned char *bufp_orig = *bufp;
     yasm_intnum *intn;
     unsigned int val_len;
     unsigned long multiple, i;
 
     STAILQ_FOREACH(dv, &bc_data->datahead, link) {
         if (yasm_dv_get_multiple(dv, &multiple) || multiple == 0)
             continue;
         switch (dv->type) {
             case DV_EMPTY:
                 break;
             case DV_VALUE:
                 val_len = dv->data.val.size/8;
                 for (i=0; i<multiple; i++) {
                     if (output_value(&dv->data.val, *bufp, val_len,
-                                     (unsigned long)(*bufp-bufp_orig), bc, 1,
+                                     (unsigned long)(*bufp-bufstart), bc, 1,
                                      d))
                         return 1;
                     *bufp += val_len;
                 }
                 break;
             case DV_RAW:
                 for (i=0; i<multiple; i++) {
                     memcpy(*bufp, dv->data.raw.contents, dv->data.raw.len);
                     *bufp += dv->data.raw.len;
                 }
@@ skipping 235 matching lines @@
 yasm_dv_create_reserve(void)
 {
     yasm_dataval *retval = yasm_xmalloc(sizeof(yasm_dataval));
 
     retval->type = DV_RESERVE;
     retval->multiple = NULL;
 
     return retval;
 }
 
+yasm_value *
+yasm_dv_get_value(yasm_dataval *dv)
+{
+    if (dv->type != DV_VALUE)
+        return NULL;
+    return &dv->data.val;
+}
+
 void
 yasm_dv_set_multiple(yasm_dataval *dv, yasm_expr *e)
 {
     if (dv->multiple)
         dv->multiple = yasm_expr_create_tree( dv->multiple, YASM_EXPR_MUL, e,
                                              e->line);
     else
         dv->multiple = e;
 }
 
@@ skipping 90 matching lines @@
             case DV_SLEB128:
                 fprintf(f, "%*sSLEB128 value:\n", indent_level, "");
                 yasm_value_print(&cur->data.val, f, indent_level+1);
                 break;
             case DV_RESERVE:
                 fprintf(f, "%*sReserved\n", indent_level, "");
                 break;
         }
     }
 }