* cgen.h (*): Clean up pass over `struct foo' usage.

	(CGEN_ATTR): Make unsigned char.
	(CGEN_ATTR_TYPE): Update.
	(CGEN_ATTR_{ENTRY,TABLE}): New types.
	(cgen_base): Move member `attrs' to cgen_insn.
	(CGEN_KEYWORD): New member `null_entry'.
	(CGEN_{SYNTAX,FORMAT}): New types.
	(cgen_insn): Format and syntax separated from each other.

2 files changed, 247 insertions, 162 deletions

diff --git a/include/opcode/ChangeLog b/include/opcode/ChangeLog
index 81ae0a3..93878de 100644
--- a/include/opcode/ChangeLog
+++ b/include/opcode/ChangeLog
@@ -1,3 +1,14 @@
+Mon Jan 12 11:37:36 1998  Doug Evans  <devans@seba.cygnus.com>
+
+	* cgen.h (*): Clean up pass over `struct foo' usage.
+	(CGEN_ATTR): Make unsigned char.
+	(CGEN_ATTR_TYPE): Update.
+	(CGEN_ATTR_{ENTRY,TABLE}): New types.
+	(cgen_base): Move member `attrs' to cgen_insn.
+	(CGEN_KEYWORD): New member `null_entry'.
+	(CGEN_{SYNTAX,FORMAT}): New types.
+	(cgen_insn): Format and syntax separated from each other.
+
 start-sanitize-sky
 Mon Jan  5 13:33:21 1998  Doug Evans  <devans@seba.cygnus.com>
 
diff --git a/include/opcode/cgen.h b/include/opcode/cgen.h
index 932eb15..a436ee9 100644
--- a/include/opcode/cgen.h
+++ b/include/opcode/cgen.h
@@ -1,6 +1,6 @@
 /* Header file for targets using CGEN: Cpu tools GENerator.
 
-Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
 
 This file is part of GDB, the GNU debugger, and the GNU Binutils.
 
@@ -14,9 +14,9 @@ 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.  */
+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 CGEN_H
 #define CGEN_H
