Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Enumerations | Functions
xtensa-isa.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  xtensa_isa_opaque
struct  xtensa_funcUnit_use_struct

Defines

#define XTENSA_ISA_VERSION   7000
#define uint32   unsigned int
#define XTENSA_UNDEFINED   -1

Typedefs

typedef struct xtensa_isa_opaquextensa_isa
typedef int xtensa_opcode
typedef int xtensa_format
typedef int xtensa_regfile
typedef int xtensa_state
typedef int xtensa_sysreg
typedef int xtensa_interface
typedef int xtensa_funcUnit
typedef enum xtensa_isa_status_enum xtensa_isa_status
typedef uint32 xtensa_insnbuf_word
typedef xtensa_insnbuf_wordxtensa_insnbuf
typedef struct
xtensa_funcUnit_use_struct 
xtensa_funcUnit_use

Enumerations

enum  xtensa_isa_status_enum {
  xtensa_isa_ok = 0, xtensa_isa_bad_format, xtensa_isa_bad_slot, xtensa_isa_bad_opcode,
  xtensa_isa_bad_operand, xtensa_isa_bad_field, xtensa_isa_bad_iclass, xtensa_isa_bad_regfile,
  xtensa_isa_bad_sysreg, xtensa_isa_bad_state, xtensa_isa_bad_interface, xtensa_isa_bad_funcUnit,
  xtensa_isa_wrong_slot, xtensa_isa_no_field, xtensa_isa_out_of_memory, xtensa_isa_buffer_overflow,
  xtensa_isa_internal_error, xtensa_isa_bad_value
}

Functions

