Subversion Repositories openrisc

/* tc-i386.c -- Assemble Intel syntax code for ix86/x86-64

   Copyright 2009

   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   GAS is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with GAS; see the file COPYING.  If not, write to the Free

   Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA

   02110-1301, USA.  */

static struct

  {

    operatorT op_modifier;      /* Operand modifier.  */

    int is_mem;                 /* 1 if operand is memory reference.  */

    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

                                 * in brackets.  */

    i386_operand_type reloc_types;      /* Value obtained from lex_got().  */

    const reg_entry *base;      /* Base register (if any).  */

    const reg_entry *index;     /* Index register (if any).  */

    offsetT scale_factor;       /* Accumulated scale factor.  */

    symbolS *seg;

  }

intel_state;

/* offset X_add_symbol */

#define O_offset O_md32

/* offset X_add_symbol */

#define O_short O_md31

/* near ptr X_add_symbol */

#define O_near_ptr O_md30

/* far ptr X_add_symbol */

#define O_far_ptr O_md29

/* byte ptr X_add_symbol */

#define O_byte_ptr O_md28

/* word ptr X_add_symbol */

#define O_word_ptr O_md27

/* dword ptr X_add_symbol */

#define O_dword_ptr O_md26

/* qword ptr X_add_symbol */

#define O_qword_ptr O_md25

/* oword ptr X_add_symbol */

#define O_oword_ptr O_md24

/* fword ptr X_add_symbol */

#define O_fword_ptr O_md23

/* tbyte ptr X_add_symbol */

#define O_tbyte_ptr O_md22

/* xmmword ptr X_add_symbol */

#define O_xmmword_ptr O_md21

/* ymmword ptr X_add_symbol */

#define O_ymmword_ptr O_md20

static struct

  {

    const char *name;

    operatorT op;

    unsigned int operands;

  }

const i386_operators[] =

  {

    { "and", O_bit_and, 2 },

    { "eq", O_eq, 2 },

    { "ge", O_ge, 2 },

    { "gt", O_gt, 2 },

    { "le", O_le, 2 },

    { "lt", O_lt, 2 },

    { "mod", O_modulus, 2 },

    { "ne", O_ne, 2 },

    { "not", O_bit_not, 1 },

    { "offset", O_offset, 1 },

    { "or", O_bit_inclusive_or, 2 },

    { "shl", O_left_shift, 2 },

    { "short", O_short, 1 },

    { "shr", O_right_shift, 2 },

    { "xor", O_bit_exclusive_or, 2 },

    { NULL, O_illegal, 0 }

  };

static struct

  {

    const char *name;

    operatorT op;

    unsigned short sz[3];

  }

const i386_types[] =

  {

#define I386_TYPE(t, n) { #t, O_##t##_ptr, { n, n, n } }

    I386_TYPE(byte, 1),

    I386_TYPE(word, 2),

    I386_TYPE(dword, 4),

    I386_TYPE(fword, 6),

    I386_TYPE(qword, 8),

    I386_TYPE(tbyte, 10),

    I386_TYPE(oword, 16),

    I386_TYPE(xmmword, 16),

    I386_TYPE(ymmword, 32),

#undef I386_TYPE

    { "near", O_near_ptr, { 0xff04, 0xff02, 0xff08 } },

    { "far", O_far_ptr, { 0xff06, 0xff05, 0xff06 } },

    { NULL, O_illegal, { 0, 0, 0 } }

  };

operatorT i386_operator (const char *name, unsigned int operands, char *pc)

{

  unsigned int j;

  if (!intel_syntax)

    return O_absent;

  if (!name)

    {

      if (operands != 2)

        return O_illegal;

      switch (*input_line_pointer)

        {

        case ':':

          ++input_line_pointer;

          return O_full_ptr;

        case '[':

          ++input_line_pointer;

          return O_index;

        case '@':

          if (this_operand >= 0 && i.reloc[this_operand] == NO_RELOC)

            {

              int adjust = 0;

              char *gotfree_input_line = lex_got (&i.reloc[this_operand],

                                                  &adjust,

                                                  &intel_state.reloc_types);

              if (!gotfree_input_line)

                break;

              free (gotfree_input_line);

              *input_line_pointer++ = '+';

              memset (input_line_pointer, '0', adjust - 1);

              input_line_pointer[adjust - 1] = ' ';

              return O_add;

            }

          break;

        }

      return O_illegal;

    }

  for (j = 0; i386_operators[j].name; ++j)

    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].op;

      }

  for (j = 0; i386_types[j].name; ++j)

    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 ();

      if (strcasecmp (name, "ptr") == 0)

        {

          name[-1] = *pc;

          *pc = c;

          if (intel_syntax > 0 || operands != 1)

            return O_illegal;

          return i386_types[j].op;

        }

      *input_line_pointer = c;

      input_line_pointer = name - 1;

    }

  return O_absent;

}

static int i386_intel_parse_name (const char *name, expressionS *e)

