1 /* Header file for targets using CGEN: Cpu tools GENerator.
3 Copyright (C) 1996, 1997 Free Software Foundation, Inc.
5 This file is part of GDB, the GNU debugger, and the GNU Binutils.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 #if defined(__STDC__) || defined(ALMOST_STDC)
26 #define CGEN_XCAT3(a,b,c) a ## b ## c
27 #define CGEN_CAT3(a,b,c) CGEN_XCAT3 (a, b, c)
29 #define CGEN_CAT3(a,b,c) a/**/b/**/c
33 /* Prepend the cpu name, defined in cpu-opc.h, and _cgen_ to symbol S.
34 The lack of spaces in the arg list is important for non-stdc systems.
35 This file is included by <cpu>-opc.h.
36 It can be included independently of cpu-opc.h, in which case the cpu
37 dependent portions will be declared as "unknown_cgen_foo". */
40 #define CGEN_SYM(s) CGEN_CAT3 (unknown,_cgen_,s)
43 /* This file contains the static (unchanging) pieces and as much other stuff
44 as we can reasonably put here. It's generally cleaner to put stuff here
45 rather than having it machine generated if possible. */
47 /* The assembler syntax is made up of expressions (duh...).
48 At the lowest level the values are mnemonics, register names, numbers, etc.
49 Above that are subexpressions, if any (an example might be the
50 "effective address" in m68k cpus). At the second highest level are the
51 insns themselves. Above that are pseudo-insns, synthetic insns, and macros,
55 /* Lots of cpu's have a fixed insn size, or one which rarely changes,
56 and it's generally easier to handle these by treating the insn as an
57 integer type, rather than an array of characters. So we allow targets
61 typedef unsigned int cgen_insn_t
;
63 typedef char *cgen_insn_t
;
67 #define CGEN_INLINE inline
72 /* Perhaps we should just use bfd.h, but it's not clear
73 one would want to require that yet. */
81 Attributes are used to describe various random things. */
83 /* Struct to record attribute information. */
85 unsigned int num_nonbools
;
87 unsigned int nonbool
[1];
90 /* Define a structure member for attributes with N non-boolean entries.
91 The attributes are sorted so that the non-boolean ones come first.
92 num_nonbools: count of nonboolean attributes
93 bool: values of boolean attributes
94 nonbool: values of non-boolean attributes
95 There is a maximum of 32 attributes total. */
96 #define CGEN_ATTR_TYPE(n) \
97 const struct { unsigned int num_nonbools; \
99 unsigned int nonbool[(n) ? (n) : 1]; }
101 /* Given an attribute number, return its mask. */
102 #define CGEN_ATTR_MASK(attr) (1 << (attr))
104 /* Return value of attribute ATTR in ATTR_TABLE for OBJ.
105 OBJ is a pointer to the entity that has the attributes.
106 It's not used at present but is reserved for future purposes. */
107 #define CGEN_ATTR_VALUE(obj, attr_table, attr) \
108 ((unsigned int) (attr) < (attr_table)->num_nonbools \
109 ? ((attr_table)->nonbool[attr]) \
110 : (((attr_table)->bool & (1 << (attr))) != 0))
112 /* Parse result (also extraction result).
114 The result of parsing an insn is stored here.
115 To generate the actual insn, this is passed to the insert handler.
116 When printing an insn, the result of extraction is stored here.
117 To print the insn, this is passed to the print handler.
119 It is machine generated so we don't define it here,
120 but we do need a forward decl for the handler fns.
122 There is one member for each possible field in the insn.
123 The type depends on the field.
124 Also recorded here is the computed length of the insn for architectures
130 /* Total length of the insn, as recorded in the `fields' struct. */
131 /* ??? The field insert handler has lots of opportunities for optimization
132 if it ever gets inlined. On architectures where insns all have the same
133 size, may wish to detect that and make this macro a constant - to allow
134 further optimizations. */
135 #define CGEN_FIELDS_BITSIZE(fields) ((fields)->length)
137 /* Associated with each insn or expression is a set of "handlers" for
138 performing operations like parsing, printing, etc. */
141 typedef struct cgen_insn CGEN_INSN
;
144 The first argument is a pointer to a struct describing the insn being
146 The second argument is a pointer to a pointer to the text being parsed.
147 The third argument is a pointer to a cgen_fields struct
148 in which the results are placed.
149 If the expression is successfully parsed, the pointer to the text is
150 updated. If not it is left alone.
151 The result is NULL if success or an error message. */
152 typedef const char * (cgen_parse_fn
) PARAMS ((const struct cgen_insn
*,
154 struct cgen_fields
*));
157 The first argument is a pointer to the disassembly info.
158 Eg: disassemble_info. It's defined as `PTR' so this file can be included
160 The second argument is a pointer to a struct describing the insn being
162 The third argument is a pointer to a cgen_fields struct.
163 The fourth argument is the pc value of the insn.
164 The fifth argument is the length of the insn, in bytes. */
165 /* Don't require bfd.h unnecessarily. */
167 typedef void (cgen_print_fn
) PARAMS ((PTR
, const struct cgen_insn
*,
168 struct cgen_fields
*, bfd_vma
, int));
170 typedef void (cgen_print_fn
) ();
174 The first argument is a pointer to a struct describing the insn being
176 The second argument is a pointer to a cgen_fields struct
177 from which the values are fetched.
178 The third argument is a pointer to a buffer in which to place the insn. */
179 typedef void (cgen_insert_fn
) PARAMS ((const struct cgen_insn
*,
180 struct cgen_fields
*, cgen_insn_t
*));
183 The first argument is a pointer to a struct describing the insn being
185 The second argument is a pointer to a struct controlling extraction
186 (only used for variable length insns).
187 The third argument is the first CGEN_BASE_INSN_SIZE bytes.
188 The fourth argument is a pointer to a cgen_fields struct
189 in which the results are placed.
190 The result is the length of the insn or zero if not recognized. */
191 typedef int (cgen_extract_fn
) PARAMS ((const struct cgen_insn
*,
193 struct cgen_fields
*));
195 /* The `parse' and `insert' fields are indices into these tables.
196 The elements are pointer to specialized handler functions.
197 Element 0 is special, it means use the default handler. */
198 extern cgen_parse_fn
* CGEN_SYM (parse_handlers
) [];
199 #define CGEN_PARSE_FN(x) (CGEN_SYM (parse_handlers)[(x)->base.parse])
200 extern cgen_insert_fn
* CGEN_SYM (insert_handlers
) [];
201 #define CGEN_INSERT_FN(x) (CGEN_SYM (insert_handlers)[(x)->base.insert])
203 /* Likewise for the `extract' and `print' fields. */
204 extern cgen_extract_fn
* CGEN_SYM (extract_handlers
) [];
205 #define CGEN_EXTRACT_FN(x) (CGEN_SYM (extract_handlers)[(x)->base.extract])
206 extern cgen_print_fn
* CGEN_SYM (print_handlers
) [];
207 #define CGEN_PRINT_FN(x) (CGEN_SYM (print_handlers)[(x)->base.print])
209 /* Base class of parser/printer.
210 (Don't read too much into the use of the phrase "base class").
212 Instructions and expressions all share this data in common.
213 It's a collection of the common elements needed to parse and print
216 #ifndef CGEN_MAX_INSN_ATTRS
217 #define CGEN_MAX_INSN_ATTRS 1
221 /* Indices into the handler tables.
222 We could use pointers here instead, but in the case of the insn table,
223 90% of them would be identical and that's a lot of redundant data.
224 0 means use the default (what the default is is up to the code). */
225 unsigned char parse
, insert
, extract
, print
;
228 CGEN_ATTR_TYPE (CGEN_MAX_INSN_ATTRS
) attrs
;
233 Each insn and subexpression has one of these.
235 The syntax "string" consists of characters (n > 0 && n < 128), and operand
236 values (n >= 128), and is terminated by 0. Operand values are 128 + index
237 into the operand table. The operand table doesn't exist in C, per se, as
238 the data is recorded in the parse/insert/extract/print switch statements.
240 ??? Whether we want to use yacc instead is unclear, but we do make an
241 effort to not make doing that difficult. At least that's the intent.
245 /* Original syntax string, for debugging purposes. */
248 /* Name of entry (that distinguishes it from all other entries).
249 This is used, for example, in simulator profiling results. */
252 #if 0 /* not needed yet */
253 /* Format of this insn.
254 This doesn't closely follow the notion of instruction formats for more
255 complex instruction sets. This is the value computed at runtime. */
256 enum cgen_fmt_type fmt
;
259 /* Mnemonic (or name if expression). */
263 /* FIXME: If each insn's mnemonic is constant, do we want to record just
264 the arguments here? */
265 #ifndef CGEN_MAX_SYNTAX_BYTES
266 #define CGEN_MAX_SYNTAX_BYTES 16
268 unsigned char syntax
[CGEN_MAX_SYNTAX_BYTES
];
270 #define CGEN_SYNTAX_CHAR_P(c) ((c) < 128)
271 #define CGEN_SYNTAX_CHAR(c) (c)
272 #define CGEN_SYNTAX_FIELD(c) ((c) - 128)
274 /* recognize insn if (op & mask) == value
275 For architectures with variable length insns, this is just a preliminary
277 /* FIXME: Might want a selectable type (rather than always
279 unsigned long mask
, value
;
282 This is the size that `mask' and `value' have been calculated to.
283 Normally it is CGEN_BASE_INSN_BITSIZE. On vliw architectures where
284 the base insn size may be larger than the size of an insn, this field is
285 less than CGEN_BASE_INSN_BITSIZE.
286 On architectures like the 386 and m68k the real size of the insn may
287 be computed while parsing. */
288 /* FIXME: wip, of course */
292 /* Operand values (keywords, integers, symbols, etc.) */
294 /* Types of assembler elements. */
297 CGEN_ASM_KEYWORD
, CGEN_ASM_MAX
300 /* List of hardware elements. */
302 typedef struct cgen_hw_entry
{
303 struct cgen_hw_entry
*next
;
305 enum cgen_asm_type asm_type
;
309 extern CGEN_HW_ENTRY
*CGEN_SYM (hw_list
);
311 CGEN_HW_ENTRY
*cgen_hw_lookup
PARAMS ((const char *));
313 #ifndef CGEN_MAX_KEYWORD_ATTRS
314 #define CGEN_MAX_KEYWORD_ATTRS 1
317 /* This struct is used to describe things like register names, etc. */
319 typedef struct cgen_keyword_entry
{
320 /* Name (as in register name). */
323 /* Value (as in register number).
324 The value cannot be -1 as that is used to indicate "not found".
325 IDEA: Have "FUNCTION" attribute? [function is called to fetch value]. */
329 /* FIXME: Not used yet. */
330 CGEN_ATTR_TYPE (CGEN_MAX_KEYWORD_ATTRS
) attrs
;
332 /* Next name hash table entry. */
333 struct cgen_keyword_entry
*next_name
;
334 /* Next value hash table entry. */
335 struct cgen_keyword_entry
*next_value
;
336 } CGEN_KEYWORD_ENTRY
;
338 /* Top level struct for describing a set of related keywords
339 (e.g. register names).
341 This struct supports runtime entry of new values, and hashed lookups. */
343 typedef struct cgen_keyword
{
344 /* Pointer to initial [compiled in] values. */
345 struct cgen_keyword_entry
*init_entries
;
346 /* Number of entries in `init_entries'. */
347 unsigned int num_init_entries
;
348 /* Hash table used for name lookup. */
349 struct cgen_keyword_entry
**name_hash_table
;
350 /* Hash table used for value lookup. */
351 struct cgen_keyword_entry
**value_hash_table
;
352 /* Number of entries in the hash_tables. */
353 unsigned int hash_table_size
;
356 /* Structure used for searching. */
358 typedef struct cgen_keyword_search
{
359 /* Table being searched. */
360 const struct cgen_keyword
*table
;
361 /* Specification of what is being searched for. */
363 /* Current index in hash table. */
364 unsigned int current_hash
;
365 /* Current element in current hash chain. */
366 struct cgen_keyword_entry
*current_entry
;
367 } CGEN_KEYWORD_SEARCH
;
369 /* Lookup a keyword from its name. */
370 const struct cgen_keyword_entry
* cgen_keyword_lookup_name
371 PARAMS ((struct cgen_keyword
*, const char *));
372 /* Lookup a keyword from its value. */
373 const struct cgen_keyword_entry
* cgen_keyword_lookup_value
374 PARAMS ((struct cgen_keyword
*, int));
376 void cgen_keyword_add
PARAMS ((struct cgen_keyword
*,
377 struct cgen_keyword_entry
*));
378 /* Keyword searching.
379 This can be used to retrieve every keyword, or a subset. */
380 struct cgen_keyword_search cgen_keyword_search_init
381 PARAMS ((struct cgen_keyword
*, const char *));
382 const struct cgen_keyword_entry
*cgen_keyword_search_next
383 PARAMS ((struct cgen_keyword_search
*));
385 /* Operand value support routines. */
386 /* FIXME: some of the long's here will need to be bfd_vma or some such. */
388 const char * cgen_parse_keyword
PARAMS ((const char **,
389 struct cgen_keyword
*,
391 const char * cgen_parse_signed_integer
PARAMS ((const char **, int,
392 long, long, long *));
393 const char * cgen_parse_unsigned_integer
PARAMS ((const char **, int,
394 unsigned long, unsigned long,
396 const char * cgen_parse_address
PARAMS ((const char **, int,
398 const char * cgen_validate_signed_integer
PARAMS ((long, long, long));
399 const char * cgen_validate_unsigned_integer
PARAMS ((unsigned long,
403 /* This struct defines each entry in the operand table. */
405 #ifndef CGEN_MAX_OPERAND_ATTRS
406 #define CGEN_MAX_OPERAND_ATTRS 1
409 typedef struct cgen_operand
{
413 /* Bit position (msb of first byte = bit 0).
414 May be unused for a modifier. */
417 /* The number of bits in the operand.
418 May be unused for a modifier. */
419 unsigned char length
;
422 CGEN_ATTR_TYPE (CGEN_MAX_OPERAND_ATTRS
) attrs
;
423 #define CGEN_OPERAND_ATTRS(operand) (&(operand)->attrs)
425 #if 0 /* ??? Interesting idea but relocs tend to get too complicated for
426 simple table lookups to work. */
427 /* Ideally this would be the internal (external?) reloc type. */
432 /* Return value of attribute ATTR in OPERAND. */
433 #define CGEN_OPERAND_ATTR(operand, attr) \
434 CGEN_ATTR_VALUE (operand, CGEN_OPERAND_ATTRS (operand), attr)
436 /* The operand table is currently a very static entity. */
437 extern const CGEN_OPERAND
CGEN_SYM (operand_table
)[];
439 enum cgen_operand_type
;
441 #define CGEN_OPERAND_INDEX(operand) ((int) ((operand) - CGEN_SYM (operand_table)))
442 /* FIXME: Rename, cpu-opc.h defines this as the typedef of the enum. */
443 #define CGEN_OPERAND_TYPE(operand) ((enum cgen_operand_type) CGEN_OPERAND_INDEX (operand))
444 #define CGEN_OPERAND_ENTRY(n) (& CGEN_SYM (operand_table) [n])
446 /* This struct defines each entry in the instruction table. */
449 struct cgen_base base
;
450 /* Given a pointer to a cgen_insn struct, return a pointer to `base'. */
451 #define CGEN_INSN_BASE(insn) (&(insn)->base)
452 #define CGEN_INSN_ATTRS(insn) (&(insn)->base.attrs)
454 struct cgen_syntax syntax
;
455 #define CGEN_INSN_SYNTAX(insn) (&(insn)->syntax)
456 #define CGEN_INSN_FMT(insn) ((insn)->syntax.fmt)
457 #define CGEN_INSN_BITSIZE(insn) ((insn)->syntax.length)
460 /* Return value of attribute ATTR in INSN. */
461 #define CGEN_INSN_ATTR(insn, attr) \
462 CGEN_ATTR_VALUE (insn, CGEN_INSN_ATTRS (insn), attr)
464 /* Instruction lists.
465 This is used for adding new entries and for creating the hash lists. */
467 typedef struct cgen_insn_list
{
468 struct cgen_insn_list
*next
;
469 const struct cgen_insn
*insn
;
472 /* The table of instructions. */
474 typedef struct cgen_insn_table
{
475 /* Pointer to initial [compiled in] entries. */
476 const struct cgen_insn
*init_entries
;
477 /* Number of entries in `init_entries', including trailing NULL entry. */
478 unsigned int num_init_entries
;
479 /* Values added at runtime. */
480 struct cgen_insn_list
*new_entries
;
481 /* Assembler hash function. */
482 unsigned int (*asm_hash
) PARAMS ((const char *));
483 /* Number of entries in assembler hash table. */
484 unsigned int asm_hash_table_size
;
485 /* Disassembler hash function. */
486 unsigned int (*dis_hash
) PARAMS ((const char *, unsigned long));
487 /* Number of entries in disassembler hash table. */
488 unsigned int dis_hash_table_size
;
491 /* ??? This is currently used by the simulator.
492 We want this to be fast and the simulator currently doesn't handle
493 runtime added instructions so this is ok. An alternative would be to
494 store the index in the table. */
495 extern const CGEN_INSN
CGEN_SYM (insn_table_entries
)[];
496 #define CGEN_INSN_INDEX(insn) ((int) ((insn) - CGEN_SYM (insn_table_entries)))
497 #define CGEN_INSN_ENTRY(n) (& CGEN_SYM (insn_table_entries) [n])
499 /* Return number of instructions. This includes any added at runtime. */
501 int cgen_insn_count
PARAMS (());
503 /* The assembler insn table is hashed based on some function of the mnemonic
504 (the actually hashing done is up to the target, but we provide a few
505 examples like the first letter or a function of the entire mnemonic).
506 The index of each entry is the index of the corresponding table entry.
507 The value of each entry is the index of the next entry, with a 0
508 terminating (thus the first entry is reserved). */
510 #ifndef CGEN_ASM_HASH
511 #ifdef CGEN_MNEMONIC_OPERANDS
512 #define CGEN_ASM_HASH_SIZE 127
513 #define CGEN_ASM_HASH(string) (*(unsigned char *) (string) % CGEN_ASM_HASH_SIZE)
515 #define CGEN_ASM_HASH_SIZE 128
516 #define CGEN_ASM_HASH(string) (*(unsigned char *) (string) % CGEN_ASM_HASH_SIZE) /*FIXME*/
520 unsigned int CGEN_SYM (asm_hash_insn
) PARAMS ((const char *));
521 CGEN_INSN_LIST
* cgen_asm_lookup_insn
PARAMS ((const char *));
522 #define CGEN_ASM_LOOKUP_INSN(insn) cgen_asm_lookup_insn (insn)
523 #define CGEN_ASM_NEXT_INSN(insn) ((insn)->next)
525 /* The disassembler insn table is hashed based on some function of machine
526 instruction (the actually hashing done is up to the target). */
528 /* It doesn't make much sense to provide a default here,
529 but while this is under development we do.
530 BUFFER is a pointer to the bytes of the insn.
531 INSN is the first CGEN_BASE_INSN_SIZE bytes as an int in host order. */
532 #ifndef CGEN_DIS_HASH
533 #define CGEN_DIS_HASH_SIZE 256
534 #define CGEN_DIS_HASH(buffer, insn) (*(unsigned char *) (buffer))
537 unsigned int CGEN_SYM (dis_hash_insn
) PARAMS ((const char *, unsigned long));
538 CGEN_INSN_LIST
* cgen_dis_lookup_insn
PARAMS ((const char *, unsigned long));
539 #define CGEN_DIS_LOOKUP_INSN(buf, insn) cgen_dis_lookup_insn (buf, insn)
540 #define CGEN_DIS_NEXT_INSN(insn) ((insn)->next)
542 /* Top level structures and functions. */
544 typedef struct cgen_opcode_data
{
545 CGEN_HW_ENTRY
*hw_list
;
546 /*CGEN_OPERAND_TABLE *operand_table; - FIXME:wip */
547 CGEN_INSN_TABLE
*insn_table
;
550 /* Each CPU has one of these. */
551 extern CGEN_OPCODE_DATA
CGEN_SYM (opcode_data
);
553 /* Global state access macros.
554 Some of these are tucked away and accessed with cover fns.
555 Simpler things like the current machine and endian are not. */
557 extern int cgen_current_machine
;
558 #define CGEN_CURRENT_MACHINE cgen_current_machine
560 extern enum cgen_endian cgen_current_endian
;
561 #define CGEN_CURRENT_ENDIAN cgen_current_endian
563 /* Prototypes of major functions. */
565 /* Set the current cpu (+ mach number, endian, etc.). *?
566 void cgen_set_cpu PARAMS ((CGEN_OPCODE_DATA *, int, enum cgen_endian));
568 /* Initialize the assembler, disassembler. */
569 void cgen_asm_init
PARAMS ((void));
570 void cgen_dis_init
PARAMS ((void));
572 /* `init_tables' must be called before `xxx_supported'. */
573 void CGEN_SYM (init_tables
) PARAMS ((int));
574 void CGEN_SYM (init_asm
) PARAMS ((int, enum cgen_endian
));
575 void CGEN_SYM (init_dis
) PARAMS ((int, enum cgen_endian
));
576 void CGEN_SYM (init_parse
) PARAMS ((void));
577 void CGEN_SYM (init_print
) PARAMS ((void));
578 void CGEN_SYM (init_insert
) PARAMS ((void));
579 void CGEN_SYM (init_extract
) PARAMS ((void));
580 const struct cgen_insn
*
581 CGEN_SYM (assemble_insn
) PARAMS ((const char *, struct cgen_fields
*,
582 cgen_insn_t
*, char **));
583 int CGEN_SYM (insn_supported
) PARAMS ((const struct cgen_syntax
*));
585 int CGEN_SYM (opval_supported
) PARAMS ((const struct cgen_opval
*));
588 extern const struct cgen_keyword
CGEN_SYM (operand_mach
);
589 int CGEN_SYM (get_mach
) PARAMS ((const char *));
592 CGEN_SYM (put_operand
) PARAMS ((int, const long *,
593 struct cgen_fields
*));
595 CGEN_SYM (get_operand
) PARAMS ((int, const struct cgen_fields
*));
597 CGEN_INLINE
const char *
598 CGEN_SYM (parse_operand
) PARAMS ((int, const char **, struct cgen_fields
*));
600 CGEN_INLINE
const char *
601 CGEN_SYM (validate_operand
) PARAMS ((int, const struct cgen_fields
*));
603 /* Default insn parser, printer. */
604 extern cgen_parse_fn
CGEN_SYM (parse_insn
);
605 extern cgen_insert_fn
CGEN_SYM (insert_insn
);
606 extern cgen_extract_fn
CGEN_SYM (extract_insn
);
607 extern cgen_print_fn
CGEN_SYM (print_insn
);
609 /* Read in a cpu description file. */
610 const char * cgen_read_cpu_file
PARAMS ((const char *));
612 /* Assembler interface.
614 The interface to the assembler is intended to be clean in the sense that
615 libopcodes.a is a standalone entity and could be used with any assembler.
616 Not that one would necessarily want to do that but rather that it helps
617 keep a clean interface. The interface will obviously be slanted towards
618 GAS, but at least it's a start.
620 Parsing is controlled by the assembler which calls
621 CGEN_SYM (assemble_insn). If it can parse and build the entire insn
622 it doesn't call back to the assembler. If it needs/wants to call back
623 to the assembler, (*cgen_asm_parse_operand_fn) is called which can either
625 - return a number to be inserted in the insn
626 - return a "register" value to be inserted
627 (the register might not be a register per pe)
628 - queue the argument and return a marker saying the expression has been
629 queued (eg: a fix-up)
630 - return an error message indicating the expression wasn't recognizable
632 The result is an error message or NULL for success.
633 The parsed value is stored in the bfd_vma *. */
635 enum cgen_asm_result
{
636 CGEN_ASM_NUMBER
, CGEN_ASM_REGISTER
, CGEN_ASM_QUEUED
, CGEN_ASM_ERROR
639 /* Don't require bfd.h unnecessarily. */
641 extern const char * (*cgen_asm_parse_operand_fn
)
642 PARAMS ((const char **, int, int, enum cgen_asm_result
*, bfd_vma
*));
645 /* These are GAS specific. They're not here as part of the interface,
646 but rather that we need to put them somewhere. */
648 /* Call this for each insn to initialize the assembler callback interface. */
649 void cgen_asm_init_parse
PARAMS ((void));
651 /* Don't require bfd.h unnecessarily. */
653 /* The result is an error message or NULL for success.
654 The parsed value is stored in the bfd_vma *. */
655 const char *cgen_asm_parse_operand
PARAMS ((const char **, int, int,
656 enum cgen_asm_result
*,
660 /* Add a register to the assembler's hash table.
661 This makes lets GAS parse registers for us.
662 ??? This isn't currently used, but it could be in the future. */
663 void cgen_asm_record_register
PARAMS ((char *, int));
665 /* After CGEN_SYM (assemble_insn) is done, this is called to
666 output the insn and record any fixups. */
667 void cgen_asm_finish_insn
PARAMS ((const struct cgen_insn
*, cgen_insn_t
*,