xtensa_isa_status xtensa_isa_errno (xtensa_isa isa)
char * xtensa_isa_error_msg (xtensa_isa isa)
int xtensa_insnbuf_size (xtensa_isa isa)
xtensa_insnbuf xtensa_insnbuf_alloc (xtensa_isa isa)
void xtensa_insnbuf_free (xtensa_isa isa, xtensa_insnbuf buf)
int xtensa_insnbuf_to_chars (xtensa_isa isa, const xtensa_insnbuf insn, unsigned char *cp, int num_chars)
void xtensa_insnbuf_from_chars (xtensa_isa isa, xtensa_insnbuf insn, const unsigned char *cp, int num_chars)
xtensa_isa xtensa_isa_init (xtensa_isa_status *errno_p, char **error_msg_p)
void xtensa_isa_free (xtensa_isa isa)
int xtensa_isa_maxlength (xtensa_isa isa)
int xtensa_isa_length_from_chars (xtensa_isa isa, const unsigned char *cp)
int xtensa_isa_num_pipe_stages (xtensa_isa isa)
int xtensa_isa_num_formats (xtensa_isa isa)
int xtensa_isa_num_opcodes (xtensa_isa isa)
int xtensa_isa_num_regfiles (xtensa_isa isa)
int xtensa_isa_num_states (xtensa_isa isa)
int xtensa_isa_num_sysregs (xtensa_isa isa)
int xtensa_isa_num_interfaces (xtensa_isa isa)
int xtensa_isa_num_funcUnits (xtensa_isa isa)
const char * xtensa_format_name (xtensa_isa isa, xtensa_format fmt)
xtensa_format xtensa_format_lookup (xtensa_isa isa, const char *fmtname)
xtensa_format xtensa_format_decode (xtensa_isa isa, const xtensa_insnbuf insn)
int xtensa_format_encode (xtensa_isa isa, xtensa_format fmt, xtensa_insnbuf insn)
int xtensa_format_length (xtensa_isa isa, xtensa_format fmt)
int xtensa_format_num_slots (xtensa_isa isa, xtensa_format fmt)
xtensa_opcode xtensa_format_slot_nop_opcode (xtensa_isa isa, xtensa_format fmt, int slot)
int xtensa_format_get_slot (xtensa_isa isa, xtensa_format fmt, int slot, const xtensa_insnbuf insn, xtensa_insnbuf slotbuf)
int xtensa_format_set_slot (xtensa_isa isa, xtensa_format fmt, int slot, xtensa_insnbuf insn, const xtensa_insnbuf slotbuf)
xtensa_opcode xtensa_opcode_lookup (xtensa_isa isa, const char *opname)
xtensa_opcode xtensa_opcode_decode (xtensa_isa isa, xtensa_format fmt, int slot, const xtensa_insnbuf slotbuf)
int xtensa_opcode_encode (xtensa_isa isa, xtensa_format fmt, int slot, xtensa_insnbuf slotbuf, xtensa_opcode opc)
const char * xtensa_opcode_name (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_is_branch (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_is_jump (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_is_loop (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_is_call (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_num_operands (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_num_stateOperands (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_num_interfaceOperands (xtensa_isa isa, xtensa_opcode opc)
int xtensa_opcode_num_funcUnit_uses (xtensa_isa isa, xtensa_opcode opc)
xtensa_funcUnit_usextensa_opcode_funcUnit_use (xtensa_isa isa, xtensa_opcode opc, int u)
const char * xtensa_operand_name (xtensa_isa isa, xtensa_opcode opc, int opnd)
int xtensa_operand_is_visible (xtensa_isa isa, xtensa_opcode opc, int opnd)
char xtensa_operand_inout (xtensa_isa isa, xtensa_opcode opc, int opnd)
int xtensa_operand_get_field (xtensa_isa isa, xtensa_opcode opc, int opnd, xtensa_format fmt, int slot, const xtensa_insnbuf slotbuf, uint32 *valp)
int xtensa_operand_set_field (xtensa_isa isa, xtensa_opcode opc, int opnd, xtensa_format fmt, int slot, xtensa_insnbuf slotbuf, uint32 val)
int xtensa_operand_encode (xtensa_isa isa, xtensa_opcode opc, int opnd, uint32 *valp)
int xtensa_operand_decode (xtensa_isa isa, xtensa_opcode opc, int opnd, uint32 *valp)
int xtensa_operand_is_register (xtensa_isa isa, xtensa_opcode opc, int opnd)
xtensa_regfile xtensa_operand_regfile (xtensa_isa isa, xtensa_opcode opc, int opnd)
int xtensa_operand_num_regs (xtensa_isa isa, xtensa_opcode opc, int opnd)
int xtensa_operand_is_known_reg (xtensa_isa isa, xtensa_opcode opc, int opnd)
int xtensa_operand_is_PCrelative (xtensa_isa isa, xtensa_opcode opc, int opnd)
int xtensa_operand_do_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd, uint32 *valp, uint32 pc)
int xtensa_operand_undo_reloc (xtensa_isa isa, xtensa_opcode opc, int opnd, uint32 *valp, uint32 pc)
xtensa_state xtensa_stateOperand_state (xtensa_isa isa, xtensa_opcode opc, int stOp)
char xtensa_stateOperand_inout (xtensa_isa isa, xtensa_opcode opc, int stOp)
xtensa_interface xtensa_interfaceOperand_interface (xtensa_isa isa, xtensa_opcode opc, int ifOp)
xtensa_regfile xtensa_regfile_lookup (xtensa_isa isa, const char *name)
xtensa_regfile xtensa_regfile_lookup_shortname (xtensa_isa isa, const char *shortname)
const char * xtensa_regfile_name (xtensa_isa isa, xtensa_regfile rf)
const char * xtensa_regfile_shortname (xtensa_isa isa, xtensa_regfile rf)
xtensa_regfile xtensa_regfile_view_parent (xtensa_isa isa, xtensa_regfile rf)
int xtensa_regfile_num_bits (xtensa_isa isa, xtensa_regfile rf)
int xtensa_regfile_num_entries (xtensa_isa isa, xtensa_regfile rf)
xtensa_state xtensa_state_lookup (xtensa_isa isa, const char *name)
const char * xtensa_state_name (xtensa_isa isa, xtensa_state st)
int xtensa_state_num_bits (xtensa_isa isa, xtensa_state st)
int xtensa_state_is_exported (xtensa_isa isa, xtensa_state st)
xtensa_sysreg xtensa_sysreg_lookup (xtensa_isa isa, int num, int is_user)
xtensa_sysreg xtensa_sysreg_lookup_name (xtensa_isa isa, const char *name)
const char * xtensa_sysreg_name (xtensa_isa isa, xtensa_sysreg sysreg)
int xtensa_sysreg_number (xtensa_isa isa, xtensa_sysreg sysreg)
int xtensa_sysreg_is_user (xtensa_isa isa, xtensa_sysreg sysreg)
xtensa_interface xtensa_interface_lookup (xtensa_isa isa, const char *ifname)
const char * xtensa_interface_name (xtensa_isa isa, xtensa_interface intf)
int xtensa_interface_num_bits (xtensa_isa isa, xtensa_interface intf)
char xtensa_interface_inout (xtensa_isa isa, xtensa_interface intf)
int xtensa_interface_has_side_effect (xtensa_isa isa, xtensa_interface intf)
int xtensa_interface_class_id (xtensa_isa isa, xtensa_interface intf)
xtensa_funcUnit xtensa_funcUnit_lookup (xtensa_isa isa, const char *fname)
const char * xtensa_funcUnit_name (xtensa_isa isa, xtensa_funcUnit fun)
int xtensa_funcUnit_num_copies (xtensa_isa isa, xtensa_funcUnit fun)

Class Documentation

struct xtensa_isa_opaque

Definition at line 62 of file xtensa-isa.h.

Class Members
int unused
struct xtensa_funcUnit_use_struct

Definition at line 429 of file xtensa-isa.h.

Class Members
int stage
xtensa_funcUnit unit

Define Documentation

#define uint32   unsigned int

Definition at line 33 of file xtensa-isa.h.

#define XTENSA_ISA_VERSION   7000

Definition at line 30 of file xtensa-isa.h.

#define XTENSA_UNDEFINED   -1

Definition at line 82 of file xtensa-isa.h.


Typedef Documentation

typedef int xtensa_format

Definition at line 72 of file xtensa-isa.h.

Definition at line 77 of file xtensa-isa.h.

Definition at line 173 of file xtensa-isa.h.

Definition at line 172 of file xtensa-isa.h.

Definition at line 76 of file xtensa-isa.h.

typedef int xtensa_opcode

Definition at line 71 of file xtensa-isa.h.

Definition at line 73 of file xtensa-isa.h.

typedef int xtensa_state

Definition at line 74 of file xtensa-isa.h.

typedef int xtensa_sysreg

Definition at line 75 of file xtensa-isa.h.


Enumeration Type Documentation

Enumerator:
xtensa_isa_ok 
xtensa_isa_bad_format 
xtensa_isa_bad_slot 
xtensa_isa_bad_opcode 
xtensa_isa_bad_operand 
xtensa_isa_bad_field 
xtensa_isa_bad_iclass 
xtensa_isa_bad_regfile 
xtensa_isa_bad_sysreg 
xtensa_isa_bad_state 
xtensa_isa_bad_interface 
xtensa_isa_bad_funcUnit 
xtensa_isa_wrong_slot 
xtensa_isa_no_field 
xtensa_isa_out_of_memory 
xtensa_isa_buffer_overflow 
xtensa_isa_internal_error 
xtensa_isa_bad_value 

Definition at line 140 of file xtensa-isa.h.


Function Documentation

Definition at line 549 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_format fmt;

  fmt = (intisa->format_decode_fn) (insn);
  if (fmt != XTENSA_UNDEFINED)
    return fmt;

  xtisa_errno = xtensa_isa_bad_format;
  strcpy (xtisa_error_msg, "cannot decode instruction format");
  return XTENSA_UNDEFINED;
}

Here is the caller graph for this function:

Definition at line 565 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_FORMAT (intisa, fmt, -1);
  (*intisa->formats[fmt].encode_fn) (insn);
  return 0;
}

Here is the caller graph for this function:

Definition at line 607 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int slot_id;

  CHECK_FORMAT (intisa, fmt, -1);
  CHECK_SLOT (intisa, fmt, slot, -1);

  slot_id = intisa->formats[fmt].slot_id[slot];
  (*intisa->slots[slot_id].get_fn) (insn, slotbuf);
  return 0;
}

Here is the caller graph for this function:

Definition at line 575 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
  return intisa->formats[fmt].length;
}

Here is the caller graph for this function:

xtensa_format xtensa_format_lookup ( xtensa_isa  isa,
const char *  fmtname 
)

Definition at line 524 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int fmt;

  if (!fmtname || !*fmtname)
    {
      xtisa_errno = xtensa_isa_bad_format;
      strcpy (xtisa_error_msg, "invalid format name");
      return XTENSA_UNDEFINED;
    }

  for (fmt = 0; fmt < intisa->num_formats; fmt++)
    {
      if (strcasecmp (fmtname, intisa->formats[fmt].name) == 0)
       return fmt;
    }
  
  xtisa_errno = xtensa_isa_bad_format;
  sprintf (xtisa_error_msg, "format \"%s\" not recognized", fmtname);
  return XTENSA_UNDEFINED;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 515 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_FORMAT (intisa, fmt, NULL);
  return intisa->formats[fmt].name;
}

Here is the caller graph for this function:

Definition at line 584 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
  return intisa->formats[fmt].num_slots;
}