{

  unsigned int i;

  for (i = 0; i386_types[i].name; ++i)

    if (strcasecmp(i386_types[i].name, name) == 0)

      {

        e->X_op = O_constant;

        e->X_add_number = i386_types[i].sz[flag_code];

        e->X_add_symbol = NULL;

        e->X_op_symbol = NULL;

        return 1;

      }

  return 0;

}

static INLINE int i386_intel_check (const reg_entry *reg,

                                    const reg_entry *base,

                                    const reg_entry *index)

{

  if ((this_operand >= 0 && reg != i.op[this_operand].regs)

      || base != intel_state.base || index != intel_state.index)

    {

      as_bad (_("invalid use of register"));

      return 0;

    }

  return 1;

}

static INLINE void i386_intel_fold (expressionS *e, symbolS *sym)

{

  if (S_GET_SEGMENT (sym) == absolute_section)

    {

      offsetT val = e->X_add_number;

      *e = *symbol_get_value_expression (sym);

      e->X_add_number += val;

    }

  else

    {

      e->X_add_symbol = sym;

      e->X_op_symbol = NULL;

      e->X_op = O_symbol;

    }

}

static int i386_intel_simplify (expressionS *);

static INLINE int i386_intel_simplify_symbol(symbolS *sym)

{

  int ret = i386_intel_simplify (symbol_get_value_expression (sym));

  if (ret == 2)

  {

    S_SET_SEGMENT(sym, absolute_section);

    ret = 1;

  }

  return ret;

}

static int i386_intel_simplify (expressionS *e)

{

  const reg_entry *reg = this_operand >= 0 ? i.op[this_operand].regs : NULL;

  const reg_entry *base = intel_state.base;

  const reg_entry *index = intel_state.index;

  int ret;

  if (!intel_syntax)

    return 1;

  switch (e->X_op)

    {

    case O_index:

      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;;

        }

      if (!intel_state.in_offset)

        ++intel_state.in_bracket;

      ret = i386_intel_simplify_symbol (e->X_op_symbol);

      if (!intel_state.in_offset)

        --intel_state.in_bracket;

      if (!ret)

        return 0;

      if (e->X_add_symbol)

        e->X_op = O_add;

      else

        i386_intel_fold (e, e->X_op_symbol);

      break;

    case O_offset:

      ++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))

        return 0;

      i386_intel_fold (e, e->X_add_symbol);

      return ret;

    case O_byte_ptr:

    case O_word_ptr:

    case O_dword_ptr:

    case O_fword_ptr:

    case O_qword_ptr:

    case O_tbyte_ptr:

    case O_oword_ptr:

    case O_xmmword_ptr:

    case O_ymmword_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)

        {

          as_bad (_("invalid use of register"));

          return 0;

        }

      if (!i386_intel_simplify_symbol (e->X_add_symbol))

        return 0;

      i386_intel_fold (e, e->X_add_symbol);

      break;

    case O_full_ptr:

      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))

        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)

            {

              as_bad (_("invalid use of pseudo-register"));

              return 0;

            }

          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;

    case O_multiply:

      if (this_operand >= 0 && intel_state.in_bracket)

        {

          expressionS *scale = NULL;

          if (intel_state.index)

            --scale;

          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)

            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)

            scale = symbol_get_value_expression (e->X_add_symbol);

          if (ret && scale && (scale + 1))

            {

              resolve_expression (scale);

              if (scale->X_op != O_constant

                  || intel_state.index->reg_type.bitfield.reg16)

                scale->X_add_number = 0;

              intel_state.scale_factor *= scale->X_add_number;

            }

          --intel_state.in_scale;

          if (!ret)

            return 0;

          if (!intel_state.in_scale)

            switch (intel_state.scale_factor)

              {

              case 1:

                i.log2_scale_factor = 0;

                break;

              case 2:

                i.log2_scale_factor = 1;

                break;

              case 4:

                i.log2_scale_factor = 2;

                break;

              case 8:

                i.log2_scale_factor = 3;

                break;

              default:

                /* esp is invalid as index */

                intel_state.index = i386_regtab + REGNAM_EAX + 4;

                break;

              }

          break;

        }

      /* FALLTHROUGH */

    default:

      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;

        }

      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))

        return 0;

      break;

    }

  if (this_operand >= 0 && e->X_op == O_symbol && !intel_state.in_offset)

    {

      segT seg = S_GET_SEGMENT (e->X_add_symbol);

      if (seg != absolute_section

          && seg != reg_section

          && seg != expr_section)

        intel_state.is_mem |= 2 - !intel_state.in_bracket;

    }

  return 1;

}

int i386_need_index_operator (void)

{

  return intel_syntax < 0;

}

static int

i386_intel_operand (char *operand_string, int got_a_float)

