Subversion Repositories Kolibri OS

   Free Software Foundation, Inc.

   Copyright 1994-2015 Free Software Foundation, Inc.

   Contributed by Doug Evans (dje@cygnus.com).

   Contributed by Claudiu Zissulescu (claziss@synopsys.com)

   These values are internal to opcodes/bfd/binutils/gas.  */

#define ARC_MACH_7 2

#ifndef OPCODE_ARC_H

extern struct arc_opcode *arc_ext_opcodes;

#define OPCODE_ARC_H

struct arc_operand_value {

#define ARC_OPVAL_MACH(bits) ((bits) & ARC_MACH_MASK)

  } flag_class_t;

};

  const char *name;

  /* An array of operand codes.  Each code is an index into the

  struct arc_ext_operand_value *next;

};

struct arc_operand

{

extern struct arc_ext_operand_value *arc_ext_operands;

  /* The number of bits in the operand.  */

  unsigned int bits;

/* One of the insn format chars.  */

  unsigned char fmt;

  /* How far the operand is left shifted in the instruction.  */

  unsigned int shift;

/* The number of bits in the operand (may be unused for a modifier).  */

  unsigned char bits;

  /* The default relocation type for this operand.  */

     If it is NULL, execute

/* How far the operand is left shifted in the instruction, or

     (i is the instruction which we are filling in, o is a pointer to

   the modifier's flag bit (may be unused for a modifier.  */

     complement arithmetic).

  unsigned char shift;

/* Various flag bits.  */

     If this field is not NULL, then simply call it with the

  int flags;

     instruction and the operand value.	 It will return the new value

     of the instruction.  If the ERRMSG argument is not NULL, then if

/* Values for `flags'.  */

     If it is NULL, compute

     (i is the instruction, o is a pointer to this structure, and op

/* This operand is a suffix to the opcode.  */

extern const struct arc_operand arc_operands[];

#define ARC_OPERAND_SUFFIX 1

extern const unsigned arc_num_operands;

extern const unsigned arc_Toperand;

   prints these symbolically if possible.  */

#define ARC_OPERAND_RELATIVE_BRANCH 2

/* Values defined for the flags field of a struct arc_operand.  */

   prints these symbolically if possible.  */

/* This operand does not actually exist in the assembler input.  This

#define ARC_OPERAND_ABSOLUTE_BRANCH 4

   is used to support extended mnemonics, for which two operands fields

   are identical.  The assembler should call the insert function with

/* This operand is a long immediate value.  */

   any op value.  The disassembler should call the extract function,

   ignore the return value, and check the value placed in the invalid

/* This operand takes signed values.  */

   argument.  */

#define ARC_OPERAND_SIGNED 0x20

#define ARC_OPERAND_FAKE	0x0001

/* This operand takes signed values, but also accepts a full positive

/* This operand names an integer register.  */

   range of values.  That is, if bits is 16, it takes any value from

#define ARC_OPERAND_IR		0x0002

   -0x8000 to 0xffff.  */

#define ARC_OPERAND_SIGNOPT 0x40

/* This operand takes signed values.  */

#define ARC_OPERAND_SIGNED	0x0004

/* This operand should be regarded as a negative number for the

   purposes of overflow checking (i.e., the normal most negative

/* This operand takes unsigned values.  This exists primarily so that

   number is disallowed and one more than the normal most positive

   a flags value of 0 can be treated as end-of-arguments.  */

   number is allowed).  This flag will only be set for a signed

#define ARC_OPERAND_UNSIGNED	0x0008

   operand.  */

#define ARC_OPERAND_NEGATIVE 0x80

/* This operand takes long immediate values.  */

#define ARC_OPERAND_LIMM	0x0010

/* This operand doesn't really exist.  The program uses these operands

   in special ways.  */

/* This operand is identical like the previous one.  */

#define ARC_OPERAND_FAKE 0x100

#define ARC_OPERAND_DUPLICATE   0x0020

/* separate flags operand for j and jl instructions  */

/* This operand is truncated.  The truncation is done accordingly to

#define ARC_OPERAND_JUMPFLAGS 0x200

/* This operand is 16bit aligned.  */

/* allow warnings and errors to be issued after call to insert_xxxxxx  */

#define ARC_OPERAND_ALIGNED16   0x0100

#define ARC_OPERAND_ERROR 0x800

/* This operand is 32bit aligned.  */

#define ARC_OPERAND_ALIGNED32   0x0200

#define ARC_OPERAND_STORE 0x10000

/* This operand can be ignored by matching process if it is not

/* A normal register is allowed (not used, but here for completeness).  */

   present.  */

#define ARC_MOD_REG 0x2000

/* Don't check the range when matching.	 */

  (ARC_OPERAND_IR |				\

/* An auxiliary register name is expected.  */

   ARC_OPERAND_LIMM | ARC_OPERAND_SIGNED | 	\

/* Sum of all ARC_MOD_XXX bits.  */

#define ARC_MOD_BITS 0x7000

/* The flags structure.  */

/* Non-zero if the operand type is really a modifier.  */

struct arc_flag_operand

#define ARC_MOD_P(X) ((X) & ARC_MOD_BITS)

  /* The flag name.  */

  const char *name;

#define ARC_REGISTER_WRITEONLY   0x02

  /* The flag code.  */

   If it is NULL, execute

   i |= (p & ((1 << o->bits) - 1)) << o->shift;

  /* The number of bits in the operand.  */

   (I is the instruction which we are filling in, O is a pointer to

   this structure, and OP is the opcode value; this assumes twos

extern const struct arc_flag_operand arc_flag_operands[];

   complement arithmetic).

  /* Flag class.  */

   If this field is not NULL, then simply call it with the

  /* List of valid flags (codes).  */

   of the instruction.  If the ERRMSG argument is not NULL, then if

  unsigned flags[32];

   the operand value is illegal, *ERRMSG will be set to a warning

/* Relocation equivalence structure.  */

   extract this operand type from an instruction, check this field.

{

  const char * name;	   /* String to lookup.  */

   non-zero if this operand type can not actually be extracted from

  const char * mnemonic;   /* Extra matching condition.  */

   this operand (i.e., the instruction does not match).  If the

  unsigned     flagcode;   /* Extra matching condition.  */

   operand is valid, *INVALID will not be changed.

  signed int   oldreloc;   /* Old relocation.  */

  signed int   newreloc;   /* New relocation.  */

   INSN is a pointer to an array of two `arc_insn's.  The first element is

extern const struct arc_reloc_equiv_tab arc_reloc_equiv[];

   the insn, the second is the limm if present.

extern const unsigned arc_num_equiv_tab;

/* Structure for operand operations for pseudo/alias instructions.  */

   Operands that have a printable form like registers and suffixes have

struct arc_operand_operation

  /* The index for operand from operand array.  */

  long (*extract)

  unsigned operand_idx;

    (arc_insn *insn, const struct arc_operand *operand, int mods,

     const struct arc_operand_value **opval, int *invalid);

  /* Defines if it needs the operand inserted by the assembler or

};

     whether this operand comes from the pseudo instruction's

     operands.  */

  unsigned char needs_insert;

#define ARC_HAVE_MACH(bits) ((bits) & ARC_MACH_MASK)

/* Special register values:  */

     the operand needs to be inserted (i.e. needs_insert == 1).  */

  int count;

#define ARC_REG_CONSTANT_P(REG) ((REG) >= 61)

  /* Index of the operand to swap with.  To be done AFTER applying