@@ -82,7 +82,7 @@ enum cgen_endian {
 
 /* Struct to record attribute information.  */
 typedef struct {
-  unsigned int num_nonbools;
+  unsigned char num_nonbools;
   unsigned int bool;
   unsigned int nonbool[1];
 } CGEN_ATTR;
@@ -94,7 +94,7 @@ typedef struct {
    nonbool: values of non-boolean attributes
    There is a maximum of 32 attributes total.  */
 #define CGEN_ATTR_TYPE(n) \
-const struct { unsigned int num_nonbools; \
+const struct { unsigned char num_nonbools; \
 	       unsigned int bool; \
 	       unsigned int nonbool[(n) ? (n) : 1]; }
 
@@ -108,6 +108,22 @@ const struct { unsigned int num_nonbools; \
 ((unsigned int) (attr) < (attr_table)->num_nonbools \
  ? ((attr_table)->nonbool[attr]) \
  : (((attr_table)->bool & (1 << (attr))) != 0))
+
+/* Attribute name/value tables.
+   These are used to assist parsing of descriptions at runtime.  */
+
+typedef struct {
+  const char *name;
+  int value;
+} CGEN_ATTR_ENTRY;
+
+/* For each domain (fld,operand,insn), list of attributes.  */
+
+typedef struct {
+  const char *name;
+  /* NULL for boolean attributes.  */
+  const CGEN_ATTR_ENTRY *vals;
+} CGEN_ATTR_TABLE;
 
 /* Parse result (also extraction result).
 
@@ -207,11 +223,12 @@ extern cgen_print_fn * CGEN_SYM (print_handlers) [];
 #define CGEN_PRINT_FN(x) (CGEN_SYM (print_handlers)[(x)->base.print])
 
 /* Base class of parser/printer.
-   (Don't read too much into the use of the phrase "base class").
+   (Don't read too much into the use of the phrase "base class".
+   It's a name I'm using to organize my thoughts.)
 
    Instructions and expressions all share this data in common.
-   It's a collection of the common elements needed to parse and print
-   each of them.  */
+   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
@@ -223,71 +240,81 @@ struct cgen_base {
      90% of them would be identical and that's a lot of redundant data.
      0 means use the default (what the default is is up to the code).  */
   unsigned char parse, insert, extract, print;
-
-  /* Attributes.  */
-  CGEN_ATTR_TYPE (CGEN_MAX_INSN_ATTRS) attrs;
 };
 
-/* Syntax table.
+/* Assembler interface.
 
-   Each insn and subexpression has one of these.
+   The interface to the assembler is intended to be clean in the sense that
+   libopcodes.a is a standalone entity and could be used with any assembler.
+   Not that one would necessarily want to do that but rather that it helps
+   keep a clean interface.  The interface will obviously be slanted towards
+   GAS, but at least it's a start.
 
-   The syntax "string" consists of characters (n > 0 && n < 128), and operand
-   values (n >= 128), and is terminated by 0.  Operand values are 128 + index
-   into the operand table.  The operand table doesn't exist in C, per se, as
-   the data is recorded in the parse/insert/extract/print switch statements.
+   Parsing is controlled by the assembler which calls
+   CGEN_SYM (assemble_insn).  If it can parse and build the entire insn
+   it doesn't call back to the assembler.  If it needs/wants to call back
+   to the assembler, (*cgen_parse_operand_fn) is called which can either
 
-   ??? Whether we want to use yacc instead is unclear, but we do make an
-   effort to not make doing that difficult.  At least that's the intent.
-*/
+   - return a number to be inserted in the insn
+   - return a "register" value to be inserted
+     (the register might not be a register per pe)
+   - queue the argument and return a marker saying the expression has been
+     queued (eg: a fix-up)
+   - return an error message indicating the expression wasn't recognizable
+
+   The result is an error message or NULL for success.
+   The parsed value is stored in the bfd_vma *.  */
 
-struct cgen_syntax {
-  /* Original syntax string, for debugging purposes.  */
-  char *orig;
+/* Values for indicating what the caller wants.  */
+enum cgen_parse_operand_type {
+  CGEN_PARSE_OPERAND_INIT, CGEN_PARSE_OPERAND_INTEGER,
+  CGEN_PARSE_OPERAND_ADDRESS
+};
 
-  /* Name of entry (that distinguishes it from all other entries).
-     This is used, for example, in simulator profiling results.  */
-  char *name;
+/* 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
+};
 
-#if 0 /* not needed yet */
-  /* Format of this insn.
-     This doesn't closely follow the notion of instruction formats for more
-     complex instruction sets.  This is the value computed at runtime.  */
-  enum cgen_fmt_type fmt;
+/* Don't require bfd.h unnecessarily.  */
+#ifdef BFD_VERSION
+extern const char * (*cgen_parse_operand_fn)
+     PARAMS ((enum cgen_parse_operand_type, const char **, int, int,
+	      enum cgen_parse_operand_result *, bfd_vma *));
 #endif
 
-  /* Mnemonic (or name if expression).  */
-  char *mnemonic;
+/* Called before trying to match a table entry with the insn.  */
+void cgen_init_parse_operand PARAMS ((void));
 
-  /* Syntax string.  */
-  /* FIXME: If each insn's mnemonic is constant, do we want to record just
-     the arguments here?  */
-#ifndef CGEN_MAX_SYNTAX_BYTES
-#define CGEN_MAX_SYNTAX_BYTES 16
-#endif
-  unsigned char syntax[CGEN_MAX_SYNTAX_BYTES];
+/* Called from <cpu>-asm.c to initialize operand parsing.  */
 
-#define CGEN_SYNTAX_CHAR_P(c) ((c) < 128)
-#define CGEN_SYNTAX_CHAR(c) (c)
-#define CGEN_SYNTAX_FIELD(c) ((c) - 128)
+/* These are GAS specific.  They're not here as part of the interface,
+   but rather that we need to put them somewhere.  */
 
-  /* recognize insn if (op & mask) == value
-     For architectures with variable length insns, this is just a preliminary
-     test.  */
-  /* FIXME: Might want a selectable type (rather than always
-     unsigned long).  */
-  unsigned long mask, value;
+/* Call this from md_assemble to initialize the assembler callback.  */
+void cgen_asm_init_parse PARAMS ((void));
 
-  /* length, in bits
-     This is the size that `mask' and `value' have been calculated to.
-     Normally it is CGEN_BASE_INSN_BITSIZE.  On vliw architectures where
-     the base insn size may be larger than the size of an insn, this field is
-     less than CGEN_BASE_INSN_BITSIZE.
-     On architectures like the 386 and m68k the real size of the insn may
-     be computed while parsing.  */
-  /* FIXME: wip, of course */
-  int length;
-};
+/* 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 *));
+#endif
+
+/* 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 *,
+				   unsigned int));
 
 /* Operand values (keywords, integers, symbols, etc.)  */
 
@@ -325,7 +352,13 @@ typedef struct cgen_keyword_entry {
      IDEA: Have "FUNCTION" attribute? [function is called to fetch value].  */
   int value;
 
-  /* Attributes.  */
+  /* Attributes.
+     This should, but technically needn't, 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.  */
+  /* ??? 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;
 
@@ -340,61 +373,63 @@ typedef struct cgen_keyword_entry {
 
    This struct supports runtime entry of new values, and hashed lookups.  */
 
-typedef struct cgen_keyword {
+typedef struct {
   /* Pointer to initial [compiled in] values.  */
-  struct 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.  */
-  struct cgen_keyword_entry **name_hash_table;
+  CGEN_KEYWORD_ENTRY **name_hash_table;
   /* Hash table used for value lookup.  */
-  struct 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;
 } CGEN_KEYWORD;
 
 /* Structure used for searching.  */
 
-typedef struct cgen_keyword_search {
+typedef struct {
   /* Table being searched.  */
-  const struct cgen_keyword *table;
+  const CGEN_KEYWORD *table;
   /* Specification of what is being searched for.  */
   const char *spec;
   /* Current index in hash table.  */
   unsigned int current_hash;
   /* Current element in current hash chain.  */
-  struct cgen_keyword_entry *current_entry;
+  CGEN_KEYWORD_ENTRY *current_entry;
 } CGEN_KEYWORD_SEARCH;
 
 /* Lookup a keyword from its name.  */
-const struct cgen_keyword_entry * cgen_keyword_lookup_name
-  PARAMS ((struct cgen_keyword *, const char *));
+const CGEN_KEYWORD_ENTRY * cgen_keyword_lookup_name
+  PARAMS ((CGEN_KEYWORD *, const char *));
 /* Lookup a keyword from its value.  */
-const struct cgen_keyword_entry * cgen_keyword_lookup_value
-  PARAMS ((struct cgen_keyword *, int));
+const CGEN_KEYWORD_ENTRY * cgen_keyword_lookup_value
+  PARAMS ((CGEN_KEYWORD *, int));
 /* Add a keyword.  */
-void cgen_keyword_add PARAMS ((struct cgen_keyword *,
-			       struct cgen_keyword_entry *));
+void cgen_keyword_add PARAMS ((CGEN_KEYWORD *, CGEN_KEYWORD_ENTRY *));
 /* Keyword searching.
    This can be used to retrieve every keyword, or a subset.  */
-struct cgen_keyword_search cgen_keyword_search_init
-  PARAMS ((struct cgen_keyword *, const char *));
-const struct cgen_keyword_entry *cgen_keyword_search_next
-  PARAMS ((struct cgen_keyword_search *));
+CGEN_KEYWORD_SEARCH cgen_keyword_search_init
+  PARAMS ((CGEN_KEYWORD *, const char *));
+const CGEN_KEYWORD_ENTRY *cgen_keyword_search_next
+  PARAMS ((CGEN_KEYWORD_SEARCH *));
 
 /* Operand value support routines.  */
 /* FIXME: some of the long's here will need to be bfd_vma or some such.  */
 
 const char * cgen_parse_keyword PARAMS ((const char **,
-					 struct cgen_keyword *,
+					 CGEN_KEYWORD *,
 					 long *));
 const char * cgen_parse_signed_integer PARAMS ((const char **, int,
 						long, long, long *));
 const char * cgen_parse_unsigned_integer PARAMS ((const char **, int,
 						  unsigned long, unsigned long,
 						  unsigned long *));
-const char * cgen_parse_address PARAMS ((const char **, int,
-					 int, long *));
+const char * cgen_parse_address PARAMS ((const char **, int, int,
+					 enum cgen_parse_operand_result *,
+					 long *));
 const char * cgen_validate_signed_integer PARAMS ((long, long, long));
 const char * cgen_validate_unsigned_integer PARAMS ((unsigned long,
 						     unsigned long,
@@ -406,27 +441,33 @@ const char * cgen_validate_unsigned_integer PARAMS ((unsigned long,
 #define CGEN_MAX_OPERAND_ATTRS 1
 #endif
 
-typedef struct cgen_operand {
-  /* For debugging.  */
+typedef struct {
+  /* Name as it appears in the syntax string.  */
   char *name;
 
   /* Bit position (msb of first byte = bit 0).
+     This is just a hint, and may be unused in more complex operands.
      May be unused for a modifier.  */
   unsigned char start;
 
   /* The number of bits in the operand.
+     This is just a hint, and may be unused in more complex operands.
      May be unused for a modifier.  */
   unsigned char length;
 
-  /* Attributes.  */
-  CGEN_ATTR_TYPE (CGEN_MAX_OPERAND_ATTRS) attrs;
-#define CGEN_OPERAND_ATTRS(operand) (&(operand)->attrs)
-
-#if 0 /* ??? Interesting idea but relocs tend to get too complicated for
-	 simple table lookups to work.  */
+#if 0 /* ??? Interesting idea but relocs tend to get too complicated,
+	 and ABI dependent, for simple table lookups to work.  */
   /* Ideally this would be the internal (external?) reloc type.  */
   int reloc_type;
 #endif
+
+  /* Attributes.
+     This should, but technically needn't, 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, now or tomorrow.  */
+  CGEN_ATTR_TYPE (CGEN_MAX_OPERAND_ATTRS) attrs;
+#define CGEN_OPERAND_ATTRS(operand) (&(operand)->attrs)
 } CGEN_OPERAND;
 
 /* Return value of attribute ATTR in OPERAND.  */
@@ -443,41 +484,132 @@ enum cgen_operand_type;
 #define CGEN_OPERAND_TYPE(operand) ((enum cgen_operand_type) CGEN_OPERAND_INDEX (operand))
 #define CGEN_OPERAND_ENTRY(n) (& CGEN_SYM (operand_table) [n])
 
+/* Syntax string.
+
+   Each insn format and subexpression has one of these.
+
+   The syntax "string" consists of characters (n > 0 && n < 128), and operand
+   values (n >= 128), and is terminated by 0.  Operand values are 128 + index
+   into the operand table.  The operand table doesn't exist in C, per se, as
+   the data is recorded in the parse/insert/extract/print switch statements. */
+
+#ifndef CGEN_MAX_SYNTAX_BYTES
+#define CGEN_MAX_SYNTAX_BYTES 16
+#endif
+
+typedef struct {
+  unsigned char syntax[CGEN_MAX_SYNTAX_BYTES];
+} CGEN_SYNTAX;
+
+#define CGEN_SYNTAX_STRING(syn) (syn->syntax)
+#define CGEN_SYNTAX_CHAR_P(c) ((c) < 128)
+#define CGEN_SYNTAX_CHAR(c) (c)
+#define CGEN_SYNTAX_FIELD(c) ((c) - 128)
+
+/* ??? I can't currently think of any case where the mnemonic doesn't come
+   first [and if one ever doesn't building the hash tables will be tricky].
+   However, we treat mnemonics as just another operand of the instruction.
+   A value of 1 means "this is where the mnemonic appears".  1 isn't
+   special other than it's a non-printable ASCII char.  */
+#define CGEN_SYNTAX_MNEMONIC_P(ch) ((ch) == 1)
+
+/* Instruction formats.
+
+   Instructions are grouped by format.  Associated with an instruction is its
+   format.  Each opcode table entry contains a pointer into the format table.
+   This cuts down on the size of the opcode table as there are relatively few
+   formats compared with the number of instructions.  */
+
+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
+     the base insn size may be larger than the size of an insn, this field is
+     less than CGEN_BASE_INSN_BITSIZE.  */
+  unsigned char mask_length;
+
+  /* Total length of instruction.  */
+  unsigned char length;
+
+  /* Mask to apply to the first BASE_LENGTH bits.
+     Each insn's value is stored with the insn.
+     The first step in recognizing an insn for disassembly is
+     (opcode & mask) == value.  */
+  unsigned int mask;
+} CGEN_FORMAT;
+
 /* This struct defines each entry in the instruction table.  */
 
 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)
-#define CGEN_INSN_ATTRS(insn) (&(insn)->base.attrs)
-
-  struct cgen_syntax syntax;
-#define CGEN_INSN_SYNTAX(insn) (&(insn)->syntax)
-#define CGEN_INSN_FMT(insn) ((insn)->syntax.fmt)
-#define CGEN_INSN_BITSIZE(insn) ((insn)->syntax.length)
-};
 
+  /* 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;
+#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;
+#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;
+#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;
+#define CGEN_INSN_MASK_BITSIZE(insn) (((CGEN_FORMAT *) (insn)->format)->mask_length)
+#define CGEN_INSN_BITSIZE(insn) (((CGEN_FORMAT *) (insn)->format)->length)
+
+  /* Instruction opcode value.  */
+  unsigned int value;
+#define CGEN_INSN_VALUE(insn) ((insn)->value)
+#define CGEN_INSN_MASK(insn) (((CGEN_FORMAT *) (insn)->format)->mask)
+
+  /* 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;
+#define CGEN_INSN_ATTRS(insn) (&(insn)->attrs)
 /* Return value of attribute ATTR in INSN.  */
 #define CGEN_INSN_ATTR(insn, attr) \
 CGEN_ATTR_VALUE (insn, CGEN_INSN_ATTRS (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 struct cgen_insn *insn;
+  const CGEN_INSN *insn;
 } CGEN_INSN_LIST;
 
 /* The table of instructions.  */
 
-typedef struct cgen_insn_table {
+typedef struct {
   /* Pointer to initial [compiled in] entries.  */
-  const struct 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.  */
-  struct cgen_insn_list *new_entries;
+  CGEN_INSN_LIST *new_entries;
   /* Assembler hash function.  */
   unsigned int (*asm_hash) PARAMS ((const char *));
   /* Number of entries in assembler hash table.  */
@@ -498,7 +630,7 @@ extern const CGEN_INSN CGEN_SYM (insn_table_entries)[];
 
 /* Return number of instructions.  This includes any added at runtime.  */
 
-int cgen_insn_count PARAMS (());
+int cgen_insn_count PARAMS ((void));
 
 /* The assembler insn table is hashed based on some function of the mnemonic
    (the actually hashing done is up to the target, but we provide a few
@@ -541,7 +673,7 @@ CGEN_INSN_LIST * cgen_dis_lookup_insn PARAMS ((const char *, unsigned long));
 
 /* Top level structures and functions.  */
 
-typedef struct cgen_opcode_data {
+typedef struct {
   CGEN_HW_ENTRY *hw_list;
   /*CGEN_OPERAND_TABLE *operand_table; - FIXME:wip */
   CGEN_INSN_TABLE *insn_table;
@@ -580,12 +712,12 @@ void CGEN_SYM (init_extract) PARAMS ((void));
 const struct cgen_insn *
 CGEN_SYM (assemble_insn) PARAMS ((const char *, struct cgen_fields *,
 				  cgen_insn_t *, char **));
-int CGEN_SYM (insn_supported) PARAMS ((const struct cgen_syntax *));
 #if 0 /* old */
+int CGEN_SYM (insn_supported) PARAMS ((const struct cgen_insn *));
 int CGEN_SYM (opval_supported) PARAMS ((const struct cgen_opval *));
 #endif
 
-extern const struct cgen_keyword  CGEN_SYM (operand_mach);
+extern const CGEN_KEYWORD  CGEN_SYM (operand_mach);
 int CGEN_SYM (get_mach) PARAMS ((const char *));
 
 CGEN_INLINE void
@@ -608,63 +740,5 @@ extern cgen_print_fn CGEN_SYM (print_insn);
 
 /* Read in a cpu description file.  */
 const char * cgen_read_cpu_file PARAMS ((const char *));
-
-/* Assembler interface.
-
-   The interface to the assembler is intended to be clean in the sense that
-   libopcodes.a is a standalone entity and could be used with any assembler.
-   Not that one would necessarily want to do that but rather that it helps
-   keep a clean interface.  The interface will obviously be slanted towards
-   GAS, but at least it's a start.
-
-   Parsing is controlled by the assembler which calls
-   CGEN_SYM (assemble_insn).  If it can parse and build the entire insn
-   it doesn't call back to the assembler.  If it needs/wants to call back
-   to the assembler, (*cgen_asm_parse_operand_fn) is called which can either
-
-   - return a number to be inserted in the insn
-   - return a "register" value to be inserted
-     (the register might not be a register per pe)
-   - queue the argument and return a marker saying the expression has been
-     queued (eg: a fix-up)
-   - return an error message indicating the expression wasn't recognizable
-
-   The result is an error message or NULL for success.
-   The parsed value is stored in the bfd_vma *.  */
-
-enum cgen_asm_result {
-  CGEN_ASM_NUMBER, CGEN_ASM_REGISTER, CGEN_ASM_QUEUED, CGEN_ASM_ERROR
-};
-
-/* Don't require bfd.h unnecessarily.  */
-#ifdef BFD_VERSION
-extern const char * (*cgen_asm_parse_operand_fn)
-     PARAMS ((const char **, int, int, enum cgen_asm_result *, bfd_vma *));
-#endif
-
-/* These are GAS specific.  They're not here as part of the interface,
-   but rather that we need to put them somewhere.  */
-
-/* Call this for each insn to initialize the assembler callback interface.  */
-void cgen_asm_init_parse PARAMS ((void));
-
-/* 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_asm_parse_operand PARAMS ((const char **, int, int,
-					    enum cgen_asm_result *,
-					    bfd_vma *));
-#endif
-
-/* 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 *,
-				   unsigned int));
 
 #endif /* CGEN_H */