Here is the caller graph for this function:

Definition at line 623 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int slot_id;

  CHECK_FORMAT (intisa, fmt, -1);
  CHECK_SLOT (intisa, fmt, slot, -1);

  slot_id = intisa->formats[fmt].slot_id[slot];
  (*intisa->slots[slot_id].set_fn) (insn, slotbuf);
  return 0;
}

Here is the caller graph for this function:

Definition at line 593 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int slot_id;

  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
  CHECK_SLOT (intisa, fmt, slot, XTENSA_UNDEFINED);

  slot_id = intisa->formats[fmt].slot_id[slot];
  return xtensa_opcode_lookup (isa, intisa->slots[slot_id].nop_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1729 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_lookup_entry entry, *result = 0;

  if (!fname || !*fname)
    {
      xtisa_errno = xtensa_isa_bad_funcUnit;
      strcpy (xtisa_error_msg, "invalid functional unit name");
      return XTENSA_UNDEFINED;
    }

  if (intisa->num_funcUnits != 0)
    {
      entry.key = fname;
      result = bsearch (&entry, intisa->funcUnit_lookup_table,
                     intisa->num_funcUnits, sizeof (xtensa_lookup_entry),
                     xtensa_isa_name_compare);
    }

  if (!result)
    {
      xtisa_errno = xtensa_isa_bad_funcUnit;
      sprintf (xtisa_error_msg,
              "functional unit \"%s\" not recognized", fname);
      return XTENSA_UNDEFINED;
    }

  return result->u.fun;
}

Here is the call graph for this function:

Definition at line 1762 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_FUNCUNIT (intisa, fun, NULL);
  return intisa->funcUnits[fun].name;
}

Definition at line 1771 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_FUNCUNIT (intisa, fun, XTENSA_UNDEFINED);
  return intisa->funcUnits[fun].num_copies;
}

Here is the caller graph for this function:

Definition at line 79 of file xtensa-isa.c.

{
  xtensa_insnbuf result = (xtensa_insnbuf)
    malloc (xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));
  CHECK_ALLOC (result, 0);
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void xtensa_insnbuf_from_chars ( xtensa_isa  isa,
xtensa_insnbuf  insn,
const unsigned char *  cp,
int  num_chars 
)

Definition at line 184 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int max_size, insn_size, fence_post, start, increment, i;

  max_size = xtensa_isa_maxlength (isa);

  /* Decode the instruction length so we know how many bytes to read.  */
  insn_size = (intisa->length_decode_fn) (cp);
  if (insn_size == XTENSA_UNDEFINED)
    {
      /* This should never happen when the byte stream contains a
        valid instruction.  Just read the maximum number of bytes....  */
      insn_size = max_size;
    }

  if (num_chars == 0 || num_chars > insn_size)
    num_chars = insn_size;

  if (intisa->is_big_endian)
    {
      start = max_size - 1;
      increment = -1;
    }
  else
    {
      start = 0;
      increment = 1;
    }

  fence_post = start + (num_chars * increment);
  memset (insn, 0, xtensa_insnbuf_size (isa) * sizeof (xtensa_insnbuf_word));

  for (i = start; i != fence_post; i += increment, ++cp)
    {
      int word_inx = byte_to_word_index (i);
      int bit_inx = byte_to_bit_index (i);

      insn[word_inx] |= (*cp & 0xff) << bit_inx;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 71 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->insnbuf_size;
}

Here is the caller graph for this function:

int xtensa_insnbuf_to_chars ( xtensa_isa  isa,
const xtensa_insnbuf  insn,
unsigned char *  cp,
int  num_chars 
)

