Update Yasm to 1.2.0 (Yasm Part 1/3)

third_party/yasm/patched-yasm/modules/objfmts/coff/win64-except.c

 /*
  * Win64 structured exception handling support
  *
  *  Copyright (C) 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: win64-except.c 2130 2008-10-07 05:38:11Z peter $");
 
 #include <libyasm.h>
 
 #include "coff-objfmt.h"
 
 
 #define UNW_FLAG_EHANDLER   0x01
 #define UNW_FLAG_UHANDLER   0x02
 #define UNW_FLAG_CHAININFO  0x04
 
 /* Bytecode callback function prototypes */
 static void win64_uwinfo_bc_destroy(void *contents);
 static void win64_uwinfo_bc_print(const void *contents, FILE *f,
                                   int indent_level);
 static void win64_uwinfo_bc_finalize(yasm_bytecode *bc,
                                      yasm_bytecode *prev_bc);
 static int win64_uwinfo_bc_calc_len
     (yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
 static int win64_uwinfo_bc_expand(yasm_bytecode *bc, int span, long old_val,
                                   long new_val, /*@out@*/ long *neg_thres,
                                   /*@out@*/ long *pos_thres);
 static int win64_uwinfo_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);
 
 static void win64_uwcode_bc_destroy(void *contents);
 static void win64_uwcode_bc_print(const void *contents, FILE *f,
                                   int indent_level);
 static void win64_uwcode_bc_finalize(yasm_bytecode *bc,
                                      yasm_bytecode *prev_bc);
 static int win64_uwcode_bc_calc_len
     (yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data);
 static int win64_uwcode_bc_expand(yasm_bytecode *bc, int span, long old_val,
                                   long new_val, /*@out@*/ long *neg_thres,
                                   /*@out@*/ long *pos_thres);
 static int win64_uwcode_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 win64_uwinfo_bc_callback = {
     win64_uwinfo_bc_destroy,
     win64_uwinfo_bc_print,
     win64_uwinfo_bc_finalize,
     NULL,
     win64_uwinfo_bc_calc_len,
@@ skipping 195 matching lines @@
                 N_("frame offset of %ld bytes, must be between 0 and 240"),
                 new_val);
             return -1;
         default:
             yasm_internal_error(N_("unrecognized span id"));
     }
     return 0;
 }
 
 static int
-win64_uwinfo_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+win64_uwinfo_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)
 {
     coff_unwind_info *info = (coff_unwind_info *)bc->contents;
     unsigned char *buf = *bufp;
     /*@only@*/ /*@null@*/ yasm_intnum *frameoff;
     long intv;
 
     /* Version and flags */
     if (info->ehandler)
         YASM_WRITE_8(buf, 1 | (UNW_FLAG_EHANDLER << 3));
     else
         YASM_WRITE_8(buf, 1);
 
     /* Size of prolog */
-    output_value(&info->prolog_size, buf, 1, (unsigned long)(buf-*bufp),
+    output_value(&info->prolog_size, buf, 1, (unsigned long)(buf-bufstart),
                  bc, 1, d);
     buf += 1;
 
     /* Count of codes */
-    output_value(&info->codes_count, buf, 1, (unsigned long)(buf-*bufp),
+    output_value(&info->codes_count, buf, 1, (unsigned long)(buf-bufstart),
                  bc, 1, d);
     buf += 1;
 
     /* Frame register and offset */
     frameoff = yasm_value_get_intnum(&info->frameoff, bc, 1);
     if (!frameoff) {
         yasm_error_set(YASM_ERROR_VALUE,
                        N_("frame offset expression too complex"));
         return 1;
     }
@@ skipping 138 matching lines @@
         code->opcode = UWOP_SAVE_NONVOL_FAR;
         bc->len += 2;
     } else if (code->opcode == UWOP_SAVE_XMM128 && span == 3) {
         code->opcode = UWOP_SAVE_XMM128_FAR;
         bc->len += 2;
     }
     return 0;
 }
 
 static int
-win64_uwcode_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+win64_uwcode_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)
 {
     coff_unwind_code *code = (coff_unwind_code *)bc->contents;
     unsigned char *buf = *bufp;
     yasm_value val;
     unsigned int size;
     int shift;
     long intv, low, high, mask;
     yasm_intnum *intn;
 
     /* Offset in prolog */
     yasm_value_initialize(&val,
         yasm_expr_create(YASM_EXPR_SUB, yasm_expr_sym(code->loc),
                          yasm_expr_sym(code->proc), bc->line),
         8);
-    output_value(&val, buf, 1, (unsigned long)(buf-*bufp), bc, 1, d);
+    output_value(&val, buf, 1, (unsigned long)(buf-bufstart), bc, 1, d);
     buf += 1;
     yasm_value_delete(&val);
 
     /* Offset value */
     switch (code->opcode) {
         case UWOP_PUSH_NONVOL:
         case UWOP_SET_FPREG:
         case UWOP_PUSH_MACHFRAME:
             /* just 1 node, no offset; write opcode and info and we're done */
             YASM_WRITE_8(buf, (code->info << 4) | (code->opcode & 0xF));
@@ skipping 59 matching lines @@
     if (size != 0) {
         yasm_intnum_get_sized(intn, buf, size, size*8, -shift, 0, 1);
         buf += size;
     }
 
     yasm_intnum_destroy(intn);
 
     *bufp = buf;
     return 0;
 }