{

  char *saved_input_line_pointer, *buf;

  segT exp_seg;

  expressionS exp, *expP;

  char suffix = 0;

  int ret;

  /* Initialize state structure.  */

  intel_state.op_modifier = O_absent;

  intel_state.is_mem = 0;

  intel_state.base = NULL;

  intel_state.index = NULL;

  intel_state.seg = NULL;

  operand_type_set (&intel_state.reloc_types, ~0);

  gas_assert (!intel_state.in_offset);

  gas_assert (!intel_state.in_bracket);

  gas_assert (!intel_state.in_scale);

  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);

  ret = i386_intel_simplify (&exp);

  intel_syntax = 1;

  SKIP_WHITESPACE ();

  if (!is_end_of_line[(unsigned char) *input_line_pointer])

    {

      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"));

      ret = 0;

    }

  input_line_pointer = saved_input_line_pointer;

  free (buf);

  gas_assert (!intel_state.in_offset);

  gas_assert (!intel_state.in_bracket);

  gas_assert (!intel_state.in_scale);

  if (!ret)

    return 0;

  if (intel_state.op_modifier != O_absent

      && current_templates->start->base_opcode != 0x8d /* lea */)

    {

      i.types[this_operand].bitfield.unspecified = 0;

      switch (intel_state.op_modifier)

        {

        case O_byte_ptr:

          i.types[this_operand].bitfield.byte = 1;

          suffix = BYTE_MNEM_SUFFIX;

          break;

        case O_word_ptr:

          i.types[this_operand].bitfield.word = 1;

          if ((current_templates->start->name[0] == 'l'

               && current_templates->start->name[2] == 's'

               && current_templates->start->name[3] == 0)

              || current_templates->start->base_opcode == 0x62 /* bound */)

            suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */

          else if (got_a_float == 2)    /* "fi..." */

            suffix = SHORT_MNEM_SUFFIX;

          else

            suffix = WORD_MNEM_SUFFIX;

          break;

        case O_dword_ptr:

          i.types[this_operand].bitfield.dword = 1;

          if ((current_templates->start->name[0] == 'l'

               && current_templates->start->name[2] == 's'

               && current_templates->start->name[3] == 0)

              || current_templates->start->base_opcode == 0x62 /* bound */)

            suffix = WORD_MNEM_SUFFIX;

          else if (flag_code == CODE_16BIT

                   && (current_templates->start->opcode_modifier.jump

                       || current_templates->start->opcode_modifier.jumpdword))

            suffix = LONG_DOUBLE_MNEM_SUFFIX;

          else if (got_a_float == 1)    /* "f..." */

            suffix = SHORT_MNEM_SUFFIX;

          else

            suffix = LONG_MNEM_SUFFIX;

          break;

        case O_fword_ptr:

          i.types[this_operand].bitfield.fword = 1;

          if (current_templates->start->name[0] == 'l'

              && current_templates->start->name[2] == 's'

              && current_templates->start->name[3] == 0)

            suffix = LONG_MNEM_SUFFIX;

          else if (!got_a_float)

            {

              if (flag_code == CODE_16BIT)

                add_prefix (DATA_PREFIX_OPCODE);

              suffix = LONG_DOUBLE_MNEM_SUFFIX;

            }

          else

            suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */

          break;

        case O_qword_ptr:

          i.types[this_operand].bitfield.qword = 1;

          if (current_templates->start->base_opcode == 0x62 /* bound */

              || got_a_float == 1)      /* "f..." */

            suffix = LONG_MNEM_SUFFIX;

          else

            suffix = QWORD_MNEM_SUFFIX;

          break;

        case O_tbyte_ptr:

          i.types[this_operand].bitfield.tbyte = 1;

          if (got_a_float == 1)

            suffix = LONG_DOUBLE_MNEM_SUFFIX;

          else

            suffix = BYTE_MNEM_SUFFIX; /* so it will cause an error */

          break;

        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_far_ptr:

          suffix = LONG_DOUBLE_MNEM_SUFFIX;

          /* FALLTHROUGH */

        case O_near_ptr:

          if (!current_templates->start->opcode_modifier.jump

              && !current_templates->start->opcode_modifier.jumpdword)

            suffix = got_a_float /* so it will cause an error */

                     ? BYTE_MNEM_SUFFIX

                     : LONG_DOUBLE_MNEM_SUFFIX;

          break;

        default:

          BAD_CASE (intel_state.op_modifier);

          break;

        }

      if (!i.suffix)

        i.suffix = suffix;

      else if (i.suffix != suffix)

        {

          as_bad (_("conflicting operand size modifiers"));

          return 0;

        }

    }

  /* Operands for jump/call need special consideration.  */

  if (current_templates->start->opcode_modifier.jump

      || current_templates->start->opcode_modifier.jumpdword

      || current_templates->start->opcode_modifier.jumpintersegment)

    {

      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

        switch (intel_state.op_modifier)

          {

          case O_near_ptr:

            if (intel_state.seg)

              i.types[this_operand].bitfield.jumpabsolute = 1;

            else

              intel_state.is_mem = 1;

            break;

          case O_far_ptr:

          case O_absent:

            if (!intel_state.seg)

              {