Definition at line 124 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int insn_size = xtensa_isa_maxlength (isa);
  int fence_post, start, increment, i, byte_count;
  xtensa_format fmt;

  if (num_chars == 0)
    num_chars = insn_size;

  if (intisa->is_big_endian)
    {
      start = insn_size - 1;
      increment = -1;
    }
  else
    {
      start = 0;
      increment = 1;
    }

  /* Find the instruction format.  Do nothing if the buffer does not contain
     a valid instruction since we need to know how many bytes to copy.  */
  fmt = xtensa_format_decode (isa, insn);
  if (fmt == XTENSA_UNDEFINED)
    return XTENSA_UNDEFINED;

  byte_count = xtensa_format_length (isa, fmt);
  if (byte_count == XTENSA_UNDEFINED)
    return XTENSA_UNDEFINED;

  if (byte_count > num_chars)
    {
      xtisa_errno = xtensa_isa_buffer_overflow;
      strcpy (xtisa_error_msg, "output buffer too small for instruction");
      return XTENSA_UNDEFINED;
    }

  fence_post = start + (byte_count * increment);

  for (i = start; i != fence_post; i += increment, ++cp)
    {
      int word_inx = byte_to_word_index (i);
      int bit_inx = byte_to_bit_index (i);

      *cp = (insn[word_inx] >> bit_inx) & 0xff;
    }

  return byte_count;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1705 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
  return intisa->interfaces[intf].class_id;
}

Here is the caller graph for this function:

Definition at line 1694 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
  if ((intisa->interfaces[intf].flags & XTENSA_INTERFACE_HAS_SIDE_EFFECT) != 0)
    return 1;
  return 0;
}

Here is the caller graph for this function:

Definition at line 1685 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_INTERFACE (intisa, intf, 0);
  return intisa->interfaces[intf].inout;
}

Here is the caller graph for this function:

Definition at line 1635 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_lookup_entry entry, *result = 0;

  if (!ifname || !*ifname)
    {
      xtisa_errno = xtensa_isa_bad_interface;
      strcpy (xtisa_error_msg, "invalid interface name");
      return XTENSA_UNDEFINED;
    }

  if (intisa->num_interfaces != 0)
    {
      entry.key = ifname;
      result = bsearch (&entry, intisa->interface_lookup_table,
                     intisa->num_interfaces, sizeof (xtensa_lookup_entry),
                     xtensa_isa_name_compare);
    }

  if (!result)
    {
      xtisa_errno = xtensa_isa_bad_interface;
      sprintf (xtisa_error_msg, "interface \"%s\" not recognized", ifname);
      return XTENSA_UNDEFINED;
    }

  return result->u.intf;
}

Here is the call graph for this function:

Definition at line 1667 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_INTERFACE (intisa, intf, NULL);
  return intisa->interfaces[intf].name;
}

Definition at line 1676 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_INTERFACE (intisa, intf, XTENSA_UNDEFINED);
  return intisa->interfaces[intf].num_bits;
}

Definition at line 1316 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_iclass_internal *iclass;
  int iclass_id;

  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  iclass_id = intisa->opcodes[opc].iclass_id;
  iclass = &intisa->iclasses[iclass_id];
  CHECK_INTERFACE_OPERAND (intisa, opc, iclass, ifOp, XTENSA_UNDEFINED);
  return iclass->interfaceOperands[ifOp];
}

Here is the caller graph for this function:

void xtensa_isa_free ( xtensa_isa  isa)

Definition at line 331 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int n;

  /* With this version of the code, the xtensa_isa structure is not
     dynamically allocated, so this function is not essential.  Free
     the memory allocated by xtensa_isa_init and restore the xtensa_isa
     structure to its initial state.  */

  if (intisa->opname_lookup_table)
    {
      free (intisa->opname_lookup_table);
      intisa->opname_lookup_table = 0;
    }

  if (intisa->state_lookup_table)
    {
      free (intisa->state_lookup_table);
      intisa->state_lookup_table = 0;
    }

  if (intisa->sysreg_lookup_table)
    {
      free (intisa->sysreg_lookup_table);
      intisa->sysreg_lookup_table = 0;
    }
  for (n = 0; n < 2; n++)
    {
      if (intisa->sysreg_table[n])
       {
         free (intisa->sysreg_table[n]);
         intisa->sysreg_table[n] = 0;
       }
    }

  if (intisa->interface_lookup_table)
    {
      free (intisa->interface_lookup_table);
      intisa->interface_lookup_table = 0;
    }

  if (intisa->funcUnit_lookup_table)
    {
      free (intisa->funcUnit_lookup_table);
      intisa->funcUnit_lookup_table = 0;
    }
}

Here is the call graph for this function:

xtensa_isa xtensa_isa_init ( xtensa_isa_status errno_p,
char **  error_msg_p 
)

Definition at line 236 of file xtensa-isa.c.

