X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fconfig%2Ftc-i386-intel.c;h=a2cd286572d3fd7ab712fd3d49eba06755feb537;hb=4288405d5ec2c68c7e9d8d68a090c6c9ff3825d1;hp=c12569fcb5a3179c855f549a95304db1ebde27eb;hpb=9c2799c243988c1a6d3fe93c7c2c06599672068d;p=deliverable%2Fbinutils-gdb.git

diff --git a/gas/config/tc-i386-intel.c b/gas/config/tc-i386-intel.c
index c12569fcb5..a2cd286572 100644
--- a/gas/config/tc-i386-intel.c
+++ b/gas/config/tc-i386-intel.c
@@ -1,6 +1,5 @@
 /* tc-i386.c -- Assemble Intel syntax code for ix86/x86-64
-   Copyright 2009
-   Free Software Foundation, Inc.
+   Copyright (C) 2009-2019 Free Software Foundation, Inc.
 
    This file is part of GAS, the GNU Assembler.
 
@@ -23,9 +22,11 @@ static struct
   {
     operatorT op_modifier;	/* Operand modifier.  */
     int is_mem;			/* 1 if operand is memory reference.  */
+    int is_indirect;		/* 1 if operand is indirect reference.  */
+    int has_offset;		/* 1 if operand has offset.  */
     unsigned int in_offset;	/* >=1 if processing operand of offset.  */
     unsigned int in_bracket;	/* >=1 if processing operand in brackets.  */
-    unsigned int in_scale;	/* >=1 if processing multipication operand
+    unsigned int in_scale;	/* >=1 if processing multiplication operand
 				 * in brackets.  */
     i386_operand_type reloc_types;	/* Value obtained from lex_got().  */
     const reg_entry *base;	/* Base register (if any).  */
@@ -61,11 +62,13 @@ intel_state;
 #define O_xmmword_ptr O_md21
 /* ymmword ptr X_add_symbol */
 #define O_ymmword_ptr O_md20
+/* zmmword ptr X_add_symbol */
+#define O_zmmword_ptr O_md19
 
 static struct
   {
     const char *name;
-    operatorT operator;
+    operatorT op;
     unsigned int operands;
   }
 const i386_operators[] =
@@ -91,7 +94,7 @@ const i386_operators[] =
 static struct
   {
     const char *name;
-    operatorT operator;
+    operatorT op;
     unsigned short sz[3];
   }
 const i386_types[] =
@@ -106,6 +109,7 @@ const i386_types[] =
     I386_TYPE(oword, 16),
     I386_TYPE(xmmword, 16),
     I386_TYPE(ymmword, 32),
+    I386_TYPE(zmmword, 64),
 #undef I386_TYPE
     { "near", O_near_ptr, { 0xff04, 0xff02, 0xff08 } },
     { "far", O_far_ptr, { 0xff06, 0xff05, 0xff06 } },
@@ -153,33 +157,38 @@ operatorT i386_operator (const char *name, unsigned int operands, char *pc)
     }
 
   for (j = 0; i386_operators[j].name; ++j)
-    if (strcasecmp(i386_operators[j].name, name) == 0)
+    if (strcasecmp (i386_operators[j].name, name) == 0)
       {
 	if (i386_operators[j].operands
 	    && i386_operators[j].operands != operands)
 	  return O_illegal;
-	return i386_operators[j].operator;
+	return i386_operators[j].op;
       }
 
   for (j = 0; i386_types[j].name; ++j)
-    if (strcasecmp(i386_types[j].name, name) == 0)
+    if (strcasecmp (i386_types[j].name, name) == 0)
       break;
+
   if (i386_types[j].name && *pc == ' ')
     {
-      char *name = ++input_line_pointer;
-      char c = get_symbol_end ();
+      char *pname;
+      char c;
+
+      ++input_line_pointer;
+      c = get_symbol_name (&pname);
 
-      if (strcasecmp (name, "ptr") == 0)
+      if (strcasecmp (pname, "ptr") == 0)
 	{
-	  name[-1] = *pc;
+	  /* FIXME: What if c == '"' ?  */
+	  pname[-1] = *pc;
 	  *pc = c;
 	  if (intel_syntax > 0 || operands != 1)
 	    return O_illegal;
-	  return i386_types[j].operator;
+	  return i386_types[j].op;
 	}
 
-      *input_line_pointer = c;
-      input_line_pointer = name - 1;
+      (void) restore_line_pointer (c);
+      input_line_pointer = pname - 1;
     }
 
   return O_absent;
