xtensa-isa.h File Reference

#include "rz_types.h"

Go to the source code of this file.

Classes
struct	xtensa_isa_opaque
struct	xtensa_funcUnit_use_struct

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

Typedefs
typedef struct xtensa_isa_opaque *	xtensa_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_word *	xtensa_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_use *	xtensa_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)
int	xtensa_state_is_shared_or (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)

Variables
xtensa_isa	xtensa_default_isa

Macro Definition Documentation

uint32

#define uint32   unsigned int

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

XTENSA_ISA_VERSION

#define XTENSA_ISA_VERSION   7000

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

XTENSA_UNDEFINED

#define XTENSA_UNDEFINED   -1

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

Typedef Documentation

xtensa_format

typedef int xtensa_format

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

xtensa_funcUnit

typedef int xtensa_funcUnit

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

xtensa_funcUnit_use

typedef struct xtensa_funcUnit_use_struct xtensa_funcUnit_use

xtensa_insnbuf

typedef xtensa_insnbuf_word* xtensa_insnbuf

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

xtensa_insnbuf_word

typedef uint32 xtensa_insnbuf_word

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

xtensa_interface

typedef int xtensa_interface

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

xtensa_isa

typedef struct xtensa_isa_opaque * xtensa_isa

xtensa_isa_status

typedef enum xtensa_isa_status_enum xtensa_isa_status

xtensa_opcode

typedef int xtensa_opcode

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

xtensa_regfile

typedef int xtensa_regfile

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

xtensa_state

typedef int xtensa_state

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

xtensa_sysreg

typedef int xtensa_sysreg

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

Enumeration Type Documentation

xtensa_isa_status_enum

enum xtensa_isa_status_enum

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 149 of file xtensa-isa.h.

                                    {
    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
} xtensa_isa_status;

Function Documentation

xtensa_format_decode()

xtensa_format xtensa_format_decode	(	xtensa_isa	isa,
		const xtensa_insnbuf	insn
	)

Definition at line 570 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;
}

References xtensa_isa_internal_struct::format_decode_fn, xtensa_isa_bad_format, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

Referenced by print_insn_xtensa(), xtensa_insnbuf_to_chars(), and xtensa_op().

xtensa_format_encode()

int xtensa_format_encode	(	xtensa_isa	isa,
		xtensa_format	fmt,
		xtensa_insnbuf	insn
	)

Definition at line 587 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;
}

References CHECK_FORMAT, xtensa_format_internal_struct::encode_fn, and xtensa_isa_internal_struct::formats.

xtensa_format_get_slot()

int xtensa_format_get_slot	(	xtensa_isa	isa,
		xtensa_format	fmt,
		int	slot,
		const xtensa_insnbuf	insn,
		xtensa_insnbuf	slotbuf
	)

Definition at line 629 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;
}

References CHECK_FORMAT, CHECK_SLOT, xtensa_isa_internal_struct::formats, xtensa_slot_internal_struct::get_fn, xtensa_format_internal_struct::slot_id, and xtensa_isa_internal_struct::slots.

Referenced by print_insn_xtensa(), and xtensa_op().

xtensa_format_length()

int xtensa_format_length	(	xtensa_isa	isa,
		xtensa_format	fmt
	)

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

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

References CHECK_FORMAT, xtensa_isa_internal_struct::formats, xtensa_format_internal_struct::length, and XTENSA_UNDEFINED.

Referenced by print_insn_xtensa(), and xtensa_insnbuf_to_chars().

xtensa_format_lookup()

xtensa_format xtensa_format_lookup	(	xtensa_isa	isa,
		const char *	fmtname
	)

Definition at line 544 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 (rz_str_casecmp (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;
}

References xtensa_isa_internal_struct::formats, xtensa_format_internal_struct::name, xtensa_isa_internal_struct::num_formats, rz_str_casecmp(), sprintf, xtensa_isa_bad_format, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_format_name()

const char* xtensa_format_name	(	xtensa_isa	isa,
		xtensa_format	fmt
	)

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

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

References CHECK_FORMAT, xtensa_isa_internal_struct::formats, xtensa_format_internal_struct::name, and NULL.

xtensa_format_num_slots()

int xtensa_format_num_slots	(	xtensa_isa	isa,
		xtensa_format	fmt
	)

Definition at line 606 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;
}

