230 lines
9.2 KiB
C
230 lines
9.2 KiB
C
/* Interface definition for configurable Xtensa ISA support.
|
|
Copyright 2003 Free Software Foundation, Inc.
|
|
|
|
This file is part of BFD, the Binary File Descriptor library.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|
|
|
#ifndef XTENSA_LIBISA_H
|
|
#define XTENSA_LIBISA_H
|
|
|
|
/* Use the statically-linked version for the GNU tools. */
|
|
#define STATIC_LIBISA 1
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifndef uint32
|
|
#define uint32 unsigned int
|
|
#endif
|
|
|
|
/* This file defines the interface to the Xtensa ISA library. This library
|
|
contains most of the ISA-specific information for a particular Xtensa
|
|
processor. For example, the set of valid instructions, their opcode
|
|
encodings and operand fields are all included here. To support Xtensa's
|
|
configurability and user-defined instruction extensions (i.e., TIE), the
|
|
library is initialized by loading one or more dynamic libraries; only a
|
|
small set of interface code is present in the statically-linked portion
|
|
of the library.
|
|
|
|
This interface basically defines four abstract data types.
|
|
|
|
. an instruction buffer - for holding the raw instruction bits
|
|
. ISA info - information about the ISA as a whole
|
|
. opcode info - information about individual instructions
|
|
. operand info - information about specific instruction operands
|
|
|
|
It would be nice to implement these as classes in C++, but the library is
|
|
implemented in C to match the expectations of the GNU tools.
|
|
Instead, the interface defines a set of functions to access each data
|
|
type. With the exception of the instruction buffer, the internal
|
|
representations of the data structures are hidden. All accesses must be
|
|
made through the functions defined here. */
|
|
|
|
typedef void* xtensa_isa;
|
|
typedef void* xtensa_operand;
|
|
|
|
|
|
/* Opcodes are represented here using sequential integers beginning with 0.
|
|
The specific value used for a particular opcode is only fixed for a
|
|
particular instantiation of an xtensa_isa structure, so these values
|
|
should only be used internally. */
|
|
typedef int xtensa_opcode;
|
|
|
|
/* Define a unique value for undefined opcodes ("static const int" doesn't
|
|
seem to work for this because EGCS 1.0.3 on i686-Linux without -O won't
|
|
allow it to be used as an initializer). */
|
|
#define XTENSA_UNDEFINED -1
|
|
|
|
|
|
typedef int libisa_module_specifier;
|
|
|
|
extern xtensa_isa xtensa_isa_init (void);
|
|
|
|
|
|
/* Instruction buffers. */
|
|
|
|
typedef uint32 xtensa_insnbuf_word;
|
|
typedef xtensa_insnbuf_word *xtensa_insnbuf;
|
|
|
|
/* Get the size in words of the xtensa_insnbuf array. */
|
|
extern int xtensa_insnbuf_size (xtensa_isa);
|
|
|
|
/* Allocate (with malloc) an xtensa_insnbuf of the right size. */
|
|
extern xtensa_insnbuf xtensa_insnbuf_alloc (xtensa_isa);
|
|
|
|
/* Release (with free) an xtensa_insnbuf of the right size. */
|
|
extern void xtensa_insnbuf_free (xtensa_insnbuf);
|
|
|
|
/* Inward and outward conversion from memory images (byte streams) to our
|
|
internal instruction representation. */
|
|
extern void xtensa_insnbuf_to_chars (xtensa_isa, const xtensa_insnbuf,
|
|
char *);
|
|
|
|
extern void xtensa_insnbuf_from_chars (xtensa_isa, xtensa_insnbuf,
|
|
const char *);
|
|
|
|
|
|
/* ISA information. */
|
|
|
|
/* Load the ISA information from a shared library. If successful, this returns
|
|
a value which identifies the ISA for use in subsequent calls to the ISA
|
|
library; otherwise, it returns NULL. Multiple ISAs can be loaded to support
|
|
heterogeneous multiprocessor systems. */
|
|
extern xtensa_isa xtensa_load_isa (libisa_module_specifier);
|
|
|
|
/* Extend an existing set of ISA information by loading an additional shared
|
|
library of ISA information. This is primarily intended for loading TIE
|
|
extensions. If successful, the return value is non-zero. */
|
|
extern int xtensa_extend_isa (xtensa_isa, libisa_module_specifier);
|
|
|
|
/* The default ISA. This variable is set automatically to the ISA most
|
|
recently loaded and is provided as a convenience. An exception is the GNU
|
|
opcodes library, where there is a fixed interface that does not allow
|
|
passing the ISA as a parameter and the ISA must be taken from this global
|
|
variable. (Note: Since this variable is just a convenience, it is not
|
|
exported when libisa is built as a DLL, due to the hassle of dealing with
|
|
declspecs.) */
|
|
extern xtensa_isa xtensa_default_isa;
|
|
|
|
|
|
/* Deallocate an xtensa_isa structure. */
|
|
extern void xtensa_isa_free (xtensa_isa);
|
|
|
|
/* Get the maximum instruction size in bytes. */
|
|
extern int xtensa_insn_maxlength (xtensa_isa);
|
|
|
|
/* Get the total number of opcodes for this processor. */
|
|
extern int xtensa_num_opcodes (xtensa_isa);
|
|
|
|
/* Translate a mnemonic name to an opcode. Returns XTENSA_UNDEFINED if
|
|
the name is not a valid opcode mnemonic. */
|
|
extern xtensa_opcode xtensa_opcode_lookup (xtensa_isa, const char *);
|
|
|
|
/* Decode a binary instruction buffer. Returns the opcode or
|
|
XTENSA_UNDEFINED if the instruction is illegal. */
|
|
extern xtensa_opcode xtensa_decode_insn (xtensa_isa, const xtensa_insnbuf);
|
|
|
|
|
|
/* Opcode information. */
|
|
|
|
/* Set the opcode field(s) in a binary instruction buffer. The operand
|
|
fields are set to zero. */
|
|
extern void xtensa_encode_insn (xtensa_isa, xtensa_opcode, xtensa_insnbuf);
|
|
|
|
/* Get the mnemonic name for an opcode. */
|
|
extern const char * xtensa_opcode_name (xtensa_isa, xtensa_opcode);
|
|
|
|
/* Find the length (in bytes) of an instruction. */
|
|
extern int xtensa_insn_length (xtensa_isa, xtensa_opcode);
|
|
|
|
/* Find the length of an instruction by looking only at the first byte. */
|
|
extern int xtensa_insn_length_from_first_byte (xtensa_isa, char);
|
|
|
|
/* Find the number of operands for an instruction. */
|
|
extern int xtensa_num_operands (xtensa_isa, xtensa_opcode);
|
|
|
|
/* Get the information about operand number "opnd" of a particular opcode. */
|
|
extern xtensa_operand xtensa_get_operand (xtensa_isa, xtensa_opcode, int);
|
|
|
|
/* Operand information. */
|
|
|
|
/* Find the kind of operand. There are three possibilities:
|
|
1) PC-relative immediates (e.g., "l", "L"). These can be identified with
|
|
the xtensa_operand_isPCRelative function.
|
|
2) non-PC-relative immediates ("i").
|
|
3) register-file short names (e.g., "a", "b", "m" and others defined
|
|
via TIE). */
|
|
extern char * xtensa_operand_kind (xtensa_operand);
|
|
|
|
/* Check if an operand is an input ('<'), output ('>'), or inout ('=')
|
|
operand. Note: The output operand of a conditional assignment
|
|
(e.g., movnez) appears here as an inout ('=') even if it is declared
|
|
in the TIE code as an output ('>'); this allows the compiler to
|
|
properly handle register allocation for conditional assignments. */
|
|
extern char xtensa_operand_inout (xtensa_operand);
|
|
|
|
/* Get and set the raw (encoded) value of the field for the specified
|
|
operand. The "set" function does not check if the value fits in the
|
|
field; that is done by the "encode" function below. */
|
|
extern uint32 xtensa_operand_get_field (xtensa_operand, const xtensa_insnbuf);
|
|
|
|
extern void xtensa_operand_set_field (xtensa_operand, xtensa_insnbuf, uint32);
|
|
|
|
|
|
/* Encode and decode operands. The raw bits in the operand field
|
|
may be encoded in a variety of different ways. These functions hide the
|
|
details of that encoding. The encode function has a special return type
|
|
(xtensa_encode_result) to indicate success or the reason for failure; the
|
|
encoded value is returned through the argument pointer. The decode function
|
|
has no possibility of failure and returns the decoded value. */
|
|
|
|
typedef enum
|
|
{
|
|
xtensa_encode_result_ok,
|
|
xtensa_encode_result_align,
|
|
xtensa_encode_result_not_in_table,
|
|
xtensa_encode_result_too_low,
|
|
xtensa_encode_result_too_high,
|
|
xtensa_encode_result_not_ok,
|
|
xtensa_encode_result_max = xtensa_encode_result_not_ok
|
|
} xtensa_encode_result;
|
|
|
|
extern xtensa_encode_result xtensa_operand_encode (xtensa_operand, uint32 *);
|
|
|
|
extern uint32 xtensa_operand_decode (xtensa_operand, uint32);
|
|
|
|
|
|
/* For PC-relative offset operands, the interpretation of the offset may vary
|
|
between opcodes, e.g., is it relative to the current PC or that of the next
|
|
instruction? The following functions are defined to perform PC-relative
|
|
relocations and to undo them (as in the disassembler). The first function
|
|
takes the desired address and the PC of the current instruction and returns
|
|
the unencoded value to be stored in the offset field. The second function
|
|
takes the unencoded offset value and the current PC and returns the address.
|
|
Note that these functions do not replace the encode/decode functions; the
|
|
operands must be encoded/decoded separately. */
|
|
|
|
extern int xtensa_operand_isPCRelative (xtensa_operand);
|
|
|
|
extern uint32 xtensa_operand_do_reloc (xtensa_operand, uint32, uint32);
|
|
|
|
extern uint32 xtensa_operand_undo_reloc (xtensa_operand, uint32, uint32);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
#endif /* XTENSA_LIBISA_H */
|