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

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

 /*
  * x86 expression handling
  *
  *  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: x86expr.c 2162 2008-12-21 10:57:36Z peter $");
+/*@unused@*/ RCSID("$Id: x86expr.c 2199 2009-05-10 05:24:46Z peter $");
 
 #include <libyasm.h>
 
 #include "x86arch.h"
 
 
 typedef struct x86_checkea_reg3264_data {
     int *regs;          /* total multiplier for each reg */
     unsigned char bits;
     unsigned char addrsize;
@@ skipping 526 matching lines @@
     } else
         return 0;
 }
 
 int
 yasm_x86__expr_checkea(x86_effaddr *x86_ea, unsigned char *addrsize,
                        unsigned int bits, int address16_op, unsigned char *rex,
                        yasm_bytecode *bc)
 {
     int retval;
-    unsigned char *drex = x86_ea->need_drex ? &x86_ea->drex : NULL;
 
     if (*addrsize == 0) {
         /* we need to figure out the address size from what we know about:
          * - the displacement length
          * - what registers are used in the expression
          * - the bits setting
          */
         switch (x86_ea->ea.disp.size) {
             case 16:
                 /* must be 16-bit */
@@ skipping 230 matching lines @@
             /* RIP always requires a 32-bit displacement */
             x86_ea->valid_modrm = 1;
             x86_ea->ea.disp.size = 32;
             return 0;
         } else if (indexreg == REG3264_NONE) {
             /* basereg only */
             /* Don't need to go to the full effort of determining what type
              * of register basereg is, as x86_set_rex_from_reg doesn't pay
              * much attention.
              */
-            if (yasm_x86__set_rex_from_reg(rex, drex, &low3,
+            if (yasm_x86__set_rex_from_reg(rex, &low3,
                                            (unsigned int)(X86_REG64 | basereg),
                                            bits, X86_REX_B))
                 return 1;
             x86_ea->modrm |= low3;
             /* we don't need an SIB *unless* basereg is ESP or R12 */
             if (basereg == REG3264_ESP || basereg == REG64_R12)
                 x86_ea->need_sib = 1;
             else {
                 x86_ea->sib = 0;
                 x86_ea->valid_sib = 0;
                 x86_ea->need_sib = 0;
             }
         } else {
             /* index or both base and index */
             x86_ea->modrm |= 4;
             x86_ea->need_sib = 1;
         }
 
         /* Determine SIB if needed */
         if (x86_ea->need_sib == 1) {
             x86_ea->sib = 0;    /* start with 0 */
 
             /* Special case: no basereg */
             if (basereg == REG3264_NONE)
                 x86_ea->sib |= 5;
             else {
-                if (yasm_x86__set_rex_from_reg(rex, drex, &low3, (unsigned int)
+                if (yasm_x86__set_rex_from_reg(rex, &low3, (unsigned int)
                                                (X86_REG64 | basereg), bits,
                                                X86_REX_B))
                     return 1;
                 x86_ea->sib |= low3;
             }
             
             /* Put in indexreg, checking for none case */
             if (indexreg == REG3264_NONE)
                 x86_ea->sib |= 040;
                 /* Any scale field is valid, just leave at 0. */
             else {
-                if (yasm_x86__set_rex_from_reg(rex, drex, &low3, (unsigned int)
+                if (yasm_x86__set_rex_from_reg(rex, &low3, (unsigned int)
                                                (X86_REG64 | indexreg), bits,
                                                X86_REX_X))
                     return 1;
                 x86_ea->sib |= low3 << 3;
                 /* Set scale field, 1 case -> 0, so don't bother. */
                 switch (reg3264mult[indexreg]) {
                     case 2:
                         x86_ea->sib |= 0100;
                         break;
                     case 4:
@@ skipping 128 matching lines @@
 {
     if (!yasm_floatnum_check_size(flt, valsize)) {
         yasm_error_set(YASM_ERROR_FLOATING_POINT,
                        N_("invalid floating point constant size"));
         return 1;
     }
 
     yasm_floatnum_get_sized(flt, buf, destsize, valsize, shift, 0, warn);
     return 0;
 }