References CHECK_FORMAT, xtensa_isa_internal_struct::formats, xtensa_format_internal_struct::num_slots, and XTENSA_UNDEFINED.

Referenced by print_insn_xtensa(), and xtensa_op().

xtensa_format_set_slot()

int xtensa_format_set_slot	(	xtensa_isa	isa,
		xtensa_format	fmt,
		int	slot,
		xtensa_insnbuf	insn,
		const xtensa_insnbuf	slotbuf
	)

Definition at line 645 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;
}

References CHECK_FORMAT, CHECK_SLOT, xtensa_isa_internal_struct::formats, xtensa_slot_internal_struct::set_fn, xtensa_format_internal_struct::slot_id, and xtensa_isa_internal_struct::slots.

xtensa_format_slot_nop_opcode()

xtensa_opcode xtensa_format_slot_nop_opcode	(	xtensa_isa	isa,
		xtensa_format	fmt,
		int	slot
	)

Definition at line 615 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);
}

References CHECK_FORMAT, CHECK_SLOT, xtensa_isa_internal_struct::formats, xtensa_slot_internal_struct::nop_name, xtensa_format_internal_struct::slot_id, xtensa_isa_internal_struct::slots, xtensa_opcode_lookup(), and XTENSA_UNDEFINED.

xtensa_funcUnit_lookup()

xtensa_funcUnit xtensa_funcUnit_lookup	(	xtensa_isa	isa,
		const char *	fname
	)

Definition at line 1806 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;
}

References create_tags_rz::fname, xtensa_lookup_entry_struct::fun, xtensa_isa_internal_struct::funcUnit_lookup_table, xtensa_isa_internal_struct::num_funcUnits, sprintf, xtensa_lookup_entry_struct::u, xtensa_isa_bad_funcUnit, xtensa_isa_name_compare(), XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_funcUnit_name()

const char* xtensa_funcUnit_name	(	xtensa_isa	isa,
		xtensa_funcUnit	fun
	)

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

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

References CHECK_FUNCUNIT, xtensa_isa_internal_struct::funcUnits, xtensa_funcUnit_internal_struct::name, and NULL.

xtensa_funcUnit_num_copies()

int xtensa_funcUnit_num_copies	(	xtensa_isa	isa,
		xtensa_funcUnit	fun
	)

Definition at line 1848 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;
}

References CHECK_FUNCUNIT, xtensa_isa_internal_struct::funcUnits, xtensa_funcUnit_internal_struct::num_copies, and XTENSA_UNDEFINED.

xtensa_insnbuf_alloc()

xtensa_insnbuf xtensa_insnbuf_alloc

(

xtensa_isa

isa

)

Definition at line 88 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;
}

References CHECK_ALLOC, malloc(), and xtensa_insnbuf_size().

Referenced by print_insn_xtensa(), xtensa_op(), and xtensa_operand_encode().

xtensa_insnbuf_free()

void xtensa_insnbuf_free	(	xtensa_isa	isa,
		xtensa_insnbuf	buf
	)

xtensa_insnbuf_from_chars()

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

Definition at line 196 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;
    }
}

References byte_to_bit_index(), byte_to_word_index(), i, xtensa_isa_internal_struct::is_big_endian, xtensa_isa_internal_struct::length_decode_fn, memset(), start, xtensa_insnbuf_size(), xtensa_isa_maxlength(), and XTENSA_UNDEFINED.

Referenced by print_insn_xtensa(), and xtensa_op().

xtensa_insnbuf_size()

int xtensa_insnbuf_size

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::insnbuf_size.

Referenced by print_insn_xtensa(), xtensa_insnbuf_alloc(), xtensa_insnbuf_from_chars(), and xtensa_op().

xtensa_insnbuf_to_chars()

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

Definition at line 133 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;
}

References byte_to_bit_index(), byte_to_word_index(), i, xtensa_isa_internal_struct::is_big_endian, start, xtensa_format_decode(), xtensa_format_length(), xtensa_isa_buffer_overflow, xtensa_isa_maxlength(), XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_interface_class_id()

int xtensa_interface_class_id	(	xtensa_isa	isa,
		xtensa_interface	intf
	)

Definition at line 1782 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;
}

References CHECK_INTERFACE, xtensa_interface_internal_struct::class_id, xtensa_isa_internal_struct::interfaces, and XTENSA_UNDEFINED.

xtensa_interface_has_side_effect()