@@ -187,13 +196,19 @@ operatorT i386_operator (const char *name, unsigned int operands, char *pc)
 
 static int i386_intel_parse_name (const char *name, expressionS *e)
 {
-  unsigned int i;
+  unsigned int j;
 
-  for (i = 0; i386_types[i].name; ++i)
-    if (strcasecmp(i386_types[i].name, name) == 0)
+  if (! strcmp (name, "$"))
+    {
+      current_location (e);
+      return 1;
+    }
+
+  for (j = 0; i386_types[j].name; ++j)
+    if (strcasecmp(i386_types[j].name, name) == 0)
       {
 	e->X_op = O_constant;
-	e->X_add_number = i386_types[i].sz[flag_code];
+	e->X_add_number = i386_types[j].sz[flag_code];
 	e->X_add_symbol = NULL;
 	e->X_op_symbol = NULL;
 	return 1;
@@ -202,12 +217,14 @@ static int i386_intel_parse_name (const char *name, expressionS *e)
   return 0;
 }
 
-static INLINE int i386_intel_check (const reg_entry *reg,
+static INLINE int i386_intel_check (const reg_entry *rreg,
 				    const reg_entry *base,
-				    const reg_entry *index)
+				    const reg_entry *iindex)
 {
-  if ((this_operand >= 0 && reg != i.op[this_operand].regs)
-      || base != intel_state.base || index != intel_state.index)
+  if ((this_operand >= 0
+       && rreg != i.op[this_operand].regs)
+      || base != intel_state.base
+      || iindex != intel_state.index)
     {
       as_bad (_("invalid use of register"));
       return 0;
@@ -217,21 +234,93 @@ static INLINE int i386_intel_check (const reg_entry *reg,
 
 static INLINE void i386_intel_fold (expressionS *e, symbolS *sym)
 {
+  expressionS *exp = symbol_get_value_expression (sym);
   if (S_GET_SEGMENT (sym) == absolute_section)
     {
       offsetT val = e->X_add_number;
 
-      *e = *symbol_get_value_expression (sym);
+      *e = *exp;
       e->X_add_number += val;
     }
   else
     {
+      if (exp->X_op == O_symbol
+	  && strcmp (S_GET_NAME (exp->X_add_symbol),
+		     GLOBAL_OFFSET_TABLE_NAME) == 0)
+	sym = exp->X_add_symbol;
       e->X_add_symbol = sym;
       e->X_op_symbol = NULL;
       e->X_op = O_symbol;
     }
 }
 
+static int
+i386_intel_simplify_register (expressionS *e)
+{
+  int reg_num;
+
+  if (this_operand < 0 || intel_state.in_offset)
+    {
+      as_bad (_("invalid use of register"));
+      return 0;
+    }
+
+  if (e->X_op == O_register)
+    reg_num = e->X_add_number;
+  else
+    reg_num = e->X_md - 1;
+
+  if (reg_num < 0 || reg_num >= (int) i386_regtab_size)
+    {
+      as_bad (_("invalid register number"));
+      return 0;
+    }
+
+  if (!intel_state.in_bracket)
+    {
+      if (i.op[this_operand].regs)
+	{
+	  as_bad (_("invalid use of register"));
+	  return 0;
+	}
+      if (i386_regtab[reg_num].reg_type.bitfield.sreg3
+	  && i386_regtab[reg_num].reg_num == RegFlat)
+	{
+	  as_bad (_("invalid use of pseudo-register"));
+	  return 0;
+	}
+      i.op[this_operand].regs = i386_regtab + reg_num;
+    }
+  else if (!intel_state.index
+	   && (i386_regtab[reg_num].reg_type.bitfield.xmmword
+	       || i386_regtab[reg_num].reg_type.bitfield.ymmword
+	       || i386_regtab[reg_num].reg_type.bitfield.zmmword
+	       || i386_regtab[reg_num].reg_num == RegIZ))
+    intel_state.index = i386_regtab + reg_num;
+  else if (!intel_state.base && !intel_state.in_scale)
+    intel_state.base = i386_regtab + reg_num;
+  else if (!intel_state.index)
+    {
+      if (intel_state.in_scale
+	  || current_templates->start->base_opcode == 0xf30f1b /* bndmk */
+	  || (current_templates->start->base_opcode & ~1) == 0x0f1a /* bnd{ld,st}x */
+	  || i386_regtab[reg_num].reg_type.bitfield.baseindex)
+	intel_state.index = i386_regtab + reg_num;
+      else
+	{
+	  /* Convert base to index and make ESP/RSP the base.  */
+	  intel_state.index = intel_state.base;
+	  intel_state.base = i386_regtab + reg_num;
+	}
+    }
+  else
+    {
+      /* esp is invalid as index */
+      intel_state.index = i386_regtab + REGNAM_EAX + ESP_REG_NUM;
+    }
+  return 2;
+}
+
 static int i386_intel_simplify (expressionS *);
 
 static INLINE int i386_intel_simplify_symbol(symbolS *sym)
@@ -248,9 +337,10 @@ static INLINE int i386_intel_simplify_symbol(symbolS *sym)
 
 static int i386_intel_simplify (expressionS *e)
 {
-  const reg_entry *reg = this_operand >= 0 ? i.op[this_operand].regs : NULL;
+  const reg_entry *the_reg = (this_operand >= 0
+			      ? i.op[this_operand].regs : NULL);
   const reg_entry *base = intel_state.base;
-  const reg_entry *index = intel_state.index;
+  const reg_entry *state_index = intel_state.index;
   int ret;
 
   if (!intel_syntax)
@@ -262,8 +352,9 @@ static int i386_intel_simplify (expressionS *e)
       if (e->X_add_symbol)
 	{
 	  if (!i386_intel_simplify_symbol (e->X_add_symbol)
-	      || !i386_intel_check(reg, intel_state.base, intel_state.index))
-	    return 0;;
+	      || !i386_intel_check(the_reg, intel_state.base,
+				   intel_state.index))
+	    return 0;
 	}
       if (!intel_state.in_offset)
 	++intel_state.in_bracket;
@@ -279,10 +370,11 @@ static int i386_intel_simplify (expressionS *e)
       break;
 
     case O_offset:
+      intel_state.has_offset = 1;
       ++intel_state.in_offset;
       ret = i386_intel_simplify_symbol (e->X_add_symbol);
       --intel_state.in_offset;
-      if (!ret || !i386_intel_check(reg, base, index))
+      if (!ret || !i386_intel_check(the_reg, base, state_index))
 	return 0;
       i386_intel_fold (e, e->X_add_symbol);
       return ret;
@@ -296,13 +388,15 @@ static int i386_intel_simplify (expressionS *e)
     case O_oword_ptr:
     case O_xmmword_ptr:
     case O_ymmword_ptr:
+    case O_zmmword_ptr:
     case O_near_ptr:
     case O_far_ptr:
       if (intel_state.op_modifier == O_absent)
 	intel_state.op_modifier = e->X_op;
       /* FALLTHROUGH */
     case O_short:
-      if (symbol_get_value_expression (e->X_add_symbol)->X_op == O_register)
+      if (symbol_get_value_expression (e->X_add_symbol)->X_op
+	  == O_register)
 	{
 	  as_bad (_("invalid use of register"));
 	  return 0;
@@ -313,78 +407,56 @@ static int i386_intel_simplify (expressionS *e)
       break;
 
     case O_full_ptr:
-      if (symbol_get_value_expression (e->X_op_symbol)->X_op == O_register)
+      if (symbol_get_value_expression (e->X_op_symbol)->X_op
+	  == O_register)
 	{
 	  as_bad (_("invalid use of register"));
 	  return 0;
 	}
       if (!i386_intel_simplify_symbol (e->X_op_symbol)
-	  || !i386_intel_check(reg, intel_state.base, intel_state.index))
+	  || !i386_intel_check(the_reg, intel_state.base,
+			       intel_state.index))
 	return 0;
       if (!intel_state.in_offset)
-	intel_state.seg = e->X_add_symbol;
-      i386_intel_fold (e, e->X_op_symbol);
-      break;
-
-    case O_register:
-      if (this_operand < 0 || intel_state.in_offset)
-	{
-	  as_bad (_("invalid use of register"));
-	  return 0;
-	}
-      if (!intel_state.in_bracket)
 	{
-	  if (i.op[this_operand].regs)
-	    {
-	      as_bad (_("invalid use of register"));
-	      return 0;
-	    }
-	  if (i386_regtab[e->X_add_number].reg_type.bitfield.sreg3
-	      && i386_regtab[e->X_add_number].reg_num == RegFlat)
+	  if (!intel_state.seg)
+	    intel_state.seg = e->X_add_symbol;
+	  else
 	    {
-	      as_bad (_("invalid use of pseudo-register"));
-	      return 0;
+	      expressionS exp;
+
+	      exp.X_op = O_full_ptr;
+	      exp.X_add_symbol = e->X_add_symbol;
+	      exp.X_op_symbol = intel_state.seg;
+	      intel_state.seg = make_expr_symbol (&exp);
 	    }
-	  i.op[this_operand].regs = i386_regtab + e->X_add_number;
 	}
-      else if (!intel_state.base && !intel_state.in_scale)
-	intel_state.base = i386_regtab + e->X_add_number;
-      else if (!intel_state.index)
-	intel_state.index = i386_regtab + e->X_add_number;
-      else
-	{
-	  /* esp is invalid as index */
-	  intel_state.index = i386_regtab + REGNAM_EAX + 4;
-	}
-      e->X_op = O_constant;
-      e->X_add_number = 0;
-      return 2;
+      i386_intel_fold (e, e->X_op_symbol);
+      break;
 
     case O_multiply:
       if (this_operand >= 0 && intel_state.in_bracket)
 	{
 	  expressionS *scale = NULL;
-
-	  if (intel_state.index)
-	    --scale;
+	  int has_index = (intel_state.index != NULL);
 
 	  if (!intel_state.in_scale++)
 	    intel_state.scale_factor = 1;
 
 	  ret = i386_intel_simplify_symbol (e->X_add_symbol);
-	  if (ret && !scale && intel_state.index)
+	  if (ret && !has_index && intel_state.index)
 	    scale = symbol_get_value_expression (e->X_op_symbol);
 
 	  if (ret)
 	    ret = i386_intel_simplify_symbol (e->X_op_symbol);
-	  if (ret && !scale && intel_state.index)
+	  if (ret && !scale && !has_index && intel_state.index)
 	    scale = symbol_get_value_expression (e->X_add_symbol);
 
-	  if (ret && scale && (scale + 1))
+	  if (ret && scale)
 	    {
 	      resolve_expression (scale);
 	      if (scale->X_op != O_constant
-		  || intel_state.index->reg_type.bitfield.reg16)
+		  || intel_state.index->reg_type.bitfield.word)
 		scale->X_add_number = 0;
 	      intel_state.scale_factor *= scale->X_add_number;
 	    }
@@ -410,31 +482,55 @@ static int i386_intel_simplify (expressionS *e)
 		break;
 	      default:
 		/* esp is invalid as index */
-		intel_state.index = i386_regtab + REGNAM_EAX + 4;
+		intel_state.index = i386_regtab + REGNAM_EAX + ESP_REG_NUM;
 		break;
 	      }
 
 	  break;
 	}
+      goto fallthrough;
+
+    case O_register:
+      ret = i386_intel_simplify_register (e);
+      if (ret == 2)
+	{
+	  gas_assert (e->X_add_number < (unsigned short) -1);
+	  e->X_md = (unsigned short) e->X_add_number + 1;
+	  e->X_op = O_constant;
+	  e->X_add_number = 0;
+	}
+      return ret;
+
+    case O_constant:
+      if (e->X_md)
+	return i386_intel_simplify_register (e);
+
       /* FALLTHROUGH */
     default:
-      if (e->X_add_symbol && !i386_intel_simplify_symbol (e->X_add_symbol))
+fallthrough:
+      if (e->X_add_symbol
+	  && !i386_intel_simplify_symbol (e->X_add_symbol))
 	return 0;
       if (e->X_op == O_add || e->X_op == O_subtract)
 	{
 	  base = intel_state.base;
-	  index = intel_state.index;
+	  state_index = intel_state.index;
 	}
-      if (!i386_intel_check (reg, base, index)
-	  || (e->X_op_symbol && !i386_intel_simplify_symbol (e->X_op_symbol))
-	  || !i386_intel_check (reg,
-				e->X_op != O_add ? base : intel_state.base,
-				e->X_op != O_add ? index : intel_state.index))
+      if (!i386_intel_check (the_reg, base, state_index)
+	  || (e->X_op_symbol
+	      && !i386_intel_simplify_symbol (e->X_op_symbol))
+	  || !i386_intel_check (the_reg,
+				(e->X_op != O_add
+				 ? base : intel_state.base),
+				(e->X_op != O_add
+				 ? state_index : intel_state.index)))
 	return 0;
       break;
     }
 
-  if (this_operand >= 0 && e->X_op == O_symbol && !intel_state.in_offset)
+  if (this_operand >= 0
+      && e->X_op == O_symbol
+      && !intel_state.in_offset)
     {
       segT seg = S_GET_SEGMENT (e->X_add_symbol);
 
@@ -461,9 +557,15 @@ i386_intel_operand (char *operand_string, int got_a_float)
   char suffix = 0;
   int ret;
 
+  /* Handle vector immediates.  */
+  if (RC_SAE_immediate (operand_string))
+    return 1;
+
   /* Initialize state structure.  */
   intel_state.op_modifier = O_absent;
   intel_state.is_mem = 0;
+  intel_state.is_indirect = 0;
+  intel_state.has_offset = 0;
   intel_state.base = NULL;
   intel_state.index = NULL;
   intel_state.seg = NULL;
@@ -475,11 +577,6 @@ i386_intel_operand (char *operand_string, int got_a_float)
   saved_input_line_pointer = input_line_pointer;
   input_line_pointer = buf = xstrdup (operand_string);
 
-  /* A '$' followed by an identifier char is an identifier.  Otherwise,
-     it's operator '.' followed by an expression.  */
-  if (*buf == '$' && !is_identifier_char (buf[1]))
-    *buf = '.';
-
   intel_syntax = -1;
   memset (&exp, 0, sizeof(exp));
   exp_seg = expression (&exp);
@@ -487,16 +584,36 @@ i386_intel_operand (char *operand_string, int got_a_float)
   intel_syntax = 1;
 
   SKIP_WHITESPACE ();
+
+  /* Handle vector operations.  */
+  if (*input_line_pointer == '{')
+    {
+      char *end = check_VecOperations (input_line_pointer, NULL);
+      if (end)
+	input_line_pointer = end;
+      else
+	ret = 0;
+    }
+
   if (!is_end_of_line[(unsigned char) *input_line_pointer])
     {
-      as_bad (_("junk `%s' after expression"), input_line_pointer);
+      if (ret)
+	as_bad (_("junk `%s' after expression"), input_line_pointer);
       ret = 0;
     }
   else if (exp.X_op == O_illegal || exp.X_op == O_absent)
     {
-      as_bad (_("invalid expression"));
+      if (ret)
+	as_bad (_("invalid expression"));
       ret = 0;
     }
+  else if (!intel_state.has_offset
+	   && input_line_pointer > buf
+	   && *(input_line_pointer - 1) == ']')
+    {
+      intel_state.is_mem |= 1;
+      intel_state.is_indirect = 1;
+    }
 
   input_line_pointer = saved_input_line_pointer;
   free (buf);
@@ -586,12 +703,14 @@ i386_intel_operand (char *operand_string, int got_a_float)
 	case O_oword_ptr:
 	case O_xmmword_ptr:
 	  i.types[this_operand].bitfield.xmmword = 1;
-	  suffix = XMMWORD_MNEM_SUFFIX;
 	  break;
 
 	case O_ymmword_ptr:
 	  i.types[this_operand].bitfield.ymmword = 1;
-	  suffix = YMMWORD_MNEM_SUFFIX;
+	  break;
+
+	case O_zmmword_ptr:
+	  i.types[this_operand].bitfield.zmmword = 1;
 	  break;
 
 	case O_far_ptr:
@@ -624,7 +743,9 @@ i386_intel_operand (char *operand_string, int got_a_float)
       || current_templates->start->opcode_modifier.jumpdword
       || current_templates->start->opcode_modifier.jumpintersegment)
     {
-      if (i.op[this_operand].regs || intel_state.base || intel_state.index
+      if (i.op[this_operand].regs
+	  || intel_state.base
+	  || intel_state.index
 	  || intel_state.is_mem > 1)
 	i.types[this_operand].bitfield.jumpabsolute = 1;
       else
@@ -642,7 +763,11 @@ i386_intel_operand (char *operand_string, int got_a_float)
 	      {
 		intel_state.is_mem = 1;
 		if (intel_state.op_modifier == O_absent)
-		  break;
+		  {
+		    if (intel_state.is_indirect == 1)
+		      i.types[this_operand].bitfield.jumpabsolute = 1;
+		    break;
+		  }
 		as_bad (_("cannot infer the segment part of the operand"));
 		return 0;
 	      }
@@ -703,32 +828,107 @@ i386_intel_operand (char *operand_string, int got_a_float)
 
       temp = i.op[this_operand].regs->reg_type;
       temp.bitfield.baseindex = 0;
-      i.types[this_operand] = operand_type_or (i.types[this_operand], temp);
+      i.types[this_operand] = operand_type_or (i.types[this_operand],
+					       temp);
       i.types[this_operand].bitfield.unspecified = 0;
       ++i.reg_operands;
     }
-  else if (intel_state.base || intel_state.index || intel_state.seg
+  else if (intel_state.base
+	   || intel_state.index
+	   || intel_state.seg
 	   || intel_state.is_mem)
     {
       /* Memory operand.  */
-      if (i.mem_operands
+      if (i.mem_operands == 1 && !maybe_adjust_templates ())
+	return 0;
+      if ((int) i.mem_operands
 	  >= 2 - !current_templates->start->opcode_modifier.isstring)
 	{
+	  /* Handle
+
+	     call	0x9090,0x90909090
+	     lcall	0x9090,0x90909090
+	     jmp	0x9090,0x90909090
+	     ljmp	0x9090,0x90909090
+	   */
+
+	  if ((current_templates->start->opcode_modifier.jumpintersegment
+	       || current_templates->start->opcode_modifier.jumpdword
+	       || current_templates->start->opcode_modifier.jump)
+	      && this_operand == 1
+	      && intel_state.seg == NULL
+	      && i.mem_operands == 1
+	      && i.disp_operands == 1
+	      && intel_state.op_modifier == O_absent)
+	    {
+	      /* Try to process the first operand as immediate,  */
+	      this_operand = 0;
+	      if (i386_finalize_immediate (exp_seg, i.op[0].imms,
+					   intel_state.reloc_types,
+					   NULL))
+		{
+		  this_operand = 1;
+		  expP = &im_expressions[0];
+		  i.op[this_operand].imms = expP;
+		  *expP = exp;
+
+		  /* Try to process the second operand as immediate,  */
+		  if (i386_finalize_immediate (exp_seg, expP,
+					       intel_state.reloc_types,
+					       NULL))
+		    {
+		      i.mem_operands = 0;
+		      i.disp_operands = 0;
+		      i.imm_operands = 2;
+		      i.flags[0] &= ~Operand_Mem;
+		      i.types[0].bitfield.disp16 = 0;
+		      i.types[0].bitfield.disp32 = 0;
+		      i.types[0].bitfield.disp32s = 0;
+		      return 1;
+		    }
+		}
+	    }
+
 	  as_bad (_("too many memory references for `%s'"),
 		  current_templates->start->name);
 	  return 0;
 	}
 
+      /* Swap base and index in 16-bit memory operands like
+	 [si+bx]. Since i386_index_check is also used in AT&T
+	 mode we have to do this here.  */
+      if (intel_state.base
+	  && intel_state.index
+	  && intel_state.base->reg_type.bitfield.word
+	  && intel_state.index->reg_type.bitfield.word
+	  && intel_state.base->reg_num >= 6
+	  && intel_state.index->reg_num < 6)
+	{
+	  i.base_reg = intel_state.index;
+	  i.index_reg = intel_state.base;
+	}
+      else
+	{
+	  i.base_reg = intel_state.base;
+	  i.index_reg = intel_state.index;
+	}
+
+      if (i.base_reg || i.index_reg)
+	i.types[this_operand].bitfield.baseindex = 1;
+
       expP = &disp_expressions[i.disp_operands];
       memcpy (expP, &exp, sizeof(exp));
       resolve_expression (expP);
 
-      if (expP->X_op != O_constant || expP->X_add_number
-	  || (!intel_state.base && !intel_state.index))
+      if (expP->X_op != O_constant
+	  || expP->X_add_number
+	  || !i.types[this_operand].bitfield.baseindex)
 	{
 	  i.op[this_operand].disps = expP;
 	  i.disp_operands++;
 
+	  i386_addressing_mode ();
+
 	  if (flag_code == CODE_64BIT)
 	    {
 	      i.types[this_operand].bitfield.disp32 = 1;
@@ -768,15 +968,14 @@ i386_intel_operand (char *operand_string, int got_a_float)
 	    return 0;
 	}
 
-      if (intel_state.base || intel_state.index)
-	i.types[this_operand].bitfield.baseindex = 1;
-
       if (intel_state.seg)
 	{
-	  for (;;)
+	  for (ret = check_none; ; ret = operand_check)
 	    {
 	      expP = symbol_get_value_expression (intel_state.seg);
-	      if (expP->X_op != O_full_ptr)
+	      if (expP->X_op != O_full_ptr 
+		  || symbol_get_value_expression (expP->X_op_symbol)->X_op
+		     != O_register)
 		break;
 	      intel_state.seg = expP->X_add_symbol;
 	    }
@@ -791,6 +990,15 @@ i386_intel_operand (char *operand_string, int got_a_float)
 	      as_bad (_("invalid use of register"));
 	      return 0;
 	    }
+	  switch (ret)
+	    {
+	    case check_error:
+	      as_bad (_("redundant segment overrides"));
+	      return 0;
+	    case check_warning:
+	      as_warn (_("redundant segment overrides"));
+	      break;
+	    }
 	  switch (i386_regtab[expP->X_add_number].reg_num)
 	    {
 	    case 0: i.seg[i.mem_operands] = &es; break;
@@ -803,29 +1011,12 @@ i386_intel_operand (char *operand_string, int got_a_float)
 	    }
 	}
 
-      /* Swap base and index in 16-bit memory operands like
-	 [si+bx]. Since i386_index_check is also used in AT&T
-	 mode we have to do that here.  */
-      if (intel_state.base
-	  && intel_state.index
-	  && intel_state.base->reg_type.bitfield.reg16
-	  && intel_state.index->reg_type.bitfield.reg16
-	  && intel_state.base->reg_num >= 6
-	  && intel_state.index->reg_num < 6)
-	{
-	  i.base_reg = intel_state.index;
-	  i.index_reg = intel_state.base;
-	}
-      else
-	{
-	  i.base_reg = intel_state.base;
-	  i.index_reg = intel_state.index;
-	}
-
       if (!i386_index_check (operand_string))
 	return 0;
 
-      i.types[this_operand].bitfield.mem = 1;
+      i.flags[this_operand] |= Operand_Mem;
+      if (i.mem_operands == 0)
+	i.memop1_string = xstrdup (operand_string);
       ++i.mem_operands;
     }
   else