#ifdef CGEN_INT_INSN
typedef unsigned int cgen_insn_t;
#else
-typedef char *cgen_insn_t;
+typedef char * cgen_insn_t;
#endif
#ifdef __GNUC__
/* Perhaps we should just use bfd.h, but it's not clear
one would want to require that yet. */
-enum cgen_endian {
+enum cgen_endian
+{
CGEN_ENDIAN_UNKNOWN,
CGEN_ENDIAN_LITTLE,
CGEN_ENDIAN_BIG
Attributes are used to describe various random things. */
/* Struct to record attribute information. */
-typedef struct {
+typedef struct
+{
unsigned char num_nonbools;
unsigned int bool;
unsigned int nonbool[1];
/* Attribute name/value tables.
These are used to assist parsing of descriptions at runtime. */
-typedef struct {
- const char *name;
- int value;
+typedef struct
+{
+ const char * name;
+ int value;
} CGEN_ATTR_ENTRY;
/* For each domain (fld,operand,insn), list of attributes. */
-typedef struct {
- const char *name;
+typedef struct
+{
+ const char * name;
/* NULL for boolean attributes. */
- const CGEN_ATTR_ENTRY *vals;
+ const CGEN_ATTR_ENTRY * vals;
} CGEN_ATTR_TABLE;
\f
/* Parse result (also extraction result).
where it varies.
*/
-struct cgen_fields;
+typedef struct cgen_fields CGEN_FIELDS;
/* Total length of the insn, as recorded in the `fields' struct. */
/* ??? The field insert handler has lots of opportunities for optimization
The result is NULL if success or an error message. */
typedef const char * (cgen_parse_fn) PARAMS ((const struct cgen_insn *,
const char **,
- struct cgen_fields *));
+ CGEN_FIELDS *));
/* Print handler.
The first argument is a pointer to the disassembly info.
/* Don't require bfd.h unnecessarily. */
#ifdef BFD_VERSION
typedef void (cgen_print_fn) PARAMS ((PTR, const struct cgen_insn *,
- struct cgen_fields *, bfd_vma, int));
+ CGEN_FIELDS *, bfd_vma, int));
#else
typedef void (cgen_print_fn) ();
#endif
from which the values are fetched.
The third argument is a pointer to a buffer in which to place the insn. */
typedef void (cgen_insert_fn) PARAMS ((const struct cgen_insn *,
- struct cgen_fields *, cgen_insn_t *));
+ CGEN_FIELDS *, cgen_insn_t *));
/* Extract handler.
The first argument is a pointer to a struct describing the insn being
The result is the length of the insn or zero if not recognized. */
typedef int (cgen_extract_fn) PARAMS ((const struct cgen_insn *,
void *, cgen_insn_t,
- struct cgen_fields *));
+ CGEN_FIELDS *));
/* The `parse' and `insert' fields are indices into these tables.
The elements are pointer to specialized handler functions.
It's a collection of the common elements needed to parse, insert, extract,
and print each of them. */
-#ifndef CGEN_MAX_INSN_ATTRS
-#define CGEN_MAX_INSN_ATTRS 1
+#ifndef CGEN_INSN_MAX_ATTRS
+#define CGEN_INSN_MAX_ATTRS 1
#endif
-struct cgen_base {
+struct cgen_base
+{
/* Indices into the handler tables.
We could use pointers here instead, but in the case of the insn table,
90% of them would be identical and that's a lot of redundant data.
The parsed value is stored in the bfd_vma *. */
/* Values for indicating what the caller wants. */
-enum cgen_parse_operand_type {
- CGEN_PARSE_OPERAND_INIT, CGEN_PARSE_OPERAND_INTEGER,
+enum cgen_parse_operand_type
+{
+ CGEN_PARSE_OPERAND_INIT,
+ CGEN_PARSE_OPERAND_INTEGER,
CGEN_PARSE_OPERAND_ADDRESS
};
/* Values for indicating what was parsed.
??? Not too useful at present but in time. */
-enum cgen_parse_operand_result {
- CGEN_PARSE_OPERAND_RESULT_NUMBER, CGEN_PARSE_OPERAND_RESULT_REGISTER,
- CGEN_PARSE_OPERAND_RESULT_QUEUED, CGEN_PARSE_OPERAND_RESULT_ERROR
+enum cgen_parse_operand_result
+{
+ CGEN_PARSE_OPERAND_RESULT_NUMBER,
+ CGEN_PARSE_OPERAND_RESULT_REGISTER,
+ CGEN_PARSE_OPERAND_RESULT_QUEUED,
+ CGEN_PARSE_OPERAND_RESULT_ERROR
};
/* Don't require bfd.h unnecessarily. */
#ifdef BFD_VERSION
/* The result is an error message or NULL for success.
The parsed value is stored in the bfd_vma *. */
-const char *cgen_parse_operand PARAMS ((enum cgen_parse_operand_type,
- const char **, int, int,
- enum cgen_parse_operand_result *,
- bfd_vma *));
+const char * cgen_parse_operand PARAMS ((enum cgen_parse_operand_type,
+ const char **, int, int,
+ enum cgen_parse_operand_result *,
+ bfd_vma *));
#endif
+void cgen_save_fixups PARAMS ((void));
+void cgen_restore_fixups PARAMS ((void));
+void cgen_swap_fixups PARAMS ((void));
+
/* Add a register to the assembler's hash table.
This makes lets GAS parse registers for us.
??? This isn't currently used, but it could be in the future. */
void cgen_asm_record_register PARAMS ((char *, int));
/* After CGEN_SYM (assemble_insn) is done, this is called to
- output the insn and record any fixups. */
-void cgen_asm_finish_insn PARAMS ((const struct cgen_insn *, cgen_insn_t *,
+ output the insn and record any fixups. The address of the
+ assembled instruction is returned in case it is needed by
+ the caller. */
+char * cgen_asm_finish_insn PARAMS ((const struct cgen_insn *, cgen_insn_t *,
unsigned int));
\f
/* Operand values (keywords, integers, symbols, etc.) */
/* Types of assembler elements. */
-enum cgen_asm_type {
+enum cgen_asm_type
+{
CGEN_ASM_KEYWORD, CGEN_ASM_MAX
};
/* List of hardware elements. */
-typedef struct cgen_hw_entry {
- struct cgen_hw_entry *next;
- char *name;
- enum cgen_asm_type asm_type;
- PTR asm_data;
+typedef struct cgen_hw_entry
+{
+ /* The type of this entry, one of `enum hw_type'.
+ This is an int and not the enum as the latter may not be declared yet. */
+ int type;
+ const struct cgen_hw_entry * next;
+ char * name;
+ enum cgen_asm_type asm_type;
+ PTR asm_data;
} CGEN_HW_ENTRY;
-extern CGEN_HW_ENTRY *CGEN_SYM (hw_list);
+const CGEN_HW_ENTRY * cgen_hw_lookup PARAMS ((const char *));
-CGEN_HW_ENTRY *cgen_hw_lookup PARAMS ((const char *));
-
-#ifndef CGEN_MAX_KEYWORD_ATTRS
-#define CGEN_MAX_KEYWORD_ATTRS 1
+#ifndef CGEN_KEYWORD_MAX_ATTRS
+#define CGEN_KEYWORD_MAX_ATTRS 1
#endif
/* This struct is used to describe things like register names, etc. */
-typedef struct cgen_keyword_entry {
+typedef struct cgen_keyword_entry
+{
/* Name (as in register name). */
- char *name;
+ char * name;
/* Value (as in register number).
The value cannot be -1 as that is used to indicate "not found".
/* ??? Moving this last should be done by treating keywords like insn lists
and moving the `next' fields into a CGEN_KEYWORD_LIST struct. */
/* FIXME: Not used yet. */
- CGEN_ATTR_TYPE (CGEN_MAX_KEYWORD_ATTRS) attrs;
+ CGEN_ATTR_TYPE (CGEN_KEYWORD_MAX_ATTRS) attrs;
/* Next name hash table entry. */
struct cgen_keyword_entry *next_name;
This struct supports runtime entry of new values, and hashed lookups. */
-typedef struct {
+typedef struct cgen_keyword
+{
/* Pointer to initial [compiled in] values. */
- CGEN_KEYWORD_ENTRY *init_entries;
+ CGEN_KEYWORD_ENTRY * init_entries;
+
/* Number of entries in `init_entries'. */
unsigned int num_init_entries;
+
/* Hash table used for name lookup. */
- CGEN_KEYWORD_ENTRY **name_hash_table;
+ CGEN_KEYWORD_ENTRY ** name_hash_table;
+
/* Hash table used for value lookup. */
- CGEN_KEYWORD_ENTRY **value_hash_table;
+ CGEN_KEYWORD_ENTRY ** value_hash_table;
+
/* Number of entries in the hash_tables. */
unsigned int hash_table_size;
+
/* Pointer to null keyword "" entry if present. */
- const CGEN_KEYWORD_ENTRY *null_entry;
+ const CGEN_KEYWORD_ENTRY * null_entry;
} CGEN_KEYWORD;
/* Structure used for searching. */
-typedef struct {
+typedef struct
+{
/* Table being searched. */
- const CGEN_KEYWORD *table;
+ const CGEN_KEYWORD * table;
+
/* Specification of what is being searched for. */
- const char *spec;
+ const char * spec;
+
/* Current index in hash table. */
unsigned int current_hash;
+
/* Current element in current hash chain. */
- CGEN_KEYWORD_ENTRY *current_entry;
+ CGEN_KEYWORD_ENTRY * current_entry;
} CGEN_KEYWORD_SEARCH;
/* Lookup a keyword from its name. */
unsigned long,
unsigned long));
\f
+/* Operand modes. */
+
+/* ??? This duplicates the values in arch.h. Revisit.
+ These however need the CGEN_ prefix [as does everything in this file]. */
+/* ??? Targets may need to add their own modes so we may wish to move this
+ to <arch>-opc.h, or add a hook. */
+
+enum cgen_mode {
+ CGEN_MODE_VOID, /* FIXME: rename simulator's VM to VOID */
+ CGEN_MODE_BI, CGEN_MODE_QI, CGEN_MODE_HI, CGEN_MODE_SI, CGEN_MODE_DI,
+ CGEN_MODE_UBI, CGEN_MODE_UQI, CGEN_MODE_UHI, CGEN_MODE_USI, CGEN_MODE_UDI,
+ CGEN_MODE_SF, CGEN_MODE_DF, CGEN_MODE_XF, CGEN_MODE_TF,
+ CGEN_MODE_MAX
+};
+
+/* FIXME: Until simulator is updated. */
+#define CGEN_MODE_VM CGEN_MODE_VOID
+\f
/* This struct defines each entry in the operand table. */
-#ifndef CGEN_MAX_OPERAND_ATTRS
-#define CGEN_MAX_OPERAND_ATTRS 1
+#ifndef CGEN_OPERAND_MAX_ATTRS
+#define CGEN_OPERAND_MAX_ATTRS 1
#endif
-typedef struct {
+typedef struct cgen_operand
+{
/* Name as it appears in the syntax string. */
- char *name;
+ char * name;
+
+ /* The hardware element associated with this operand. */
+ const CGEN_HW_ENTRY *hw;
+
+ /* FIXME: We don't yet record ifield definitions, which we should.
+ When we do it might make sense to delete start/length (since they will
+ be duplicated in the ifield's definition) and replace them with a
+ pointer to the ifield entry. Note that as more complicated situations
+ need to be handled, going more and more with an OOP paradigm will help
+ keep the complication under control. Of course, this was the goal from
+ the start, but getting there in one step was too much too soon. */
/* Bit position (msb of first byte = bit 0).
This is just a hint, and may be unused in more complex operands.
array in that one architecture may have 1 nonbool attribute and another
may have more. Having this last means the non-architecture specific code
needn't care, now or tomorrow. */
- CGEN_ATTR_TYPE (CGEN_MAX_OPERAND_ATTRS) attrs;
+ CGEN_ATTR_TYPE (CGEN_OPERAND_MAX_ATTRS) attrs;
#define CGEN_OPERAND_ATTRS(operand) (&(operand)->attrs)
} CGEN_OPERAND;
#define CGEN_OPERAND_TYPE(operand) ((enum cgen_operand_type) CGEN_OPERAND_INDEX (operand))
#define CGEN_OPERAND_ENTRY(n) (& CGEN_SYM (operand_table) [n])
\f
+/* Instruction operand instances.
+
+ For each instruction, a list of the hardware elements that are read and
+ written are recorded. */
+
+/* The type of the instance. */
+enum cgen_operand_instance_type {
+ /* End of table marker. */
+ CGEN_OPERAND_INSTANCE_END = 0,
+ CGEN_OPERAND_INSTANCE_INPUT, CGEN_OPERAND_INSTANCE_OUTPUT
+};
+
+typedef struct
+{
+ /* The type of this operand. */
+ enum cgen_operand_instance_type type;
+#define CGEN_OPERAND_INSTANCE_TYPE(opinst) ((opinst)->type)
+
+ /* The hardware element referenced. */
+ const CGEN_HW_ENTRY *hw;
+#define CGEN_OPERAND_INSTANCE_HW(opinst) ((opinst)->hw)
+
+ /* The mode in which the operand is being used. */
+ enum cgen_mode mode;
+#define CGEN_OPERAND_INSTANCE_MODE(opinst) ((opinst)->mode)
+
+ /* The operand table entry or NULL if there is none (i.e. an explicit
+ hardware reference). */
+ const CGEN_OPERAND *operand;
+#define CGEN_OPERAND_INSTANCE_OPERAND(opinst) ((opinst)->operand)
+
+ /* If `operand' is NULL, the index (e.g. into array of registers). */
+ int index;
+#define CGEN_OPERAND_INSTANCE_INDEX(opinst) ((opinst)->index)
+} CGEN_OPERAND_INSTANCE;
+\f
/* Syntax string.
Each insn format and subexpression has one of these.
#define CGEN_MAX_SYNTAX_BYTES 16
#endif
-typedef struct {
+typedef struct
+{
unsigned char syntax[CGEN_MAX_SYNTAX_BYTES];
} CGEN_SYNTAX;
This cuts down on the size of the opcode table as there are relatively few
formats compared with the number of instructions. */
-typedef struct {
+typedef struct
+{
/* Length that MASK and VALUE have been calculated to
[VALUE is recorded elsewhere].
Normally it is CGEN_BASE_INSN_BITSIZE. On [V]LIW architectures where
\f
/* This struct defines each entry in the instruction table. */
-struct cgen_insn {
+struct cgen_insn
+{
/* ??? Further table size reductions can be had by moving this element
either to the format table or to a separate table of its own. Not
sure this is desirable yet. */
struct cgen_base base;
+
/* Given a pointer to a cgen_insn struct, return a pointer to `base'. */
#define CGEN_INSN_BASE(insn) (&(insn)->base)
/* Name of entry (that distinguishes it from all other entries).
This is used, for example, in simulator profiling results. */
/* ??? If mnemonics have operands, try to print full mnemonic. */
- const char *name;
+ const char * name;
#define CGEN_INSN_NAME(insn) ((insn)->name)
/* Mnemonic. This is used when parsing and printing the insn.
In the case of insns that have operands on the mnemonics, this is
only the constant part. E.g. for conditional execution of an `add' insn,
where the full mnemonic is addeq, addne, etc., this is only "add". */
- const char *mnemonic;
+ const char * mnemonic;
#define CGEN_INSN_MNEMONIC(insn) ((insn)->mnemonic)
/* Syntax string.
For now this only points to CGEN_SYNTAX elements, but it can point
to other things (e.g. something different for macros?). */
- const CGEN_SYNTAX *syntax;
+ const CGEN_SYNTAX * syntax;
#define CGEN_INSN_SYNTAX(insn) ((CGEN_SYNTAX *) (insn)->syntax)
/* Format entry.
For now this only points to CGEN_FORMAT elements, but it can point
to other things (e.g. something different for macros?). */
- const CGEN_FORMAT *format;
+ const CGEN_FORMAT * format;
#define CGEN_INSN_MASK_BITSIZE(insn) (((CGEN_FORMAT *) (insn)->format)->mask_length)
#define CGEN_INSN_BITSIZE(insn) (((CGEN_FORMAT *) (insn)->format)->length)
#define CGEN_INSN_VALUE(insn) ((insn)->value)
#define CGEN_INSN_MASK(insn) (((CGEN_FORMAT *) (insn)->format)->mask)
+ /* Pointer to NULL entry terminated table of operands used,
+ or NULL if none. */
+ const CGEN_OPERAND_INSTANCE *operands;
+#define CGEN_INSN_OPERANDS(insn) ((insn)->operands)
+
/* Attributes.
This must appear last. It is a variable sized array in that one
architecture may have 1 nonbool attribute and another may have more.
Having this last means the non-architecture specific code needn't
care. */
- CGEN_ATTR_TYPE (CGEN_MAX_INSN_ATTRS) attrs;
+ CGEN_ATTR_TYPE (CGEN_INSN_MAX_ATTRS) attrs;
#define CGEN_INSN_ATTRS(insn) (&(insn)->attrs)
/* Return value of attribute ATTR in INSN. */
#define CGEN_INSN_ATTR(insn, attr) \
/* Instruction lists.
This is used for adding new entries and for creating the hash lists. */
-typedef struct cgen_insn_list {
- struct cgen_insn_list *next;
- const CGEN_INSN *insn;
+typedef struct cgen_insn_list
+{
+ struct cgen_insn_list * next;
+ const CGEN_INSN * insn;
} CGEN_INSN_LIST;
/* The table of instructions. */
-typedef struct {
+typedef struct
+{
/* Pointer to initial [compiled in] entries. */
- const CGEN_INSN *init_entries;
+ const CGEN_INSN * init_entries;
+
/* Size of an entry (since the attribute member is variable sized). */
unsigned int entry_size;
+
/* Number of entries in `init_entries', including trailing NULL entry. */
unsigned int num_init_entries;
+
/* Values added at runtime. */
- CGEN_INSN_LIST *new_entries;
+ CGEN_INSN_LIST * new_entries;
+
/* Assembler hash function. */
- unsigned int (*asm_hash) PARAMS ((const char *));
+ unsigned int (* asm_hash) PARAMS ((const char *));
+
/* Number of entries in assembler hash table. */
unsigned int asm_hash_table_size;
+
/* Disassembler hash function. */
- unsigned int (*dis_hash) PARAMS ((const char *, unsigned long));
+ unsigned int (* dis_hash) PARAMS ((const char *, unsigned long));
+
/* Number of entries in disassembler hash table. */
unsigned int dis_hash_table_size;
} CGEN_INSN_TABLE;
\f
/* Top level structures and functions. */
-typedef struct {
- CGEN_HW_ENTRY *hw_list;
- /*CGEN_OPERAND_TABLE *operand_table; - FIXME:wip */
- CGEN_INSN_TABLE *insn_table;
+typedef struct
+{
+ const CGEN_HW_ENTRY * hw_list;
+ /*CGEN_OPERAND_TABLE * operand_table; - FIXME:wip */
+ CGEN_INSN_TABLE * insn_table;
} CGEN_OPCODE_DATA;
/* Each CPU has one of these. */
/* Prototypes of major functions. */
-/* Set the current cpu (+ mach number, endian, etc.). *?
+/* Set the current cpu (+ mach number, endian, etc.). */
void cgen_set_cpu PARAMS ((CGEN_OPCODE_DATA *, int, enum cgen_endian));
/* Initialize the assembler, disassembler. */
void CGEN_SYM (init_print) PARAMS ((void));
void CGEN_SYM (init_insert) PARAMS ((void));
void CGEN_SYM (init_extract) PARAMS ((void));
+
+/* FIXME: This prototype is wrong ifndef CGEN_INT_INSN.
+ Furthermore, ifdef CGEN_INT_INSN, the insn is created in
+ target byte order (in which case why use int's at all).
+ Perhaps replace cgen_insn_t * with char *? */
const struct cgen_insn *
-CGEN_SYM (assemble_insn) PARAMS ((const char *, struct cgen_fields *,
+CGEN_SYM (assemble_insn) PARAMS ((const char *, CGEN_FIELDS *,
cgen_insn_t *, char **));
#if 0 /* old */
int CGEN_SYM (insn_supported) PARAMS ((const struct cgen_insn *));
extern const CGEN_KEYWORD CGEN_SYM (operand_mach);
int CGEN_SYM (get_mach) PARAMS ((const char *));
+const CGEN_INSN *
+CGEN_SYM (get_insn_operands) PARAMS ((const CGEN_INSN *, cgen_insn_t,
+ int, int *));
+const CGEN_INSN *
+CGEN_SYM (lookup_insn) PARAMS ((const CGEN_INSN *, cgen_insn_t,
+ int, CGEN_FIELDS *));
+
CGEN_INLINE void
CGEN_SYM (put_operand) PARAMS ((int, const long *,
- struct cgen_fields *));
+ CGEN_FIELDS *));
CGEN_INLINE long
-CGEN_SYM (get_operand) PARAMS ((int, const struct cgen_fields *));
+CGEN_SYM (get_operand) PARAMS ((int, const CGEN_FIELDS *));
CGEN_INLINE const char *
-CGEN_SYM (parse_operand) PARAMS ((int, const char **, struct cgen_fields *));
+CGEN_SYM (parse_operand) PARAMS ((int, const char **, CGEN_FIELDS *));
CGEN_INLINE const char *
-CGEN_SYM (validate_operand) PARAMS ((int, const struct cgen_fields *));
+CGEN_SYM (validate_operand) PARAMS ((int, const CGEN_FIELDS *));
/* Default insn parser, printer. */
extern cgen_parse_fn CGEN_SYM (parse_insn);
projects / deliverable / binutils-gdb.git / blobdiff