int xtensa_interface_has_side_effect	(	xtensa_isa	isa,
		xtensa_interface	intf
	)

Definition at line 1770 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;
}

References CHECK_INTERFACE, xtensa_interface_internal_struct::flags, xtensa_isa_internal_struct::interfaces, XTENSA_INTERFACE_HAS_SIDE_EFFECT, and XTENSA_UNDEFINED.

xtensa_interface_inout()

char xtensa_interface_inout	(	xtensa_isa	isa,
		xtensa_interface	intf
	)

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

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

References CHECK_INTERFACE, xtensa_interface_internal_struct::inout, and xtensa_isa_internal_struct::interfaces.

xtensa_interface_lookup()

xtensa_interface xtensa_interface_lookup	(	xtensa_isa	isa,
		const char *	ifname
	)

Definition at line 1711 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;
}

References xtensa_isa_internal_struct::interface_lookup_table, xtensa_lookup_entry_struct::intf, xtensa_isa_internal_struct::num_interfaces, sprintf, xtensa_lookup_entry_struct::u, xtensa_isa_bad_interface, xtensa_isa_name_compare(), XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_interface_name()

const char* xtensa_interface_name	(	xtensa_isa	isa,
		xtensa_interface	intf
	)

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

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

References CHECK_INTERFACE, xtensa_isa_internal_struct::interfaces, xtensa_interface_internal_struct::name, and NULL.

xtensa_interface_num_bits()

int xtensa_interface_num_bits	(	xtensa_isa	isa,
		xtensa_interface	intf
	)

Definition at line 1752 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;
}

References CHECK_INTERFACE, xtensa_isa_internal_struct::interfaces, xtensa_interface_internal_struct::num_bits, and XTENSA_UNDEFINED.

xtensa_interfaceOperand_interface()

xtensa_interface xtensa_interfaceOperand_interface	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	ifOp
	)

Definition at line 1374 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];
}

References CHECK_INTERFACE_OPERAND, CHECK_OPCODE, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_iclass_internal_struct::interfaceOperands, opc, xtensa_isa_internal_struct::opcodes, and XTENSA_UNDEFINED.

xtensa_isa_errno()

xtensa_isa_status xtensa_isa_errno

(

xtensa_isa

isa

)

xtensa_isa_error_msg()

char* xtensa_isa_error_msg

(

xtensa_isa

isa

)

xtensa_isa_free()

void xtensa_isa_free

(

xtensa_isa

isa

)

Definition at line 344 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;
    }
}

References free(), xtensa_isa_internal_struct::funcUnit_lookup_table, xtensa_isa_internal_struct::interface_lookup_table, n, xtensa_isa_internal_struct::opname_lookup_table, xtensa_isa_internal_struct::state_lookup_table, xtensa_isa_internal_struct::sysreg_lookup_table, and xtensa_isa_internal_struct::sysreg_table.

xtensa_isa_init()

xtensa_isa xtensa_isa_init	(	xtensa_isa_status *	errno_p,
		char **	error_msg_p
	)

Definition at line 248 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 =
    calloc (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;
}

References bfd_malloc, calloc(), CHECK_ALLOC_FOR_INIT, xtensa_lookup_entry_struct::fun, xtensa_isa_internal_struct::funcUnit_lookup_table, xtensa_isa_internal_struct::funcUnits, xtensa_isa_internal_struct::insn_size, xtensa_isa_internal_struct::insnbuf_size, xtensa_isa_internal_struct::interface_lookup_table, xtensa_isa_internal_struct::interfaces, xtensa_lookup_entry_struct::intf, xtensa_sysreg_internal_struct::is_user, xtensa_lookup_entry_struct::key, xtensa_isa_internal_struct::max_sysreg_num, n, xtensa_opcode_internal_struct::name, xtensa_interface_internal_struct::name, xtensa_funcUnit_internal_struct::name, xtensa_state_internal_struct::name, xtensa_sysreg_internal_struct::name, NULL, xtensa_isa_internal_struct::num_funcUnits, xtensa_isa_internal_struct::num_interfaces, xtensa_isa_internal_struct::num_opcodes, xtensa_isa_internal_struct::num_states, xtensa_isa_internal_struct::num_sysregs, xtensa_sysreg_internal_struct::number, xtensa_lookup_entry_struct::opcode, xtensa_isa_internal_struct::opcodes, xtensa_isa_internal_struct::opname_lookup_table, qsort(), xtensa_lookup_entry_struct::state, xtensa_isa_internal_struct::state_lookup_table, xtensa_isa_internal_struct::states, xtensa_lookup_entry_struct::sysreg, xtensa_isa_internal_struct::sysreg_lookup_table, xtensa_isa_internal_struct::sysreg_table, xtensa_isa_internal_struct::sysregs, xtensa_lookup_entry_struct::u, xtensa_isa_name_compare(), xtensa_modules, and XTENSA_UNDEFINED.

