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

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 2130 2008-10-07 05:38:11Z peter $");
+/*@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,
@@ skipping 60 matching lines @@
     x86_bc_jmpfar_print,
     yasm_bc_finalize_common,
     NULL,
     x86_bc_jmpfar_calc_len,
     yasm_bc_expand_common,
     x86_bc_jmpfar_tobytes,
     0
 };
 
 int
-yasm_x86__set_rex_from_reg(unsigned char *rex, unsigned char *drex,
-                           unsigned char *low3, uintptr_t reg,
-                           unsigned int bits, x86_rex_bit_pos rexbit)
+yasm_x86__set_rex_from_reg(unsigned char *rex, unsigned char *low3,
+                           uintptr_t reg, unsigned int bits,
+                           x86_rex_bit_pos rexbit)
 {
     *low3 = (unsigned char)(reg&7);
 
     if (bits == 64) {
         x86_expritem_reg_size size = (x86_expritem_reg_size)(reg & ~0xFUL);
 
         if (size == X86_REG8X || (reg & 0xF) >= 8) {
-            if (drex) {
-                *drex |= ((reg & 8) >> 3) << rexbit;
-            } else {
-                /* Check to make sure we can set it */
-                if (*rex == 0xff) {
-                    yasm_error_set(YASM_ERROR_TYPE,
-                        N_("cannot use A/B/C/DH with instruction needing REX"));
-                    return 1;
-                }
-                *rex |= 0x40 | (((reg & 8) >> 3) << rexbit);
+            /* Check to make sure we can set it */
+            if (*rex == 0xff) {
+                yasm_error_set(YASM_ERROR_TYPE,
+                    N_("cannot use A/B/C/DH with instruction needing REX"));
+                return 1;
             }
+            *rex |= 0x40 | (((reg & 8) >> 3) << rexbit);
         } else if (size == X86_REG8 && (reg & 7) >= 4) {
             /* AH/BH/CH/DH, so no REX allowed */
             if (*rex != 0 && *rex != 0xff) {
                 yasm_error_set(YASM_ERROR_TYPE,
                     N_("cannot use A/B/C/DH with instruction needing REX"));
                 return 1;
             }
             *rex = 0xff;    /* Flag so we can NEVER set it (see above) */
         }
     }
@@ skipping 13 matching lines @@
     yasm_bc_transform(bc, &x86_bc_callback_jmp, jmp);
 }
 
 void
 yasm_x86__bc_transform_jmpfar(yasm_bytecode *bc, x86_jmpfar *jmpfar)
 {
     yasm_bc_transform(bc, &x86_bc_callback_jmpfar, jmpfar);
 }
 
 void
-yasm_x86__ea_init(x86_effaddr *x86_ea, unsigned int spare, unsigned int drex,
-                  unsigned int need_drex, yasm_bytecode *precbc)
+yasm_x86__ea_init(x86_effaddr *x86_ea, unsigned int spare,
+                  yasm_bytecode *precbc)
 {
     if (yasm_value_finalize(&x86_ea->ea.disp, precbc))
         yasm_error_set(YASM_ERROR_TOO_COMPLEX,
                        N_("effective address too complex"));
     x86_ea->modrm &= 0xC7;                  /* zero spare/reg bits */
     x86_ea->modrm |= (spare << 3) & 0x38;   /* plug in provided bits */
-    x86_ea->drex = (unsigned char)drex;
-    x86_ea->need_drex = (unsigned char)need_drex;
 }
 
 void
 yasm_x86__ea_set_disponly(x86_effaddr *x86_ea)
 {
     x86_ea->valid_modrm = 0;
     x86_ea->need_modrm = 0;
     x86_ea->valid_sib = 0;
     x86_ea->need_sib = 0;
-    x86_ea->need_drex = 0;
 }
 
 static x86_effaddr *
 ea_create(void)
 {
     x86_effaddr *x86_ea = yasm_xmalloc(sizeof(x86_effaddr));
 
     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->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;
-    x86_ea->drex = 0;
-    x86_ea->need_drex = 0;
 
     return x86_ea;
 }
 
 x86_effaddr *
 yasm_x86__ea_create_reg(x86_effaddr *x86_ea, unsigned long reg,
-                        unsigned char *rex, unsigned char *drex,
-                        unsigned int bits)
+                        unsigned char *rex, unsigned int bits)
 {
     unsigned char rm;
 
-    if (yasm_x86__set_rex_from_reg(rex, drex, &rm, reg, bits, X86_REX_B))
+    if (yasm_x86__set_rex_from_reg(rex, &rm, reg, bits, X86_REX_B))
         return NULL;
 
     if (!x86_ea)
         x86_ea = ea_create();
     x86_ea->modrm = 0xC0 | rm;  /* Mod=11, R/M=Reg, Reg=0 */
     x86_ea->valid_modrm = 1;
     x86_ea->need_modrm = 1;
 
     return x86_ea;
 }
 
 yasm_effaddr *
 yasm_x86__ea_create_expr(yasm_arch *arch, yasm_expr *e)
 {
     yasm_arch_x86 *arch_x86 = (yasm_arch_x86 *)arch;
     x86_effaddr *x86_ea;
 
     x86_ea = ea_create();
 
     if (arch_x86->parser == X86_PARSER_GAS) {
-        /* Need to change foo+rip into foo wrt rip.
+        /* Need to change foo+rip into foo wrt rip (even in .intel_syntax mode).
          * Note this assumes a particular ordering coming from the parser
          * to work (it's not very smart)!
          */
         if (e->op == YASM_EXPR_ADD && e->terms[0].type == YASM_EXPR_REG
             && e->terms[0].data.reg == X86_RIP) {
             /* replace register with 0 */
             e->terms[0].type = YASM_EXPR_INT;
             e->terms[0].data.intn = yasm_intnum_create_uint(0);
             /* build new wrt expression */
             e = yasm_expr_create(YASM_EXPR_WRT, yasm_expr_expr(e),
@@ skipping 303 matching lines @@
             add_span(add_span_data, bc, 1, &x86_ea->ea.disp, -128, 127);
         }
         bc->len += x86_ea->ea.disp.size/8;
 
         /* Handle address16 postop case */
         if (insn->postop == X86_POSTOP_ADDRESS16)
             insn->common.addrsize = 0;
 
         /* Compute length of ea and add to total */
         bc->len += x86_ea->need_modrm + (x86_ea->need_sib ? 1:0);
-        bc->len += x86_ea->need_drex ? 1:0;
         bc->len += (x86_ea->ea.segreg != 0) ? 1 : 0;
     }
 
     if (imm) {
         unsigned int immlen = imm->size;
 
         /* TODO: check imm->len vs. sized len from expr? */
 
         /* Handle signext_imm8 postop special-casing */
         if (insn->postop == X86_POSTOP_SIGNEXT_IMM8) {
@@ skipping 22 matching lines @@
                     insn->opcode.len = 1;
                 }
                 insn->postop = X86_POSTOP_NONE;
                 yasm_intnum_destroy(num);
             }
         }
 
         bc->len += immlen/8;
     }
 
-    /* VEX prefixes never have REX.  We can come into this function with the
-     * three byte form, so we need to see if we can optimize to the two byte
-     * form.  We can't do it earlier, as we don't know all of the REX byte
-     * until now.
+    /* VEX and XOP prefixes never have REX (it's embedded in the opcode).
+     * For VEX, we can come into this function with the three byte form,
+     * so we need to see if we can optimize to the two byte form.
+     * We can't do it earlier, as we don't know all of the REX byte until now.
      */
     if (insn->special_prefix == 0xC4) {
         /* See if we can shorten the VEX prefix to its two byte form.
          * In order to do this, REX.X, REX.B, and REX.W/VEX.W must all be 0,
          * and the VEX mmmmm field must be 1.
          */
         if ((insn->opcode.opcode[0] & 0x1F) == 1 &&
             (insn->opcode.opcode[1] & 0x80) == 0 &&
             (insn->rex == 0xff || (insn->rex & 0x0B) == 0)) {
             insn->opcode.opcode[0] = insn->opcode.opcode[1];
             insn->opcode.opcode[1] = insn->opcode.opcode[2];
             insn->opcode.opcode[2] = 0; /* sanity */
             insn->opcode.len = 2;
             insn->special_prefix = 0xC5;    /* mark as two-byte VEX */
         }
     } else if (insn->rex != 0xff && insn->rex != 0 &&
-               insn->special_prefix != 0xC5)
+               insn->special_prefix != 0xC5 && insn->special_prefix != 0x8F)
         bc->len++;
 
     bc->len += insn->opcode.len;
     bc->len += x86_common_calc_len(&insn->common);
     bc->len += (insn->special_prefix != 0) ? 1:0;
     return 0;
 }
 
 static int
 x86_bc_insn_expand(yasm_bytecode *bc, int span, long old_val, long new_val,
@@ skipping 181 matching lines @@
     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) {
-        /* 3-byte VEX; merge in 1s complement of REX.R, REX.X, REX.B */
+    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)
             insn->opcode.opcode[0] |= ((~insn->rex) & 0x07) << 5;
         /* merge REX.W via ORing; there should never be a case in which REX.W
          * is important when VEX.W is already set by the instruction.
          */
         if (insn->rex != 0xff && (insn->rex & 0x8) != 0)
             insn->opcode.opcode[1] |= 0x80;
     } else if (insn->special_prefix == 0xC5) {
         /* 2-byte VEX; merge in 1s complement of REX.R */
@@ skipping 21 matching lines @@
                 yasm_internal_error(N_("invalid Mod/RM in x86 tobytes_insn"));
             YASM_WRITE_8(*bufp, x86_ea->modrm);
         }
 
         if (x86_ea->need_sib) {
             if (!x86_ea->valid_sib)
                 yasm_internal_error(N_("invalid SIB in x86 tobytes_insn"));
             YASM_WRITE_8(*bufp, x86_ea->sib);
         }
 
-        if (x86_ea->need_drex)
-            YASM_WRITE_8(*bufp, x86_ea->drex);
-
         if (x86_ea->ea.need_disp) {
             unsigned int disp_len = x86_ea->ea.disp.size/8;
 
             if (x86_ea->ea.disp.ip_rel) {
                 /* Adjust relative displacement to end of bytecode */
                 /*@only@*/ yasm_intnum *delta;
                 delta = yasm_intnum_create_int(-(long)bc->len);
                 if (!x86_ea->ea.disp.abs)
                     x86_ea->ea.disp.abs =
                         yasm_expr_create_ident(yasm_expr_int(delta), bc->line);
@@ skipping 153 matching lines @@
 
 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;
 }