{
  xtensa_isa_internal *isa = &xtensa_modules;
  int n, is_user;

  /* Set up the opcode name lookup table.  */
  isa->opname_lookup_table =
    bfd_malloc (isa->num_opcodes * sizeof (xtensa_lookup_entry));
  CHECK_ALLOC_FOR_INIT (isa->opname_lookup_table, NULL, errno_p, error_msg_p);
  for (n = 0; n < isa->num_opcodes; n++)
    {
      isa->opname_lookup_table[n].key = isa->opcodes[n].name;
      isa->opname_lookup_table[n].u.opcode = n;
    }
  qsort (isa->opname_lookup_table, isa->num_opcodes,
        sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);

  /* Set up the state name lookup table.  */
  isa->state_lookup_table =
    bfd_malloc (isa->num_states * sizeof (xtensa_lookup_entry));
  CHECK_ALLOC_FOR_INIT (isa->state_lookup_table, NULL, errno_p, error_msg_p);
  for (n = 0; n < isa->num_states; n++)
    {
      isa->state_lookup_table[n].key = isa->states[n].name;
      isa->state_lookup_table[n].u.state = n;
    }
  qsort (isa->state_lookup_table, isa->num_states,
        sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);

  /* Set up the sysreg name lookup table.  */
  isa->sysreg_lookup_table =
    bfd_malloc (isa->num_sysregs * sizeof (xtensa_lookup_entry));
  CHECK_ALLOC_FOR_INIT (isa->sysreg_lookup_table, NULL, errno_p, error_msg_p);
  for (n = 0; n < isa->num_sysregs; n++)
    {
      isa->sysreg_lookup_table[n].key = isa->sysregs[n].name;
      isa->sysreg_lookup_table[n].u.sysreg = n;
    }
  qsort (isa->sysreg_lookup_table, isa->num_sysregs,
        sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);

  /* Set up the user & system sysreg number tables.  */
  for (is_user = 0; is_user < 2; is_user++)
    {
      isa->sysreg_table[is_user] =
       bfd_malloc ((isa->max_sysreg_num[is_user] + 1)
                  * sizeof (xtensa_sysreg));
      CHECK_ALLOC_FOR_INIT (isa->sysreg_table[is_user], NULL,
                         errno_p, error_msg_p);

      for (n = 0; n <= isa->max_sysreg_num[is_user]; n++)
       isa->sysreg_table[is_user][n] = XTENSA_UNDEFINED;
    }
  for (n = 0; n < isa->num_sysregs; n++)
    {
      xtensa_sysreg_internal *sreg = &isa->sysregs[n];
      is_user = sreg->is_user;

      isa->sysreg_table[is_user][sreg->number] = n;
    }

  /* Set up the interface lookup table.  */
  isa->interface_lookup_table = 
    bfd_malloc (isa->num_interfaces * sizeof (xtensa_lookup_entry));
  CHECK_ALLOC_FOR_INIT (isa->interface_lookup_table, NULL, errno_p,
                     error_msg_p);
  for (n = 0; n < isa->num_interfaces; n++)
    {
      isa->interface_lookup_table[n].key = isa->interfaces[n].name;
      isa->interface_lookup_table[n].u.intf = n;
    }
  qsort (isa->interface_lookup_table, isa->num_interfaces,
        sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);

  /* Set up the funcUnit lookup table.  */
  isa->funcUnit_lookup_table = 
    bfd_malloc (isa->num_funcUnits * sizeof (xtensa_lookup_entry));
  CHECK_ALLOC_FOR_INIT (isa->funcUnit_lookup_table, NULL, errno_p,
                     error_msg_p);
  for (n = 0; n < isa->num_funcUnits; n++)
    {
      isa->funcUnit_lookup_table[n].key = isa->funcUnits[n].name;
      isa->funcUnit_lookup_table[n].u.fun = n;
    }
  qsort (isa->funcUnit_lookup_table, isa->num_funcUnits,
        sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);

  isa->insnbuf_size = ((isa->insn_size + sizeof (xtensa_insnbuf_word) - 1) /
                     sizeof (xtensa_insnbuf_word));

  return (xtensa_isa) isa;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 400 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return (intisa->length_decode_fn) (cp);
}

Definition at line 392 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->insn_size;
}

Here is the caller graph for this function:

Definition at line 433 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_formats;
}

Here is the caller graph for this function:

Definition at line 481 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_funcUnits;
}

Here is the caller graph for this function:

Definition at line 473 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_interfaces;
}

Definition at line 441 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_opcodes;
}

Here is the caller graph for this function:

Definition at line 408 of file xtensa-isa.c.

{
  xtensa_opcode opcode;
  xtensa_funcUnit_use *use;
  int num_opcodes, num_uses;
  int i, stage, max_stage = XTENSA_UNDEFINED;

  num_opcodes = xtensa_isa_num_opcodes (isa);
  for (opcode = 0; opcode < num_opcodes; opcode++)
    {
      num_uses = xtensa_opcode_num_funcUnit_uses (isa, opcode);
      for (i = 0; i < num_uses; i++)
       {
         use = xtensa_opcode_funcUnit_use (isa, opcode, i);
         stage = use->stage;
         if (stage > max_stage)
           max_stage = stage;
       }
    }

  return max_stage + 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 449 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_regfiles;
}

Definition at line 457 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_states;
}

Definition at line 465 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  return intisa->num_sysregs;
}

Definition at line 686 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int slot_id;
  xtensa_opcode opc;

  CHECK_FORMAT (intisa, fmt, XTENSA_UNDEFINED);
  CHECK_SLOT (intisa, fmt, slot, XTENSA_UNDEFINED);

  slot_id = intisa->formats[fmt].slot_id[slot];

  opc = (intisa->slots[slot_id].opcode_decode_fn) (slotbuf);
  if (opc != XTENSA_UNDEFINED)
    return opc;

  xtisa_errno = xtensa_isa_bad_opcode;
  strcpy (xtisa_error_msg, "cannot decode opcode");
  return XTENSA_UNDEFINED;
}

Here is the caller graph for this function:

int xtensa_opcode_encode ( xtensa_isa  isa,
xtensa_format  fmt,
int  slot,
xtensa_insnbuf  slotbuf,
xtensa_opcode  opc 
)

Definition at line 709 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int slot_id;
  xtensa_opcode_encode_fn encode_fn;

  CHECK_FORMAT (intisa, fmt, -1);
  CHECK_SLOT (intisa, fmt, slot, -1);
  CHECK_OPCODE (intisa, opc, -1);

  slot_id = intisa->formats[fmt].slot_id[slot];
  encode_fn = intisa->opcodes[opc].encode_fns[slot_id];
  if (!encode_fn)
    {
      xtisa_errno = xtensa_isa_wrong_slot;
      sprintf (xtisa_error_msg,
              "opcode \"%s\" is not allowed in slot %d of format \"%s\"",
              intisa->opcodes[opc].name, slot, intisa->formats[fmt].name);
      return -1;
    }
  (*encode_fn) (slotbuf);
  return 0;
}

Here is the caller graph for this function:

Definition at line 834 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_OPCODE (intisa, opc, NULL);
  if (u < 0 || u >= intisa->opcodes[opc].num_funcUnit_uses)
    {
      xtisa_errno = xtensa_isa_bad_funcUnit;
      sprintf (xtisa_error_msg, "invalid functional unit use number (%d); "
              "opcode \"%s\" has %d", u, intisa->opcodes[opc].name,
              intisa->opcodes[opc].num_funcUnit_uses);
      return NULL;
    }
  return &intisa->opcodes[opc].funcUnit_uses[u];
}

Here is the caller graph for this function:

Definition at line 745 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_BRANCH) != 0)
    return 1;
  return 0;
}

Here is the caller graph for this function:

Definition at line 778 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_CALL) != 0)
    return 1;
  return 0;
}

Here is the caller graph for this function:

Definition at line 756 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_JUMP) != 0)
    return 1;
  return 0;
}

Here is the caller graph for this function:

Definition at line 767 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  if ((intisa->opcodes[opc].flags & XTENSA_OPCODE_IS_LOOP) != 0)
    return 1;
  return 0;
}

Here is the caller graph for this function:

xtensa_opcode xtensa_opcode_lookup ( xtensa_isa  isa,
const char *  opname 
)

Definition at line 654 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_lookup_entry entry, *result = 0;

  if (!opname || !*opname)
    {
      xtisa_errno = xtensa_isa_bad_opcode;
      strcpy (xtisa_error_msg, "invalid opcode name");
      return XTENSA_UNDEFINED;
    }

  if (intisa->num_opcodes != 0)
    {
      entry.key = opname;
      result = bsearch (&entry, intisa->opname_lookup_table,
                     intisa->num_opcodes, sizeof (xtensa_lookup_entry),
                     xtensa_isa_name_compare);
    }

  if (!result)
    {
      xtisa_errno = xtensa_isa_bad_opcode;
      sprintf (xtisa_error_msg, "opcode \"%s\" not recognized", opname);
      return XTENSA_UNDEFINED;
    }

  return result->u.opcode;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 736 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_OPCODE (intisa, opc, NULL);
  return intisa->opcodes[opc].name;
}

Here is the caller graph for this function:

Definition at line 825 of file xtensa-isa.c.

Here is the caller graph for this function:

Definition at line 813 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int iclass_id;

  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  iclass_id = intisa->opcodes[opc].iclass_id;
  return intisa->iclasses[iclass_id].num_interfaceOperands;
}

Here is the caller graph for this function:

Definition at line 789 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int iclass_id;

  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  iclass_id = intisa->opcodes[opc].iclass_id;
  return intisa->iclasses[iclass_id].num_operands;
}

Here is the caller graph for this function:

Definition at line 801 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int iclass_id;

  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  iclass_id = intisa->opcodes[opc].iclass_id;
  return intisa->iclasses[iclass_id].num_stateOperands;
}

Here is the caller graph for this function:

int xtensa_operand_decode ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd,
uint32 valp 
)

Definition at line 1092 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return -1;

  /* Use identity function for "default" operands.  */
  if (!intop->decode)
    return 0;

  if ((*intop->decode) (valp))
    {
      xtisa_errno = xtensa_isa_bad_value;
      sprintf (xtisa_error_msg, "cannot decode operand value 0x%08x", *valp);
      return -1;
    }
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xtensa_operand_do_reloc ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd,
uint32 valp,
uint32  pc 
)

Definition at line 1187 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return -1;

  if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
    return 0;

  if (!intop->do_reloc)
    {
      xtisa_errno = xtensa_isa_internal_error;
      strcpy (xtisa_error_msg, "operand missing do_reloc function");
      return -1;
    }

  if ((*intop->do_reloc) (valp, pc))
    {
      xtisa_errno = xtensa_isa_bad_value;
      sprintf (xtisa_error_msg,
              "do_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
      return -1;
    }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xtensa_operand_encode ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd,
uint32 valp 
)

Definition at line 1017 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;
  uint32 test_val, orig_val;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return -1;

  if (!intop->encode)
    {
      /* This is a default operand for a field.  How can we tell if the
        value fits in the field?  Write the value into the field,
        read it back, and then make sure we get the same value.  */

      xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
      static xtensa_insnbuf tmpbuf = 0;
      int slot_id;

      if (!tmpbuf)
       {
         tmpbuf = xtensa_insnbuf_alloc (isa);
         CHECK_ALLOC (tmpbuf, -1);
       }

      /* A default operand is always associated with a field,
        but check just to be sure....  */
      if (intop->field_id == XTENSA_UNDEFINED)
       {
         xtisa_errno = xtensa_isa_internal_error;
         strcpy (xtisa_error_msg, "operand has no field");
         return -1;
       }

      /* Find some slot that includes the field.  */
      for (slot_id = 0; slot_id < intisa->num_slots; slot_id++)
       {
         xtensa_get_field_fn get_fn =
           intisa->slots[slot_id].get_field_fns[intop->field_id];
         xtensa_set_field_fn set_fn =
           intisa->slots[slot_id].set_field_fns[intop->field_id];

         if (get_fn && set_fn)
           {
             (*set_fn) (tmpbuf, *valp);
             return ((*get_fn) (tmpbuf) != *valp);
           }
       }

      /* Couldn't find any slot containing the field....  */
      xtisa_errno = xtensa_isa_no_field;
      strcpy (xtisa_error_msg, "field does not exist in any slot");
      return -1;
    }

  /* Encode the value.  In some cases, the encoding function may detect
     errors, but most of the time the only way to determine if the value
     was successfully encoded is to decode it and check if it matches
     the original value.  */
  orig_val = *valp;
  if ((*intop->encode) (valp) ||
      (test_val = *valp, (*intop->decode) (&test_val)) ||
      test_val != orig_val)
    {
      xtisa_errno = xtensa_isa_bad_value;
      sprintf (xtisa_error_msg, "cannot encode operand value 0x%08x", *valp);
      return -1;
    }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xtensa_operand_get_field ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd,