Referenced by print_insn_xtensa(), and xtensa_op().

xtensa_isa_length_from_chars()

int xtensa_isa_length_from_chars	(	xtensa_isa	isa,
		const unsigned char *	cp
	)

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

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

References xtensa_isa_internal_struct::length_decode_fn.

xtensa_isa_maxlength()

int xtensa_isa_maxlength

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::insn_size.

Referenced by fetch_data(), print_insn_xtensa(), xtensa_insnbuf_from_chars(), and xtensa_insnbuf_to_chars().

xtensa_isa_num_formats()

int xtensa_isa_num_formats

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_formats.

xtensa_isa_num_funcUnits()

int xtensa_isa_num_funcUnits

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_funcUnits.

xtensa_isa_num_interfaces()

int xtensa_isa_num_interfaces

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_interfaces.

xtensa_isa_num_opcodes()

int xtensa_isa_num_opcodes

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_opcodes.

Referenced by xtensa_isa_num_pipe_stages().

xtensa_isa_num_pipe_stages()

int xtensa_isa_num_pipe_stages

(

xtensa_isa

isa

)

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

{
  xtensa_opcode opcode;
  xtensa_funcUnit_use *use;
  int num_opcodes, num_uses;
  int i, stage;
  static int max_stage = XTENSA_UNDEFINED;
 
  /* Only compute the value once.  */
  if (max_stage != XTENSA_UNDEFINED) {
      return max_stage + 1;
  }
 
  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;
}

References i, xtensa_funcUnit_use_struct::stage, xtensa_isa_num_opcodes(), xtensa_opcode_funcUnit_use(), xtensa_opcode_num_funcUnit_uses(), and XTENSA_UNDEFINED.

xtensa_isa_num_regfiles()

int xtensa_isa_num_regfiles

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_regfiles.

xtensa_isa_num_states()

int xtensa_isa_num_states

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_states.

xtensa_isa_num_sysregs()

int xtensa_isa_num_sysregs

(

xtensa_isa

isa

)

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

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

References xtensa_isa_internal_struct::num_sysregs.

xtensa_opcode_decode()

xtensa_opcode xtensa_opcode_decode	(	xtensa_isa	isa,
		xtensa_format	fmt,
		int	slot,
		const xtensa_insnbuf	slotbuf
	)

Definition at line 708 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;
}

References CHECK_FORMAT, CHECK_SLOT, xtensa_isa_internal_struct::formats, opc, xtensa_slot_internal_struct::opcode_decode_fn, xtensa_format_internal_struct::slot_id, xtensa_isa_internal_struct::slots, xtensa_isa_bad_opcode, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

Referenced by print_insn_xtensa(), and xtensa_op().

xtensa_opcode_encode()

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

Definition at line 732 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;
}

References CHECK_FORMAT, CHECK_OPCODE, CHECK_SLOT, xtensa_opcode_internal_struct::encode_fns, xtensa_isa_internal_struct::formats, xtensa_format_internal_struct::name, xtensa_opcode_internal_struct::name, opc, xtensa_isa_internal_struct::opcodes, xtensa_format_internal_struct::slot_id, sprintf, xtensa_isa_wrong_slot, xtisa_errno, and xtisa_error_msg.

xtensa_opcode_funcUnit_use()

xtensa_funcUnit_use* xtensa_opcode_funcUnit_use	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	u
	)

Definition at line 861 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];
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::funcUnit_uses, xtensa_opcode_internal_struct::name, NULL, xtensa_opcode_internal_struct::num_funcUnit_uses, opc, xtensa_isa_internal_struct::opcodes, sprintf, xtensa_isa_bad_funcUnit, xtisa_errno, and xtisa_error_msg.

Referenced by xtensa_isa_num_pipe_stages().

xtensa_opcode_is_branch()

int xtensa_opcode_is_branch	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 768 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::flags, opc, xtensa_isa_internal_struct::opcodes, XTENSA_OPCODE_IS_BRANCH, and XTENSA_UNDEFINED.

xtensa_opcode_is_call()

int xtensa_opcode_is_call	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 804 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::flags, opc, xtensa_isa_internal_struct::opcodes, XTENSA_OPCODE_IS_CALL, and XTENSA_UNDEFINED.

xtensa_opcode_is_jump()

int xtensa_opcode_is_jump	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 780 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::flags, opc, xtensa_isa_internal_struct::opcodes, XTENSA_OPCODE_IS_JUMP, and XTENSA_UNDEFINED.

xtensa_opcode_is_loop()

int xtensa_opcode_is_loop	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 792 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::flags, opc, xtensa_isa_internal_struct::opcodes, XTENSA_OPCODE_IS_LOOP, and XTENSA_UNDEFINED.

xtensa_opcode_lookup()

xtensa_opcode xtensa_opcode_lookup	(	xtensa_isa	isa,
		const char *	opname
	)

Definition at line 676 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;
}

References xtensa_isa_internal_struct::num_opcodes, xtensa_lookup_entry_struct::opcode, xtensa_isa_internal_struct::opname_lookup_table, sprintf, xtensa_lookup_entry_struct::u, xtensa_isa_bad_opcode, xtensa_isa_name_compare(), XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

Referenced by xtensa_format_slot_nop_opcode().

xtensa_opcode_name()

const char* xtensa_opcode_name	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

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

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

References CHECK_OPCODE, xtensa_opcode_internal_struct::name, NULL, opc, and xtensa_isa_internal_struct::opcodes.

Referenced by print_insn_xtensa().

xtensa_opcode_num_funcUnit_uses()

int xtensa_opcode_num_funcUnit_uses	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

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

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

References CHECK_OPCODE, xtensa_opcode_internal_struct::num_funcUnit_uses, opc, xtensa_isa_internal_struct::opcodes, and XTENSA_UNDEFINED.

Referenced by xtensa_isa_num_pipe_stages().

xtensa_opcode_num_interfaceOperands()

int xtensa_opcode_num_interfaceOperands	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 840 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_iclass_internal_struct::num_interfaceOperands, opc, xtensa_isa_internal_struct::opcodes, and XTENSA_UNDEFINED.

xtensa_opcode_num_operands()

int xtensa_opcode_num_operands	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 816 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_iclass_internal_struct::num_operands, opc, xtensa_isa_internal_struct::opcodes, and XTENSA_UNDEFINED.

Referenced by print_insn_xtensa().

xtensa_opcode_num_stateOperands()

int xtensa_opcode_num_stateOperands	(	xtensa_isa	isa,
		xtensa_opcode	opc
	)

Definition at line 828 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;
}

References CHECK_OPCODE, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_iclass_internal_struct::num_stateOperands, opc, xtensa_isa_internal_struct::opcodes, and XTENSA_UNDEFINED.

xtensa_operand_decode()

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

Definition at line 1128 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;
}

References xtensa_operand_internal_struct::decode, get_operand(), opc, sprintf, xtensa_isa_bad_value, xtisa_errno, and xtisa_error_msg.

Referenced by esil_branch_check_bit_imm(), esil_set_shift_amount_imm(), esil_shift_logic_imm(), and print_xtensa_operand().

xtensa_operand_do_reloc()

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

Definition at line 1239 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;
}

References xtensa_operand_internal_struct::do_reloc, xtensa_operand_internal_struct::flags, get_operand(), opc, pc, sprintf, xtensa_isa_bad_value, xtensa_isa_internal_error, XTENSA_OPERAND_IS_PCRELATIVE, xtisa_errno, and xtisa_error_msg.

xtensa_operand_encode()

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

Definition at line 1053 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.  */
      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;
}

References CHECK_ALLOC, xtensa_operand_internal_struct::decode, xtensa_operand_internal_struct::encode, xtensa_operand_internal_struct::field_id, xtensa_slot_internal_struct::get_field_fns, get_operand(), xtensa_isa_internal_struct::num_slots, opc, xtensa_slot_internal_struct::set_field_fns, xtensa_isa_internal_struct::slots, sprintf, uint32, xtensa_insnbuf_alloc(), xtensa_isa_bad_value, xtensa_isa_internal_error, xtensa_isa_no_field, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_operand_get_field()

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

References CHECK_FORMAT, CHECK_SLOT, xtensa_operand_internal_struct::field_id, xtensa_isa_internal_struct::formats, xtensa_slot_internal_struct::get_field_fns, get_operand(), xtensa_format_internal_struct::name, xtensa_operand_internal_struct::name, opc, xtensa_format_internal_struct::slot_id, xtensa_isa_internal_struct::slots, sprintf, xtensa_isa_no_field, xtensa_isa_wrong_slot, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

Referenced by esil_abs_neg(), esil_add_imm(), esil_add_sub(), esil_bitwise_op(), esil_branch_check_bit(), esil_branch_check_bit_imm(), esil_branch_check_mask(), esil_branch_compare(), esil_branch_compare_imm(), esil_branch_compare_single(), esil_call(), esil_callx(), esil_extract_unsigned(), esil_load_imm(), esil_load_relative(), esil_move(), esil_move_conditional(), esil_move_imm(), esil_set_shift_amount(), esil_set_shift_amount_imm(), esil_shift_logic_imm(), esil_shift_logic_sar(), esil_store_imm(), print_insn_xtensa(), and xtensa_check_stack_op().

xtensa_operand_inout()

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

Definition at line 952 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;
}

References CHECK_OPCODE, CHECK_OPERAND, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_arg_internal_struct::inout, opc, xtensa_isa_internal_struct::opcodes, and xtensa_iclass_internal_struct::operands.

xtensa_operand_is_known_reg()

int xtensa_operand_is_known_reg	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	opnd
	)

Definition at line 1203 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;
}

References xtensa_operand_internal_struct::flags, get_operand(), opc, XTENSA_OPERAND_IS_UNKNOWN, and XTENSA_UNDEFINED.

xtensa_operand_is_PCrelative()

int xtensa_operand_is_PCrelative	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	opnd
	)

Definition at line 1221 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;
}

References xtensa_operand_internal_struct::flags, get_operand(), opc, XTENSA_OPERAND_IS_PCRELATIVE, and XTENSA_UNDEFINED.

Referenced by print_xtensa_operand().

xtensa_operand_is_register()

int xtensa_operand_is_register	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	opnd
	)

Definition at line 1155 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;
}

References xtensa_operand_internal_struct::flags, get_operand(), opc, XTENSA_OPERAND_IS_REGISTER, and XTENSA_UNDEFINED.

Referenced by print_xtensa_operand().

xtensa_operand_is_visible()

int xtensa_operand_is_visible	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	opnd
	)

Definition at line 924 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;
}

References CHECK_OPCODE, CHECK_OPERAND, xtensa_operand_internal_struct::flags, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_arg_internal_struct::inout, opc, xtensa_isa_internal_struct::opcodes, xtensa_arg_internal_struct::operand_id, xtensa_iclass_internal_struct::operands, xtensa_isa_internal_struct::operands, xtensa_arg_internal_struct::u, XTENSA_OPERAND_IS_INVISIBLE, and XTENSA_UNDEFINED.

Referenced by print_insn_xtensa().

xtensa_operand_name()

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

Definition at line 910 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;
}

References get_operand(), xtensa_operand_internal_struct::name, NULL, and opc.

xtensa_operand_num_regs()

int xtensa_operand_num_regs	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	opnd
	)

Definition at line 1188 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;
}

References get_operand(), xtensa_operand_internal_struct::num_regs, opc, and XTENSA_UNDEFINED.

Referenced by print_xtensa_operand().

xtensa_operand_regfile()

xtensa_regfile xtensa_operand_regfile	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	opnd
	)

Definition at line 1173 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;
}

References get_operand(), opc, xtensa_operand_internal_struct::regfile, and XTENSA_UNDEFINED.

Referenced by esil_abs_neg(), esil_add_imm(), esil_add_sub(), esil_bitwise_op(), esil_branch_check_bit(), esil_branch_check_bit_imm(), esil_branch_check_mask(), esil_branch_compare(), esil_branch_compare_imm(), esil_branch_compare_single(), esil_callx(), esil_extract_unsigned(), esil_load_imm(), esil_load_relative(), esil_move(), esil_move_conditional(), esil_move_imm(), esil_set_shift_amount(), esil_shift_logic_imm(), esil_shift_logic_sar(), esil_store_imm(), and print_xtensa_operand().

xtensa_operand_set_field()

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

