Update Yasm to 1.2.0 (Yasm Part 1/3)

third_party/yasm/patched-yasm/modules/arch/x86/x86bc.c

 /*
  * x86 bytecode utility functions
  *
  *  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: x86bc.c 2279 2010-01-19 07:57:43Z peter $");
 
 #include <libyasm.h>
 
 #include "x86arch.h"
 
 
 /* Bytecode callback function prototypes */
 
 static void x86_bc_insn_destroy(void *contents);
 static void x86_bc_insn_print(const void *contents, FILE *f,
                               int indent_level);
 static int x86_bc_insn_calc_len(yasm_bytecode *bc,
                                 yasm_bc_add_span_func add_span,
                                 void *add_span_data);
 static int x86_bc_insn_expand(yasm_bytecode *bc, int span, long old_val,
                               long new_val, /*@out@*/ long *neg_thres,
                               /*@out@*/ long *pos_thres);
 static int x86_bc_insn_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 void x86_bc_jmp_destroy(void *contents);
 static void x86_bc_jmp_print(const void *contents, FILE *f, int indent_level);
 static int x86_bc_jmp_calc_len(yasm_bytecode *bc,
                                yasm_bc_add_span_func add_span,
                                void *add_span_data);
 static int x86_bc_jmp_expand(yasm_bytecode *bc, int span, long old_val,
                              long new_val, /*@out@*/ long *neg_thres,
                              /*@out@*/ long *pos_thres);
 static int x86_bc_jmp_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 void x86_bc_jmpfar_destroy(void *contents);
 static void x86_bc_jmpfar_print(const void *contents, FILE *f,
                                 int indent_level);
 static int x86_bc_jmpfar_calc_len(yasm_bytecode *bc,
                                   yasm_bc_add_span_func add_span,
                                   void *add_span_data);
 static int x86_bc_jmpfar_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 x86_bc_callback_insn = {
     x86_bc_insn_destroy,
     x86_bc_insn_print,
     yasm_bc_finalize_common,
     NULL,
@@ skipping 102 matching lines @@
 
     yasm_value_initialize(&x86_ea->ea.disp, NULL, 0);
     x86_ea->ea.need_nonzero_len = 0;
     x86_ea->ea.need_disp = 0;
     x86_ea->ea.nosplit = 0;
     x86_ea->ea.strong = 0;
     x86_ea->ea.segreg = 0;
     x86_ea->ea.pc_rel = 0;
     x86_ea->ea.not_pc_rel = 0;
     x86_ea->ea.data_len = 0;
+    x86_ea->vsib_mode = 0;
     x86_ea->modrm = 0;
     x86_ea->valid_modrm = 0;
     x86_ea->need_modrm = 0;
     x86_ea->sib = 0;
     x86_ea->valid_sib = 0;
     x86_ea->need_sib = 0;
 
     return x86_ea;
 }
 
@@ skipping 171 matching lines @@
 
 void
 yasm_x86__ea_print(const yasm_effaddr *ea, FILE *f, int indent_level)
 {
     const x86_effaddr *x86_ea = (const x86_effaddr *)ea;
     fprintf(f, "%*sDisp:\n", indent_level, "");
     yasm_value_print(&ea->disp, f, indent_level+1);
     fprintf(f, "%*sNoSplit=%u\n", indent_level, "", (unsigned int)ea->nosplit);
     fprintf(f, "%*sSegmentOv=%02x\n", indent_level, "",
             (unsigned int)x86_ea->ea.segreg);
+    fprintf(f, "%*sVSIBMode=%u\n", indent_level, "",
+            (unsigned int)x86_ea->vsib_mode);
     fprintf(f, "%*sModRM=%03o ValidRM=%u NeedRM=%u\n", indent_level, "",
             (unsigned int)x86_ea->modrm, (unsigned int)x86_ea->valid_modrm,
             (unsigned int)x86_ea->need_modrm);
     fprintf(f, "%*sSIB=%03o ValidSIB=%u NeedSIB=%u\n", indent_level, "",
             (unsigned int)x86_ea->sib, (unsigned int)x86_ea->valid_sib,
             (unsigned int)x86_ea->need_sib);
 }
 
 static void
 x86_common_print(const x86_common *common, FILE *f, int indent_level)
@@ skipping 400 matching lines @@
 
 static void
 x86_opcode_tobytes(const x86_opcode *opcode, unsigned char **bufp)
 {
     unsigned int i;
     for (i=0; i<opcode->len; i++)
         YASM_WRITE_8(*bufp, opcode->opcode[i]);
 }
 
 static int
-x86_bc_insn_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+x86_bc_insn_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)
 {
     x86_insn *insn = (x86_insn *)bc->contents;
     /*@null@*/ x86_effaddr *x86_ea = (x86_effaddr *)insn->x86_ea;
     yasm_value *imm = insn->imm;
-    unsigned char *bufp_orig = *bufp;
 
     /* Prefixes */
     x86_common_tobytes(&insn->common, bufp,
                        x86_ea ? (unsigned int)(x86_ea->ea.segreg>>8) : 0);
     if (insn->special_prefix != 0)
         YASM_WRITE_8(*bufp, insn->special_prefix);
     if (insn->special_prefix == 0xC4 || insn->special_prefix == 0x8F) {
         /* 3-byte VEX/XOP; merge in 1s complement of REX.R, REX.X, REX.B */
         insn->opcode.opcode[0] &= 0x1F;
         if (insn->rex != 0xff)
@@ skipping 46 matching lines @@
                 if (!x86_ea->ea.disp.abs)
                     x86_ea->ea.disp.abs =
                         yasm_expr_create_ident(yasm_expr_int(delta), bc->line);
                 else
                     x86_ea->ea.disp.abs =
                         yasm_expr_create(YASM_EXPR_ADD,
                                          yasm_expr_expr(x86_ea->ea.disp.abs),
                                          yasm_expr_int(delta), bc->line);
             }
             if (output_value(&x86_ea->ea.disp, *bufp, disp_len,
-                             (unsigned long)(*bufp-bufp_orig), bc, 1, d))
+                             (unsigned long)(*bufp-bufstart), bc, 1, d))
                 return 1;
             *bufp += disp_len;
         }
     }
 
     /* Immediate (if required) */
     if (imm) {
         unsigned int imm_len;
         if (insn->postop == X86_POSTOP_SIGNEXT_IMM8) {
             /* If we got here with this postop still set, we need to force
              * imm size to 8 here.
              */
             imm->size = 8;
             imm->sign = 1;
             imm_len = 1;
         } else
             imm_len = imm->size/8;
-        if (output_value(imm, *bufp, imm_len, (unsigned long)(*bufp-bufp_orig),
+        if (output_value(imm, *bufp, imm_len, (unsigned long)(*bufp-bufstart),
                          bc, 1, d))
             return 1;
         *bufp += imm_len;
     }
 
     return 0;
 }
 
 static int
-x86_bc_jmp_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+x86_bc_jmp_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)
 {
     x86_jmp *jmp = (x86_jmp *)bc->contents;
     unsigned char opersize;
     unsigned int i;
-    unsigned char *bufp_orig = *bufp;
     /*@only@*/ yasm_intnum *delta;
 
     /* Prefixes */
     x86_common_tobytes(&jmp->common, bufp, 0);
 
     /* As opersize may be 0, figure out its "real" value. */
     opersize = (jmp->common.opersize == 0) ?
         jmp->common.mode_bits : jmp->common.opersize;
 
     /* Check here again to see if forms are actually legal. */
@@ skipping 14 matching lines @@
                                                          bc->line);
             else
                 jmp->target.abs =
                     yasm_expr_create(YASM_EXPR_ADD,
                                      yasm_expr_expr(jmp->target.abs),
                                      yasm_expr_int(delta), bc->line);
 
             jmp->target.size = 8;
             jmp->target.sign = 1;
             if (output_value(&jmp->target, *bufp, 1,
-                             (unsigned long)(*bufp-bufp_orig), bc, 1, d))
+                             (unsigned long)(*bufp-bufstart), bc, 1, d))
                 return 1;
             *bufp += 1;
             break;
         case JMP_NEAR_FORCED:
         case JMP_NEAR:
             /* 2/4 byte relative displacement (depending on operand size) */
             if (jmp->nearop.len == 0) {
                 yasm_error_set(YASM_ERROR_TYPE,
                                N_("near jump does not exist"));
                 return 1;
@@ skipping 11 matching lines @@
                                                          bc->line);
             else
                 jmp->target.abs =
                     yasm_expr_create(YASM_EXPR_ADD,
                                      yasm_expr_expr(jmp->target.abs),
                                      yasm_expr_int(delta), bc->line);
 
             jmp->target.size = i*8;
             jmp->target.sign = 1;
             if (output_value(&jmp->target, *bufp, i,
-                             (unsigned long)(*bufp-bufp_orig), bc, 1, d))
+                             (unsigned long)(*bufp-bufstart), bc, 1, d))
                 return 1;
             *bufp += i;
             break;
         case JMP_NONE:
             yasm_internal_error(N_("jump op_sel cannot be JMP_NONE in tobytes"));
         default:
             yasm_internal_error(N_("unrecognized relative jump op_sel"));
     }
     return 0;
 }
 
 static int
-x86_bc_jmpfar_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d,
+x86_bc_jmpfar_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)
 {
     x86_jmpfar *jmpfar = (x86_jmpfar *)bc->contents;
     unsigned int i;
-    unsigned char *bufp_orig = *bufp;
     unsigned char opersize;
 
     x86_common_tobytes(&jmpfar->common, bufp, 0);
     x86_opcode_tobytes(&jmpfar->opcode, bufp);
 
     /* As opersize may be 0, figure out its "real" value. */
     opersize = (jmpfar->common.opersize == 0) ?
         jmpfar->common.mode_bits : jmpfar->common.opersize;
 
     /* Absolute displacement: segment and offset */
     i = (opersize == 16) ? 2 : 4;
     jmpfar->offset.size = i*8;
     if (output_value(&jmpfar->offset, *bufp, i,
-                     (unsigned long)(*bufp-bufp_orig), bc, 1, d))
+                     (unsigned long)(*bufp-bufstart), bc, 1, d))
         return 1;
     *bufp += i;
     jmpfar->segment.size = 16;
     if (output_value(&jmpfar->segment, *bufp, 2,
-                     (unsigned long)(*bufp-bufp_orig), bc, 1, d))
+                     (unsigned long)(*bufp-bufstart), bc, 1, d))
         return 1;
     *bufp += 2;
 
     return 0;
 }
 
 int
 yasm_x86__intnum_tobytes(yasm_arch *arch, const yasm_intnum *intn,
                          unsigned char *buf, size_t destsize, size_t valsize,
                          int shift, const yasm_bytecode *bc, int warn)
 {
     /* Write value out. */
     yasm_intnum_get_sized(intn, buf, destsize, valsize, shift, 0, warn);
     return 0;
 }