xtensa_format  fmt,
int  slot,
const xtensa_insnbuf  slotbuf,
uint32 valp 
)

Definition at line 943 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;
  int slot_id;
  xtensa_get_field_fn get_fn;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return -1;

  CHECK_FORMAT (intisa, fmt, -1);
  CHECK_SLOT (intisa, fmt, slot, -1);

  slot_id = intisa->formats[fmt].slot_id[slot];
  if (intop->field_id == XTENSA_UNDEFINED)
    {
      xtisa_errno = xtensa_isa_no_field;
      strcpy (xtisa_error_msg, "implicit operand has no field");
      return -1;
    }
  get_fn = intisa->slots[slot_id].get_field_fns[intop->field_id];
  if (!get_fn)
    {
      xtisa_errno = xtensa_isa_wrong_slot;
      sprintf (xtisa_error_msg,
              "operand \"%s\" does not exist in slot %d of format \"%s\"",
              intop->name, slot, intisa->formats[fmt].name);
      return -1;
    }
  *valp = (*get_fn) (slotbuf);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

char xtensa_operand_inout ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd 
)

Definition at line 921 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_iclass_internal *iclass;
  int iclass_id;
  char inout;

  CHECK_OPCODE (intisa, opc, 0);
  iclass_id = intisa->opcodes[opc].iclass_id;
  iclass = &intisa->iclasses[iclass_id];
  CHECK_OPERAND (intisa, opc, iclass, opnd, 0);
  inout = iclass->operands[opnd].inout;

  /* Special case for "sout" operands.  */
  if (inout == 's')
    return 'o';

  return inout;
}

Here is the caller graph for this function:

Definition at line 1157 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return XTENSA_UNDEFINED;

  if ((intop->flags & XTENSA_OPERAND_IS_UNKNOWN) == 0)
    return 1;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1172 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return XTENSA_UNDEFINED;

  if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) != 0)
    return 1;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1116 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return XTENSA_UNDEFINED;

  if ((intop->flags & XTENSA_OPERAND_IS_REGISTER) != 0)
    return 1;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 895 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_iclass_internal *iclass;
  int iclass_id, operand_id;
  xtensa_operand_internal *intop;

  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  iclass_id = intisa->opcodes[opc].iclass_id;
  iclass = &intisa->iclasses[iclass_id];
  CHECK_OPERAND (intisa, opc, iclass, opnd, XTENSA_UNDEFINED);

  /* Special case for "sout" operands.  */
  if (iclass->operands[opnd].inout == 's')
    return 0;

  operand_id = iclass->operands[opnd].u.operand_id;
  intop = &intisa->operands[operand_id];

  if ((intop->flags & XTENSA_OPERAND_IS_INVISIBLE) == 0)
    return 1;
  return 0;
}

Here is the caller graph for this function:

const char* xtensa_operand_name ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd 
)

Definition at line 883 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return NULL;
  return intop->name;
}

Here is the call graph for this function:

Definition at line 1144 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return XTENSA_UNDEFINED;

  return intop->num_regs;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1131 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return XTENSA_UNDEFINED;

  return intop->regfile;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xtensa_operand_set_field ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd,
xtensa_format  fmt,
int  slot,
xtensa_insnbuf  slotbuf,
uint32  val 
)

Definition at line 980 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;
  int slot_id;
  xtensa_set_field_fn set_fn;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return -1;

  CHECK_FORMAT (intisa, fmt, -1);
  CHECK_SLOT (intisa, fmt, slot, -1);

  slot_id = intisa->formats[fmt].slot_id[slot];
  if (intop->field_id == XTENSA_UNDEFINED)
    {
      xtisa_errno = xtensa_isa_no_field;
      strcpy (xtisa_error_msg, "implicit operand has no field");
      return -1;
    }
  set_fn = intisa->slots[slot_id].set_field_fns[intop->field_id];
  if (!set_fn)
    {
      xtisa_errno = xtensa_isa_wrong_slot;
      sprintf (xtisa_error_msg,
              "operand \"%s\" does not exist in slot %d of format \"%s\"",
              intop->name, slot, intisa->formats[fmt].name);
      return -1;
    }
  (*set_fn) (slotbuf, val);
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int xtensa_operand_undo_reloc ( xtensa_isa  isa,
xtensa_opcode  opc,
int  opnd,
uint32 valp,
uint32  pc 
)

Definition at line 1219 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_operand_internal *intop;

  intop = get_operand (intisa, opc, opnd);
  if (!intop) return -1;

  if ((intop->flags & XTENSA_OPERAND_IS_PCRELATIVE) == 0)
    return 0;

  if (!intop->undo_reloc)
    {
      xtisa_errno = xtensa_isa_internal_error;
      strcpy (xtisa_error_msg, "operand missing undo_reloc function");
      return -1;
    }

  if ((*intop->undo_reloc) (valp, pc))
    {
      xtisa_errno = xtensa_isa_bad_value;
      sprintf (xtisa_error_msg,
              "undo_reloc failed for value 0x%08x at PC 0x%08x", *valp, pc);
      return -1;
    }

  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1347 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int n;

  if (!name || !*name)
    {
      xtisa_errno = xtensa_isa_bad_regfile;
      strcpy (xtisa_error_msg, "invalid regfile name");
      return XTENSA_UNDEFINED;
    }

  /* The expected number of regfiles is small; use a linear search.  */
  for (n = 0; n < intisa->num_regfiles; n++)
    {
      if (!strcmp (intisa->regfiles[n].name, name))
       return n;
    }

  xtisa_errno = xtensa_isa_bad_regfile;
  sprintf (xtisa_error_msg, "regfile \"%s\" not recognized", name);
  return XTENSA_UNDEFINED;
}

Here is the call graph for this function:

Definition at line 1373 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  int n;

  if (!shortname || !*shortname)
    {
      xtisa_errno = xtensa_isa_bad_regfile;
      strcpy (xtisa_error_msg, "invalid regfile shortname");
      return XTENSA_UNDEFINED;
    }

  /* The expected number of regfiles is small; use a linear search.  */
  for (n = 0; n < intisa->num_regfiles; n++)
    {
      /* Ignore regfile views since they always have the same shortnames
        as their parents.  */
      if (intisa->regfiles[n].parent != n)
       continue;
      if (!strcmp (intisa->regfiles[n].shortname, shortname))
       return n;
    }

  xtisa_errno = xtensa_isa_bad_regfile;
  sprintf (xtisa_error_msg, "regfile shortname \"%s\" not recognized",
          shortname);
  return XTENSA_UNDEFINED;
}

Here is the call graph for this function:

Definition at line 1404 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_REGFILE (intisa, rf, NULL);
  return intisa->regfiles[rf].name;
}

Definition at line 1431 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
  return intisa->regfiles[rf].num_bits;
}

Definition at line 1440 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
  return intisa->regfiles[rf].num_entries;
}

Definition at line 1413 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_REGFILE (intisa, rf, NULL);
  return intisa->regfiles[rf].shortname;
}

Here is the caller graph for this function:

Definition at line 1422 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_REGFILE (intisa, rf, XTENSA_UNDEFINED);
  return intisa->regfiles[rf].parent;
}

Definition at line 1513 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
  if ((intisa->states[st].flags & XTENSA_STATE_IS_EXPORTED) != 0)
    return 1;
  return 0;
}
xtensa_state xtensa_state_lookup ( xtensa_isa  isa,
const char *  name 
)

Definition at line 1464 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_lookup_entry entry, *result = 0;

  if (!name || !*name)
    {
      xtisa_errno = xtensa_isa_bad_state;
      strcpy (xtisa_error_msg, "invalid state name");
      return XTENSA_UNDEFINED;
    }

  if (intisa->num_states != 0)
    {
      entry.key = name;
      result = bsearch (&entry, intisa->state_lookup_table, intisa->num_states,
                     sizeof (xtensa_lookup_entry), xtensa_isa_name_compare);
    }

  if (!result)
    {
      xtisa_errno = xtensa_isa_bad_state;
      sprintf (xtisa_error_msg, "state \"%s\" not recognized", name);
      return XTENSA_UNDEFINED;
    }

  return result->u.state;
}

Here is the call graph for this function:

Definition at line 1495 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_STATE (intisa, st, NULL);
  return intisa->states[st].name;
}

Definition at line 1504 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_STATE (intisa, st, XTENSA_UNDEFINED);
  return intisa->states[st].num_bits;
}
char xtensa_stateOperand_inout ( xtensa_isa  isa,
xtensa_opcode  opc,
int  stOp 
)

Definition at line 1283 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_iclass_internal *iclass;
  int iclass_id;

  CHECK_OPCODE (intisa, opc, 0);
  iclass_id = intisa->opcodes[opc].iclass_id;
  iclass = &intisa->iclasses[iclass_id];
  CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, 0);
  return iclass->stateOperands[stOp].inout;
}

Here is the caller graph for this function:

Definition at line 1268 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_iclass_internal *iclass;
  int iclass_id;

  CHECK_OPCODE (intisa, opc, XTENSA_UNDEFINED);
  iclass_id = intisa->opcodes[opc].iclass_id;
  iclass = &intisa->iclasses[iclass_id];
  CHECK_STATE_OPERAND (intisa, opc, iclass, stOp, XTENSA_UNDEFINED);
  return iclass->stateOperands[stOp].u.state;
}

Here is the caller graph for this function:

Definition at line 1609 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
  if (intisa->sysregs[sysreg].is_user)
    return 1;
  return 0;
}

Here is the caller graph for this function:

xtensa_sysreg xtensa_sysreg_lookup ( xtensa_isa  isa,
int  num,
int  is_user 
)

Definition at line 1539 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;

  if (is_user != 0)
    is_user = 1;

  if (num < 0 || num > intisa->max_sysreg_num[is_user]
      || intisa->sysreg_table[is_user][num] == XTENSA_UNDEFINED)
    {
      xtisa_errno = xtensa_isa_bad_sysreg;
      strcpy (xtisa_error_msg, "sysreg not recognized");
      return XTENSA_UNDEFINED;
    }

  return intisa->sysreg_table[is_user][num];
}

Here is the caller graph for this function:

Definition at line 1559 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  xtensa_lookup_entry entry, *result = 0;

  if (!name || !*name)
    {
      xtisa_errno = xtensa_isa_bad_sysreg;
      strcpy (xtisa_error_msg, "invalid sysreg name");
      return XTENSA_UNDEFINED;
    }

  if (intisa->num_sysregs != 0)
    {
      entry.key = name;
      result = bsearch (&entry, intisa->sysreg_lookup_table,
                     intisa->num_sysregs, sizeof (xtensa_lookup_entry),
                     xtensa_isa_name_compare);
    }

  if (!result)
    {
      xtisa_errno = xtensa_isa_bad_sysreg;
      sprintf (xtisa_error_msg, "sysreg \"%s\" not recognized", name);
      return XTENSA_UNDEFINED;
    }

  return result->u.sysreg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char* xtensa_sysreg_name ( xtensa_isa  isa,
xtensa_sysreg  sysreg 
)

Definition at line 1591 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_SYSREG (intisa, sysreg, NULL);
  return intisa->sysregs[sysreg].name;
}

Here is the caller graph for this function:

Definition at line 1600 of file xtensa-isa.c.

{
  xtensa_isa_internal *intisa = (xtensa_isa_internal *) isa;
  CHECK_SYSREG (intisa, sysreg, XTENSA_UNDEFINED);
  return intisa->sysregs[sysreg].number;
}

Here is the caller graph for this function: