binutils-gdb/include/xtensa-isa.h

231 lines
9.2 KiB
C
Raw Normal View History

2003-04-01 17:50:31 +02:00
/* 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 */