References CHECK_FORMAT, CHECK_SLOT, xtensa_operand_internal_struct::field_id, xtensa_isa_internal_struct::formats, get_operand(), xtensa_format_internal_struct::name, xtensa_operand_internal_struct::name, opc, xtensa_slot_internal_struct::set_field_fns, xtensa_format_internal_struct::slot_id, xtensa_isa_internal_struct::slots, sprintf, val, xtensa_isa_no_field, xtensa_isa_wrong_slot, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_operand_undo_reloc()

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

Definition at line 1274 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;
}

References xtensa_operand_internal_struct::flags, get_operand(), opc, pc, sprintf, xtensa_operand_internal_struct::undo_reloc, xtensa_isa_bad_value, xtensa_isa_internal_error, XTENSA_OPERAND_IS_PCRELATIVE, xtisa_errno, and xtisa_error_msg.

Referenced by print_xtensa_operand().

xtensa_regfile_lookup()

xtensa_regfile xtensa_regfile_lookup	(	xtensa_isa	isa,
		const char *	name
	)

Definition at line 1405 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 (!filename_cmp (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;
}

References filename_cmp(), n, xtensa_regfile_internal_struct::name, xtensa_isa_internal_struct::num_regfiles, xtensa_isa_internal_struct::regfiles, sprintf, xtensa_isa_bad_regfile, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_regfile_lookup_shortname()

xtensa_regfile xtensa_regfile_lookup_shortname	(	xtensa_isa	isa,
		const char *	shortname
	)

Definition at line 1432 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 (!filename_cmp (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;
}

References filename_cmp(), n, xtensa_isa_internal_struct::num_regfiles, xtensa_regfile_internal_struct::parent, xtensa_isa_internal_struct::regfiles, xtensa_regfile_internal_struct::shortname, sprintf, xtensa_isa_bad_regfile, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_regfile_name()

const char* xtensa_regfile_name	(	xtensa_isa	isa,
		xtensa_regfile	rf
	)

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

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

References CHECK_REGFILE, xtensa_regfile_internal_struct::name, NULL, and xtensa_isa_internal_struct::regfiles.

xtensa_regfile_num_bits()

int xtensa_regfile_num_bits	(	xtensa_isa	isa,
		xtensa_regfile	rf
	)

Definition at line 1492 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;
}

References CHECK_REGFILE, xtensa_regfile_internal_struct::num_bits, xtensa_isa_internal_struct::regfiles, and XTENSA_UNDEFINED.

xtensa_regfile_num_entries()

int xtensa_regfile_num_entries	(	xtensa_isa	isa,
		xtensa_regfile	rf
	)

Definition at line 1501 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;
}

References CHECK_REGFILE, xtensa_regfile_internal_struct::num_entries, xtensa_isa_internal_struct::regfiles, and XTENSA_UNDEFINED.

xtensa_regfile_shortname()

const char* xtensa_regfile_shortname	(	xtensa_isa	isa,
		xtensa_regfile	rf
	)

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

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

References CHECK_REGFILE, NULL, xtensa_isa_internal_struct::regfiles, and xtensa_regfile_internal_struct::shortname.

Referenced by esil_abs_neg(), esil_add_imm(), esil_add_sub(), esil_bitwise_op(), esil_branch_check_bit(), esil_branch_check_bit_imm(), esil_branch_check_mask(), esil_branch_compare(), esil_branch_compare_imm(), esil_branch_compare_single(), esil_callx(), esil_extract_unsigned(), esil_load_imm(), esil_load_relative(), esil_move(), esil_move_conditional(), esil_move_imm(), esil_set_shift_amount(), esil_shift_logic_imm(), esil_shift_logic_sar(), esil_store_imm(), and print_xtensa_operand().

xtensa_regfile_view_parent()

xtensa_regfile xtensa_regfile_view_parent	(	xtensa_isa	isa,
		xtensa_regfile	rf
	)

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

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

References CHECK_REGFILE, xtensa_regfile_internal_struct::parent, xtensa_isa_internal_struct::regfiles, and XTENSA_UNDEFINED.

xtensa_state_is_exported()

int xtensa_state_is_exported	(	xtensa_isa	isa,
		xtensa_state	st
	)

Definition at line 1574 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;
}

References CHECK_STATE, xtensa_state_internal_struct::flags, xtensa_isa_internal_struct::states, XTENSA_STATE_IS_EXPORTED, and XTENSA_UNDEFINED.

xtensa_state_is_shared_or()

int xtensa_state_is_shared_or	(	xtensa_isa	isa,
		xtensa_state	st
	)

Definition at line 1586 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_SHARED_OR) != 0) {
      return 1;
  }
  return 0;
}

References CHECK_STATE, xtensa_state_internal_struct::flags, xtensa_isa_internal_struct::states, XTENSA_STATE_IS_SHARED_OR, and XTENSA_UNDEFINED.

xtensa_state_lookup()

xtensa_state xtensa_state_lookup	(	xtensa_isa	isa,
		const char *	name
	)

Definition at line 1525 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;
}

References name, xtensa_isa_internal_struct::num_states, sprintf, xtensa_lookup_entry_struct::state, xtensa_isa_internal_struct::state_lookup_table, xtensa_lookup_entry_struct::u, xtensa_isa_bad_state, xtensa_isa_name_compare(), XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_state_name()

const char* xtensa_state_name	(	xtensa_isa	isa,
		xtensa_state	st
	)

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

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

References CHECK_STATE, xtensa_state_internal_struct::name, NULL, and xtensa_isa_internal_struct::states.

xtensa_state_num_bits()

int xtensa_state_num_bits	(	xtensa_isa	isa,
		xtensa_state	st
	)

Definition at line 1565 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;
}

References CHECK_STATE, xtensa_state_internal_struct::num_bits, xtensa_isa_internal_struct::states, and XTENSA_UNDEFINED.

xtensa_stateOperand_inout()

char xtensa_stateOperand_inout	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	stOp
	)

Definition at line 1341 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;
}

References CHECK_OPCODE, CHECK_STATE_OPERAND, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, xtensa_arg_internal_struct::inout, opc, xtensa_isa_internal_struct::opcodes, and xtensa_iclass_internal_struct::stateOperands.

xtensa_stateOperand_state()

xtensa_state xtensa_stateOperand_state	(	xtensa_isa	isa,
		xtensa_opcode	opc,
		int	stOp
	)

Definition at line 1326 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;
}

References CHECK_OPCODE, CHECK_STATE_OPERAND, xtensa_opcode_internal_struct::iclass_id, xtensa_isa_internal_struct::iclasses, opc, xtensa_isa_internal_struct::opcodes, xtensa_arg_internal_struct::state, xtensa_iclass_internal_struct::stateOperands, xtensa_arg_internal_struct::u, and XTENSA_UNDEFINED.

xtensa_sysreg_is_user()

int xtensa_sysreg_is_user	(	xtensa_isa	isa,
		xtensa_sysreg	sysreg
	)

Definition at line 1684 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;
}

References CHECK_SYSREG, xtensa_sysreg_internal_struct::is_user, xtensa_isa_internal_struct::sysregs, and XTENSA_UNDEFINED.

xtensa_sysreg_lookup()

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

Definition at line 1613 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];
}

References xtensa_isa_internal_struct::max_sysreg_num, num, xtensa_isa_internal_struct::sysreg_table, xtensa_isa_bad_sysreg, XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_sysreg_lookup_name()

xtensa_sysreg xtensa_sysreg_lookup_name	(	xtensa_isa	isa,
		const char *	name
	)

Definition at line 1634 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;
}

References name, xtensa_isa_internal_struct::num_sysregs, sprintf, xtensa_lookup_entry_struct::sysreg, xtensa_isa_internal_struct::sysreg_lookup_table, xtensa_lookup_entry_struct::u, xtensa_isa_bad_sysreg, xtensa_isa_name_compare(), XTENSA_UNDEFINED, xtisa_errno, and xtisa_error_msg.

xtensa_sysreg_name()

const char* xtensa_sysreg_name	(	xtensa_isa	isa,
		xtensa_sysreg	sysreg
	)

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

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

References CHECK_SYSREG, xtensa_sysreg_internal_struct::name, NULL, and xtensa_isa_internal_struct::sysregs.

xtensa_sysreg_number()

int xtensa_sysreg_number	(	xtensa_isa	isa,
		xtensa_sysreg	sysreg
	)

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

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

References CHECK_SYSREG, xtensa_sysreg_internal_struct::number, xtensa_isa_internal_struct::sysregs, and XTENSA_UNDEFINED.

Variable Documentation

xtensa_default_isa

xtensa_isa xtensa_default_isa

extern

Definition at line 147 of file elf32-xtensa.c.

Referenced by xtensa_op().