xtensa-isa.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <rz_util.h>
#include "../../include/disas-asm.h"
#include "../../include/sysdep.h"
#include "../../include/xtensa-isa.h"
#include "../../include/xtensa-isa-internal.h"

Go to the source code of this file.

Macros
#define	CHECK_ALLOC(MEM, ERRVAL)
#define	CHECK_ALLOC_FOR_INIT(MEM, ERRVAL, ERRNO_P, ERROR_MSG_P)
#define	CHECK_FORMAT(INTISA, FMT, ERRVAL)
#define	CHECK_SLOT(INTISA, FMT, SLOT, ERRVAL)
#define	CHECK_OPCODE(INTISA, OPC, ERRVAL)
#define	CHECK_OPERAND(INTISA, OPC, ICLASS, OPND, ERRVAL)
#define	CHECK_STATE_OPERAND(INTISA, OPC, ICLASS, STOP, ERRVAL)
#define	CHECK_INTERFACE_OPERAND(INTISA, OPC, ICLASS, IFOP, ERRVAL)
#define	CHECK_REGFILE(INTISA, RF, ERRVAL)
#define	CHECK_STATE(INTISA, ST, ERRVAL)
#define	CHECK_SYSREG(INTISA, SYSREG, ERRVAL)
#define	CHECK_INTERFACE(INTISA, INTF, ERRVAL)
#define	CHECK_FUNCUNIT(INTISA, FUN, ERRVAL)

Functions
int	filename_cmp (const char *s1, const char *s2)
xtensa_isa_status	xtensa_isa_errno (xtensa_isa isa __attribute__((unused)))
char *	xtensa_isa_error_msg (xtensa_isa isa __attribute__((unused)))
int	xtensa_insnbuf_size (xtensa_isa isa)
xtensa_insnbuf	xtensa_insnbuf_alloc (xtensa_isa isa)
void	xtensa_insnbuf_free (xtensa_isa isa __attribute__((unused)), xtensa_insnbuf buf)
static int	byte_to_word_index (int byte_index)
static int	byte_to_bit_index (int byte_index)
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_name_compare (const void *v1, const void *v2)
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)
static xtensa_operand_internal *	get_operand (xtensa_isa_internal *intisa, xtensa_opcode opc, int opnd)
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_status	xtisa_errno
char	xtisa_error_msg [1024]
xtensa_isa_internal	xtensa_modules

Macro Definition Documentation

CHECK_ALLOC

#define CHECK_ALLOC	(		MEM,
			ERRVAL
	)

Value:

  do { \
    if ((MEM) == 0) \
      { \
    xtisa_errno = xtensa_isa_out_of_memory; \
    strcpy (xtisa_error_msg, "out of memory"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_ALLOC_FOR_INIT

#define CHECK_ALLOC_FOR_INIT	(		MEM,
			ERRVAL,
			ERRNO_P,
			ERROR_MSG_P
	)

Value:

  do { \
    if ((MEM) == 0) \
      { \
    xtisa_errno = xtensa_isa_out_of_memory; \
    strcpy (xtisa_error_msg, "out of memory"); \
    if (ERRNO_P) *(ERRNO_P) = xtisa_errno; \
    if (ERROR_MSG_P) *(ERROR_MSG_P) = xtisa_error_msg; \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_FORMAT

#define CHECK_FORMAT	(		INTISA,
			FMT,
			ERRVAL
	)

Value:

  do { \
    if ((FMT) < 0 || (FMT) >= (INTISA)->num_formats) \
      { \
    xtisa_errno = xtensa_isa_bad_format; \
    strcpy (xtisa_error_msg, "invalid format specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_FUNCUNIT

#define CHECK_FUNCUNIT	(		INTISA,
			FUN,
			ERRVAL
	)

Value:

  do { \
    if ((FUN) < 0 || (FUN) >= (INTISA)->num_funcUnits) \
      { \
    xtisa_errno = xtensa_isa_bad_funcUnit; \
    strcpy (xtisa_error_msg, "invalid functional unit specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_INTERFACE

#define CHECK_INTERFACE	(		INTISA,
			INTF,
			ERRVAL
	)

Value:

  do { \
    if ((INTF) < 0 || (INTF) >= (INTISA)->num_interfaces) \
      { \
    xtisa_errno = xtensa_isa_bad_interface; \
    strcpy (xtisa_error_msg, "invalid interface specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_INTERFACE_OPERAND

#define CHECK_INTERFACE_OPERAND	(		INTISA,
			OPC,
			ICLASS,
			IFOP,
			ERRVAL
	)

Value:

  do { \
    if ((IFOP) < 0 || (IFOP) >= (ICLASS)->num_interfaceOperands) \
      { \
    xtisa_errno = xtensa_isa_bad_operand; \
    sprintf (xtisa_error_msg, "invalid interface operand number (%d); " \
         "opcode \"%s\" has %d interface operands", (IFOP), \
         (INTISA)->opcodes[(OPC)].name, \
         (ICLASS)->num_interfaceOperands); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_OPCODE

#define CHECK_OPCODE	(		INTISA,
			OPC,
			ERRVAL
	)

Value:

  do { \
    if ((OPC) < 0 || (OPC) >= (INTISA)->num_opcodes) \
      { \
    xtisa_errno = xtensa_isa_bad_opcode; \
    strcpy (xtisa_error_msg, "invalid opcode specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_OPERAND

#define CHECK_OPERAND	(		INTISA,
			OPC,
			ICLASS,
			OPND,
			ERRVAL
	)

Value:

  do { \
    if ((OPND) < 0 || (OPND) >= (ICLASS)->num_operands) \
      { \
    xtisa_errno = xtensa_isa_bad_operand; \
    sprintf (xtisa_error_msg, "invalid operand number (%d); " \
         "opcode \"%s\" has %d operands", (OPND), \
         (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_operands); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_REGFILE

#define CHECK_REGFILE	(		INTISA,
			RF,
			ERRVAL
	)

Value:

  do { \
    if ((RF) < 0 || (RF) >= (INTISA)->num_regfiles) \
      { \
    xtisa_errno = xtensa_isa_bad_regfile; \
    strcpy (xtisa_error_msg, "invalid regfile specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_SLOT

#define CHECK_SLOT	(		INTISA,
			FMT,
			SLOT,
			ERRVAL
	)

Value:

  do { \
    if ((SLOT) < 0 || (SLOT) >= (INTISA)->formats[FMT].num_slots) \
      { \
    xtisa_errno = xtensa_isa_bad_slot; \
    strcpy (xtisa_error_msg, "invalid slot specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_STATE

#define CHECK_STATE	(		INTISA,
			ST,
			ERRVAL
	)

Value:

  do { \
    if ((ST) < 0 || (ST) >= (INTISA)->num_states) \
      { \
    xtisa_errno = xtensa_isa_bad_state; \
    strcpy (xtisa_error_msg, "invalid state specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_STATE_OPERAND

#define CHECK_STATE_OPERAND	(		INTISA,
			OPC,
			ICLASS,
			STOP,
			ERRVAL
	)

Value:

  do { \
    if ((STOP) < 0 || (STOP) >= (ICLASS)->num_stateOperands) \
      { \
    xtisa_errno = xtensa_isa_bad_operand; \
    sprintf (xtisa_error_msg, "invalid state operand number (%d); " \
         "opcode \"%s\" has %d state operands", (STOP), \
         (INTISA)->opcodes[(OPC)].name, (ICLASS)->num_stateOperands); \
    return (ERRVAL); \
      } \
  } while (0)

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

CHECK_SYSREG

#define CHECK_SYSREG	(		INTISA,
			SYSREG,
			ERRVAL
	)

Value:

  do { \
    if ((SYSREG) < 0 || (SYSREG) >= (INTISA)->num_sysregs) \
      { \
    xtisa_errno = xtensa_isa_bad_sysreg; \
    strcpy (xtisa_error_msg, "invalid sysreg specifier"); \
    return (ERRVAL); \
      } \
  } while (0)

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

Function Documentation

byte_to_bit_index()

static int byte_to_bit_index ( int  byte_index )

inlinestatic

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

{
  return (byte_index & 0x3) * 8;
}

Referenced by xtensa_insnbuf_from_chars(), and xtensa_insnbuf_to_chars().

byte_to_word_index()

static int byte_to_word_index ( int  byte_index )

inlinestatic

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

{
  return byte_index / sizeof (xtensa_insnbuf_word);
}

Referenced by xtensa_insnbuf_from_chars(), and xtensa_insnbuf_to_chars().

filename_cmp()

int filename_cmp	(	const char *	s1,
		const char *	s2
	)

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

{
#if !defined(HAVE_DOS_BASED_FILE_SYSTEM) \
    && !defined(HAVE_CASE_INSENSITIVE_FILE_SYSTEM)
  return strcmp(s1, s2);
#else
  for (;;)
    {
      int c1 = *s1;
      int c2 = *s2;
 
#if defined (HAVE_CASE_INSENSITIVE_FILE_SYSTEM)
      c1 = TOLOWER (c1);
      c2 = TOLOWER (c2);
#endif
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
      /* On DOS-based file systems, the '/' and the '\' are equivalent.  */
      if (c1 == '/')
        c1 = '\\';
      if (c2 == '/')
        c2 = '\\';
#endif
 
      if (c1 != c2)
        return (c1 - c2);
 
      if (c1 == '\0')
        return 0;
 
      s1++;
      s2++;
    }
#endif
}

References c1, c2, s1, s2, and TOLOWER.

Referenced by xtensa_regfile_lookup(), and xtensa_regfile_lookup_shortname().

get_operand()

static xtensa_operand_internal* get_operand ( xtensa_isa_internal *  intisa, xtensa_opcode  opc, int  opnd  )

static

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

{
  xtensa_iclass_internal *iclass;
  int iclass_id, operand_id;
 
  CHECK_OPCODE (intisa, opc, NULL);
  iclass_id = intisa->opcodes[opc].iclass_id;
  iclass = &intisa->iclasses[iclass_id];
  CHECK_OPERAND (intisa, opc, iclass, opnd, NULL);
  operand_id = iclass->operands[opnd].u.operand_id;
  return &intisa->operands[operand_id];
}

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

Referenced by xtensa_operand_decode(), xtensa_operand_do_reloc(), xtensa_operand_encode(), xtensa_operand_get_field(), xtensa_operand_is_known_reg(), xtensa_operand_is_PCrelative(), xtensa_operand_is_register(), xtensa_operand_name(), xtensa_operand_num_regs(), xtensa_operand_regfile(), xtensa_operand_set_field(), and xtensa_operand_undo_reloc().

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	__attribute__(unused),
		xtensa_insnbuf	buf
	)

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

{
  free (buf);
}

References free().

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

__attribute__(unused)

)

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

{
  return xtisa_errno;
}

References xtisa_errno.

xtensa_isa_error_msg()

char* xtensa_isa_error_msg

(

xtensa_isa isa

__attribute__(unused)

)

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

{
  return xtisa_error_msg;
}

References xtisa_error_msg.

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

int xtensa_isa_name_compare	(	const void *	v1,
		const void *	v2
	)

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

{
  xtensa_lookup_entry *e1 = (xtensa_lookup_entry *) v1;
  xtensa_lookup_entry *e2 = (xtensa_lookup_entry *) v2;
 
  return rz_str_casecmp (e1->key, e2->key);
}

References xtensa_lookup_entry_struct::key, rz_str_casecmp(), and v1.

Referenced by xtensa_funcUnit_lookup(), xtensa_interface_lookup(), xtensa_isa_init(), xtensa_opcode_lookup(), xtensa_state_lookup(), and xtensa_sysreg_lookup_name().

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_modules

xtensa_isa_internal xtensa_modules

extern

Definition at line 21455 of file xtensa-modules.c.

Referenced by xtensa_isa_init().

xtisa_errno

xtensa_isa_status xtisa_errno

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

Referenced by xtensa_format_decode(), xtensa_format_lookup(), xtensa_funcUnit_lookup(), xtensa_insnbuf_to_chars(), xtensa_interface_lookup(), xtensa_isa_errno(), xtensa_opcode_decode(), xtensa_opcode_encode(), xtensa_opcode_funcUnit_use(), xtensa_opcode_lookup(), xtensa_operand_decode(), xtensa_operand_do_reloc(), xtensa_operand_encode(), xtensa_operand_get_field(), xtensa_operand_set_field(), xtensa_operand_undo_reloc(), xtensa_regfile_lookup(), xtensa_regfile_lookup_shortname(), xtensa_state_lookup(), xtensa_sysreg_lookup(), and xtensa_sysreg_lookup_name().

xtisa_error_msg

char xtisa_error_msg[1024]

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

Referenced by xtensa_format_decode(), xtensa_format_lookup(), xtensa_funcUnit_lookup(), xtensa_insnbuf_to_chars(), xtensa_interface_lookup(), xtensa_isa_error_msg(), xtensa_opcode_decode(), xtensa_opcode_encode(), xtensa_opcode_funcUnit_use(), xtensa_opcode_lookup(), xtensa_operand_decode(), xtensa_operand_do_reloc(), xtensa_operand_encode(), xtensa_operand_get_field(), xtensa_operand_set_field(), xtensa_operand_undo_reloc(), xtensa_regfile_lookup(), xtensa_regfile_lookup_shortname(), xtensa_state_lookup(), xtensa_sysreg_lookup(), and xtensa_sysreg_lookup_name().