include/opcode/cgen.h

   1 /* Header file for targets using CGEN: Cpu tools GENerator.
   2
   3 Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   4
   5 This file is part of GDB, the GNU debugger, and the GNU Binutils.
   6
   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.
  11
  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.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #ifndef CGEN_H
  22 #define CGEN_H
  23
  24 #ifndef CGEN_CAT3
  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)
  28 #else
  29 #define CGEN_CAT3(a,b,c) a/**/b/**/c
  30 #endif
  31 #endif
  32
  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".  */
  38
  39 #ifndef CGEN_SYM
  40 #define CGEN_SYM(s) CGEN_CAT3 (unknown,_cgen_,s)
  41 #endif
  42
  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.  */
  46
  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,
  52    if any.
  53 */
  54 \f
  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
  58    to control this.  */
  59
  60 #ifdef CGEN_INT_INSN
  61 typedef unsigned int cgen_insn_t;
  62 #else
  63 typedef char * cgen_insn_t;
  64 #endif
  65
  66 #ifdef __GNUC__
  67 #define CGEN_INLINE inline
  68 #else
  69 #define CGEN_INLINE
  70 #endif
  71
  72 /* Perhaps we should just use bfd.h, but it's not clear
  73    one would want to require that yet.  */
  74 enum cgen_endian
  75 {
  76   CGEN_ENDIAN_UNKNOWN,
  77   CGEN_ENDIAN_LITTLE,
  78   CGEN_ENDIAN_BIG
  79 };
  80 \f
  81 /* Attributes.
  82    Attributes are used to describe various random things.  */
  83
  84 /* Struct to record attribute information.  */
  85 typedef struct
  86 {
  87   unsigned char num_nonbools;
  88   unsigned int bool;
  89   unsigned int nonbool[1];
  90 } CGEN_ATTR;
  91
  92 /* Define a structure member for attributes with N non-boolean entries.
  93    The attributes are sorted so that the non-boolean ones come first.
  94    num_nonbools: count of nonboolean attributes
  95    bool: values of boolean attributes
  96    nonbool: values of non-boolean attributes
  97    There is a maximum of 32 attributes total.  */
  98 #define CGEN_ATTR_TYPE(n) \
  99 const struct { unsigned char num_nonbools; \
 100                unsigned int bool; \
 101                unsigned int nonbool[(n) ? (n) : 1]; }
 102
 103 /* Given an attribute number, return its mask.  */
 104 #define CGEN_ATTR_MASK(attr) (1 << (attr))
 105
 106 /* Return value of attribute ATTR in ATTR_TABLE for OBJ.
 107    OBJ is a pointer to the entity that has the attributes.
 108    It's not used at present but is reserved for future purposes.  */
 109 #define CGEN_ATTR_VALUE(obj, attr_table, attr) \
 110 ((unsigned int) (attr) < (attr_table)->num_nonbools \
 111  ? ((attr_table)->nonbool[attr]) \
 112  : (((attr_table)->bool & (1 << (attr))) != 0))
 113
 114 /* Attribute name/value tables.
 115    These are used to assist parsing of descriptions at runtime.  */
 116
 117 typedef struct
 118 {
 119   const char * name;
 120   int          value;
 121 } CGEN_ATTR_ENTRY;
 122
 123 /* For each domain (fld,operand,insn), list of attributes.  */
 124
 125 typedef struct
 126 {
 127   const char *            name;
 128   /* NULL for boolean attributes.  */
 129   const CGEN_ATTR_ENTRY * vals;
 130 } CGEN_ATTR_TABLE;
 131 \f
 132 /* Parse result (also extraction result).
 133
 134    The result of parsing an insn is stored here.
 135    To generate the actual insn, this is passed to the insert handler.
 136    When printing an insn, the result of extraction is stored here.
 137    To print the insn, this is passed to the print handler.
 138
 139    It is machine generated so we don't define it here,
 140    but we do need a forward decl for the handler fns.
 141
 142    There is one member for each possible field in the insn.
 143    The type depends on the field.
 144    Also recorded here is the computed length of the insn for architectures
 145    where it varies.
 146 */
 147
 148 struct cgen_fields;
 149
 150 /* Total length of the insn, as recorded in the `fields' struct.  */
 151 /* ??? The field insert handler has lots of opportunities for optimization
 152    if it ever gets inlined.  On architectures where insns all have the same
 153    size, may wish to detect that and make this macro a constant - to allow
 154    further optimizations.  */
 155 #define CGEN_FIELDS_BITSIZE(fields) ((fields)->length)
 156 \f
 157 /* Associated with each insn or expression is a set of "handlers" for
 158    performing operations like parsing, printing, etc.  */
 159
 160 /* Forward decl.  */
 161 typedef struct cgen_insn CGEN_INSN;
 162
 163 /* Parse handler.
 164    The first argument is a pointer to a struct describing the insn being
 165    parsed.
 166    The second argument is a pointer to a pointer to the text being parsed.
 167    The third argument is a pointer to a cgen_fields struct
 168    in which the results are placed.
 169    If the expression is successfully parsed, the pointer to the text is
 170    updated.  If not it is left alone.
 171    The result is NULL if success or an error message.  */
 172 typedef const char * (cgen_parse_fn) PARAMS ((const struct cgen_insn *,
 173                                               const char **,
 174                                               struct cgen_fields *));
 175
 176 /* Print handler.
 177    The first argument is a pointer to the disassembly info.
 178    Eg: disassemble_info.  It's defined as `PTR' so this file can be included
 179    without dis-asm.h.
 180    The second argument is a pointer to a struct describing the insn being
 181    printed.
 182    The third argument is a pointer to a cgen_fields struct.
 183    The fourth argument is the pc value of the insn.
 184    The fifth argument is the length of the insn, in bytes.  */
 185 /* Don't require bfd.h unnecessarily.  */
 186 #ifdef BFD_VERSION
 187 typedef void (cgen_print_fn) PARAMS ((PTR, const struct cgen_insn *,
 188                                       struct cgen_fields *, bfd_vma, int));
 189 #else
 190 typedef void (cgen_print_fn) ();
 191 #endif
 192
 193 /* Insert handler.
 194    The first argument is a pointer to a struct describing the insn being
 195    parsed.
 196    The second argument is a pointer to a cgen_fields struct
 197    from which the values are fetched.
 198    The third argument is a pointer to a buffer in which to place the insn.  */
 199 typedef void (cgen_insert_fn) PARAMS ((const struct cgen_insn *,
 200                                        struct cgen_fields *, cgen_insn_t *));
 201
 202 /* Extract handler.
 203    The first argument is a pointer to a struct describing the insn being
 204    parsed.
 205    The second argument is a pointer to a struct controlling extraction
 206    (only used for variable length insns).
 207    The third argument is the first CGEN_BASE_INSN_SIZE bytes.
 208    The fourth argument is a pointer to a cgen_fields struct
 209    in which the results are placed.
 210    The result is the length of the insn or zero if not recognized.  */
 211 typedef int (cgen_extract_fn) PARAMS ((const struct cgen_insn *,
 212                                        void *, cgen_insn_t,
 213                                        struct cgen_fields *));
 214
 215 /* The `parse' and `insert' fields are indices into these tables.
 216    The elements are pointer to specialized handler functions.
 217    Element 0 is special, it means use the default handler.  */
 218 extern cgen_parse_fn * CGEN_SYM (parse_handlers) [];
 219 #define CGEN_PARSE_FN(x) (CGEN_SYM (parse_handlers)[(x)->base.parse])
 220 extern cgen_insert_fn * CGEN_SYM (insert_handlers) [];
 221 #define CGEN_INSERT_FN(x) (CGEN_SYM (insert_handlers)[(x)->base.insert])
 222
 223 /* Likewise for the `extract' and `print' fields.  */
 224 extern cgen_extract_fn * CGEN_SYM (extract_handlers) [];
 225 #define CGEN_EXTRACT_FN(x) (CGEN_SYM (extract_handlers)[(x)->base.extract])
 226 extern cgen_print_fn * CGEN_SYM (print_handlers) [];
 227 #define CGEN_PRINT_FN(x) (CGEN_SYM (print_handlers)[(x)->base.print])
 228 \f
 229 /* Base class of parser/printer.
 230    (Don't read too much into the use of the phrase "base class".
 231    It's a name I'm using to organize my thoughts.)
 232
 233    Instructions and expressions all share this data in common.
 234    It's a collection of the common elements needed to parse, insert, extract,
 235    and print each of them.  */
 236
 237 #ifndef CGEN_MAX_INSN_ATTRS
 238 #define CGEN_MAX_INSN_ATTRS 1
 239 #endif
 240
 241 struct cgen_base
 242 {
 243   /* Indices into the handler tables.
 244      We could use pointers here instead, but in the case of the insn table,
 245      90% of them would be identical and that's a lot of redundant data.
 246      0 means use the default (what the default is is up to the code).  */
 247   unsigned char parse, insert, extract, print;
 248 };
 249 \f
 250 /* Assembler interface.
 251
 252    The interface to the assembler is intended to be clean in the sense that
 253    libopcodes.a is a standalone entity and could be used with any assembler.
 254    Not that one would necessarily want to do that but rather that it helps
 255    keep a clean interface.  The interface will obviously be slanted towards
 256    GAS, but at least it's a start.
 257
 258    Parsing is controlled by the assembler which calls
 259    CGEN_SYM (assemble_insn).  If it can parse and build the entire insn
 260    it doesn't call back to the assembler.  If it needs/wants to call back
 261    to the assembler, (*cgen_parse_operand_fn) is called which can either
 262
 263    - return a number to be inserted in the insn
 264    - return a "register" value to be inserted
 265      (the register might not be a register per pe)
 266    - queue the argument and return a marker saying the expression has been
 267      queued (eg: a fix-up)
 268    - return an error message indicating the expression wasn't recognizable
 269
 270    The result is an error message or NULL for success.
 271    The parsed value is stored in the bfd_vma *.  */
 272
 273 /* Values for indicating what the caller wants.  */
 274 enum cgen_parse_operand_type
 275 {
 276   CGEN_PARSE_OPERAND_INIT,
 277   CGEN_PARSE_OPERAND_INTEGER,
 278   CGEN_PARSE_OPERAND_ADDRESS
 279 };
 280
 281 /* Values for indicating what was parsed.
 282    ??? Not too useful at present but in time.  */
 283 enum cgen_parse_operand_result
 284 {
 285   CGEN_PARSE_OPERAND_RESULT_NUMBER,
 286   CGEN_PARSE_OPERAND_RESULT_REGISTER,
 287   CGEN_PARSE_OPERAND_RESULT_QUEUED,
 288   CGEN_PARSE_OPERAND_RESULT_ERROR
 289 };
 290
 291 /* Don't require bfd.h unnecessarily.  */
 292 #ifdef BFD_VERSION
 293 extern const char * (*cgen_parse_operand_fn)
 294      PARAMS ((enum cgen_parse_operand_type, const char **, int, int,
 295               enum cgen_parse_operand_result *, bfd_vma *));
 296 #endif
 297
 298 /* Called before trying to match a table entry with the insn.  */
 299 void cgen_init_parse_operand PARAMS ((void));
 300
 301 /* Called from <cpu>-asm.c to initialize operand parsing.  */
 302
 303 /* These are GAS specific.  They're not here as part of the interface,
 304    but rather that we need to put them somewhere.  */
 305
 306 /* Call this from md_assemble to initialize the assembler callback.  */
 307 void cgen_asm_init_parse PARAMS ((void));
 308
 309 /* Don't require bfd.h unnecessarily.  */
 310 #ifdef BFD_VERSION
 311 /* The result is an error message or NULL for success.
 312    The parsed value is stored in the bfd_vma *.  */
 313 const char *cgen_parse_operand PARAMS ((enum cgen_parse_operand_type,
 314                                         const char **, int, int,
 315                                         enum cgen_parse_operand_result *,
 316                                         bfd_vma *));
 317 #endif
 318
 319 /* Add a register to the assembler's hash table.
 320    This makes lets GAS parse registers for us.
 321    ??? This isn't currently used, but it could be in the future.  */
 322 void cgen_asm_record_register PARAMS ((char *, int));
 323
 324 /* After CGEN_SYM (assemble_insn) is done, this is called to
 325    output the insn and record any fixups.  */
 326 void cgen_asm_finish_insn PARAMS ((const struct cgen_insn *, cgen_insn_t *,
 327                                    unsigned int));
 328 \f
 329 /* Operand values (keywords, integers, symbols, etc.)  */
 330
 331 /* Types of assembler elements.  */
 332
 333 enum cgen_asm_type
 334 {
 335   CGEN_ASM_KEYWORD, CGEN_ASM_MAX
 336 };
 337
 338 /* List of hardware elements.  */
 339
 340 typedef struct cgen_hw_entry
 341 {
 342   struct cgen_hw_entry * next;
 343   char *                 name;
 344   enum cgen_asm_type     asm_type;
 345   PTR                    asm_data;
 346 } CGEN_HW_ENTRY;
 347
 348 extern CGEN_HW_ENTRY * CGEN_SYM (hw_list);
 349
 350 CGEN_HW_ENTRY * cgen_hw_lookup PARAMS ((const char *));
 351
 352 #ifndef CGEN_MAX_KEYWORD_ATTRS
 353 #define CGEN_MAX_KEYWORD_ATTRS 1
 354 #endif
 355
 356 /* This struct is used to describe things like register names, etc.  */
 357
 358 typedef struct cgen_keyword_entry
 359 {
 360   /* Name (as in register name).  */
 361   char * name;
 362
 363   /* Value (as in register number).
 364      The value cannot be -1 as that is used to indicate "not found".
 365      IDEA: Have "FUNCTION" attribute? [function is called to fetch value].  */
 366   int value;
 367
 368   /* Attributes.
 369      This should, but technically needn't, appear last.  It is a variable sized
 370      array in that one architecture may have 1 nonbool attribute and another
 371      may have more.  Having this last means the non-architecture specific code
 372      needn't care.  */
 373   /* ??? Moving this last should be done by treating keywords like insn lists
 374      and moving the `next' fields into a CGEN_KEYWORD_LIST struct.  */
 375   /* FIXME: Not used yet.  */
 376   CGEN_ATTR_TYPE (CGEN_MAX_KEYWORD_ATTRS) attrs;
 377
 378   /* Next name hash table entry.  */
 379   struct cgen_keyword_entry *next_name;
 380   /* Next value hash table entry.  */
 381   struct cgen_keyword_entry *next_value;
 382 } CGEN_KEYWORD_ENTRY;
 383
 384 /* Top level struct for describing a set of related keywords
 385    (e.g. register names).
 386
 387    This struct supports runtime entry of new values, and hashed lookups.  */
 388
 389 typedef struct cgen_keyword
 390 {
 391   /* Pointer to initial [compiled in] values.  */
 392   CGEN_KEYWORD_ENTRY * init_entries;
 393
 394   /* Number of entries in `init_entries'.  */
 395   unsigned int num_init_entries;
 396
 397   /* Hash table used for name lookup.  */
 398   CGEN_KEYWORD_ENTRY ** name_hash_table;
 399
 400   /* Hash table used for value lookup.  */
 401   CGEN_KEYWORD_ENTRY ** value_hash_table;
 402
 403   /* Number of entries in the hash_tables.  */
 404   unsigned int hash_table_size;
 405
 406   /* Pointer to null keyword "" entry if present.  */
 407   const CGEN_KEYWORD_ENTRY * null_entry;
 408 } CGEN_KEYWORD;
 409
 410 /* Structure used for searching.  */
 411
 412 typedef struct
 413 {
 414   /* Table being searched.  */
 415   const CGEN_KEYWORD * table;
 416
 417   /* Specification of what is being searched for.  */
 418   const char * spec;
 419
 420   /* Current index in hash table.  */
 421   unsigned int current_hash;
 422
 423   /* Current element in current hash chain.  */
 424   CGEN_KEYWORD_ENTRY * current_entry;
 425 } CGEN_KEYWORD_SEARCH;
 426
 427 /* Lookup a keyword from its name.  */
 428 const CGEN_KEYWORD_ENTRY * cgen_keyword_lookup_name
 429   PARAMS ((CGEN_KEYWORD *, const char *));
 430 /* Lookup a keyword from its value.  */
 431 const CGEN_KEYWORD_ENTRY * cgen_keyword_lookup_value
 432   PARAMS ((CGEN_KEYWORD *, int));
 433 /* Add a keyword.  */
 434 void cgen_keyword_add PARAMS ((CGEN_KEYWORD *, CGEN_KEYWORD_ENTRY *));
 435 /* Keyword searching.
 436    This can be used to retrieve every keyword, or a subset.  */
 437 CGEN_KEYWORD_SEARCH cgen_keyword_search_init
 438   PARAMS ((CGEN_KEYWORD *, const char *));
 439 const CGEN_KEYWORD_ENTRY *cgen_keyword_search_next
 440   PARAMS ((CGEN_KEYWORD_SEARCH *));
 441
 442 /* Operand value support routines.  */
 443 /* FIXME: some of the long's here will need to be bfd_vma or some such.  */
 444
 445 const char * cgen_parse_keyword PARAMS ((const char **,
 446                                          CGEN_KEYWORD *,
 447                                          long *));
 448 const char * cgen_parse_signed_integer PARAMS ((const char **, int,
 449                                                 long, long, long *));
 450 const char * cgen_parse_unsigned_integer PARAMS ((const char **, int,
 451                                                   unsigned long, unsigned long,
 452                                                   unsigned long *));
 453 const char * cgen_parse_address PARAMS ((const char **, int, int,
 454                                          enum cgen_parse_operand_result *,
 455                                          long *));
 456 const char * cgen_validate_signed_integer PARAMS ((long, long, long));
 457 const char * cgen_validate_unsigned_integer PARAMS ((unsigned long,
 458                                                      unsigned long,
 459                                                      unsigned long));
 460 \f
 461 /* This struct defines each entry in the operand table.  */
 462
 463 #ifndef CGEN_MAX_OPERAND_ATTRS
 464 #define CGEN_MAX_OPERAND_ATTRS 1
 465 #endif
 466
 467 typedef struct cgen_operand
 468 {
 469   /* Name as it appears in the syntax string.  */
 470   char * name;
 471
 472   /* Bit position (msb of first byte = bit 0).
 473      This is just a hint, and may be unused in more complex operands.
 474      May be unused for a modifier.  */
 475   unsigned char start;
 476
 477   /* The number of bits in the operand.
 478      This is just a hint, and may be unused in more complex operands.
 479      May be unused for a modifier.  */
 480   unsigned char length;
 481
 482 #if 0 /* ??? Interesting idea but relocs tend to get too complicated,
 483          and ABI dependent, for simple table lookups to work.  */
 484   /* Ideally this would be the internal (external?) reloc type.  */
 485   int reloc_type;
 486 #endif
 487
 488   /* Attributes.
 489      This should, but technically needn't, appear last.  It is a variable sized
 490      array in that one architecture may have 1 nonbool attribute and another
 491      may have more.  Having this last means the non-architecture specific code
 492      needn't care, now or tomorrow.  */
 493   CGEN_ATTR_TYPE (CGEN_MAX_OPERAND_ATTRS) attrs;
 494 #define CGEN_OPERAND_ATTRS(operand) (&(operand)->attrs)
 495 } CGEN_OPERAND;
 496
 497 /* Return value of attribute ATTR in OPERAND.  */
 498 #define CGEN_OPERAND_ATTR(operand, attr) \
 499 CGEN_ATTR_VALUE (operand, CGEN_OPERAND_ATTRS (operand), attr)
 500
 501 /* The operand table is currently a very static entity.  */
 502 extern const CGEN_OPERAND CGEN_SYM (operand_table)[];
 503
 504 enum cgen_operand_type;
 505
 506 #define CGEN_OPERAND_INDEX(operand) ((int) ((operand) - CGEN_SYM (operand_table)))
 507 /* FIXME: Rename, cpu-opc.h defines this as the typedef of the enum.  */
 508 #define CGEN_OPERAND_TYPE(operand) ((enum cgen_operand_type) CGEN_OPERAND_INDEX (operand))
 509 #define CGEN_OPERAND_ENTRY(n) (& CGEN_SYM (operand_table) [n])
 510 \f
 511 /* Syntax string.
 512
 513    Each insn format and subexpression has one of these.
 514
 515    The syntax "string" consists of characters (n > 0 && n < 128), and operand
 516    values (n >= 128), and is terminated by 0.  Operand values are 128 + index
 517    into the operand table.  The operand table doesn't exist in C, per se, as
 518    the data is recorded in the parse/insert/extract/print switch statements. */
 519
 520 #ifndef CGEN_MAX_SYNTAX_BYTES
 521 #define CGEN_MAX_SYNTAX_BYTES 16
 522 #endif
 523
 524 typedef struct
 525 {
 526   unsigned char syntax[CGEN_MAX_SYNTAX_BYTES];
 527 } CGEN_SYNTAX;
 528
 529 #define CGEN_SYNTAX_STRING(syn) (syn->syntax)
 530 #define CGEN_SYNTAX_CHAR_P(c) ((c) < 128)
 531 #define CGEN_SYNTAX_CHAR(c) (c)
 532 #define CGEN_SYNTAX_FIELD(c) ((c) - 128)
 533
 534 /* ??? I can't currently think of any case where the mnemonic doesn't come
 535    first [and if one ever doesn't building the hash tables will be tricky].
 536    However, we treat mnemonics as just another operand of the instruction.
 537    A value of 1 means "this is where the mnemonic appears".  1 isn't
 538    special other than it's a non-printable ASCII char.  */
 539 #define CGEN_SYNTAX_MNEMONIC_P(ch) ((ch) == 1)
 540 \f
 541 /* Instruction formats.
 542
 543    Instructions are grouped by format.  Associated with an instruction is its
 544    format.  Each opcode table entry contains a pointer into the format table.
 545    This cuts down on the size of the opcode table as there are relatively few
 546    formats compared with the number of instructions.  */
 547
 548 typedef struct
 549 {
 550   /* Length that MASK and VALUE have been calculated to
 551      [VALUE is recorded elsewhere].
 552      Normally it is CGEN_BASE_INSN_BITSIZE.  On [V]LIW architectures where
 553      the base insn size may be larger than the size of an insn, this field is
 554      less than CGEN_BASE_INSN_BITSIZE.  */
 555   unsigned char mask_length;
 556
 557   /* Total length of instruction.  */
 558   unsigned char length;
 559
 560   /* Mask to apply to the first BASE_LENGTH bits.
 561      Each insn's value is stored with the insn.
 562      The first step in recognizing an insn for disassembly is
 563      (opcode & mask) == value.  */
 564   unsigned int mask;
 565 } CGEN_FORMAT;
 566 \f
 567 /* This struct defines each entry in the instruction table.  */
 568
 569 struct cgen_insn
 570 {
 571   /* ??? Further table size reductions can be had by moving this element
 572      either to the format table or to a separate table of its own.  Not
 573      sure this is desirable yet.  */
 574   struct cgen_base base;
 575
 576 /* Given a pointer to a cgen_insn struct, return a pointer to `base'.  */
 577 #define CGEN_INSN_BASE(insn) (&(insn)->base)
 578
 579   /* Name of entry (that distinguishes it from all other entries).
 580      This is used, for example, in simulator profiling results.  */
 581   /* ??? If mnemonics have operands, try to print full mnemonic.  */
 582   const char * name;
 583 #define CGEN_INSN_NAME(insn) ((insn)->name)
 584
 585   /* Mnemonic.  This is used when parsing and printing the insn.
 586      In the case of insns that have operands on the mnemonics, this is
 587      only the constant part.  E.g. for conditional execution of an `add' insn,
 588      where the full mnemonic is addeq, addne, etc., this is only "add".  */
 589   const char * mnemonic;
 590 #define CGEN_INSN_MNEMONIC(insn) ((insn)->mnemonic)
 591
 592   /* Syntax string.
 593      For now this only points to CGEN_SYNTAX elements, but it can point
 594      to other things (e.g. something different for macros?).  */
 595   const CGEN_SYNTAX * syntax;
 596 #define CGEN_INSN_SYNTAX(insn) ((CGEN_SYNTAX *) (insn)->syntax)
 597
 598   /* Format entry.
 599      For now this only points to CGEN_FORMAT elements, but it can point
 600      to other things (e.g. something different for macros?).  */
 601   const CGEN_FORMAT * format;
 602 #define CGEN_INSN_MASK_BITSIZE(insn) (((CGEN_FORMAT *) (insn)->format)->mask_length)
 603 #define CGEN_INSN_BITSIZE(insn) (((CGEN_FORMAT *) (insn)->format)->length)
 604
 605   /* Instruction opcode value.  */
 606   unsigned int value;
 607 #define CGEN_INSN_VALUE(insn) ((insn)->value)
 608 #define CGEN_INSN_MASK(insn) (((CGEN_FORMAT *) (insn)->format)->mask)
 609
 610   /* Attributes.
 611      This must appear last.  It is a variable sized array in that one
 612      architecture may have 1 nonbool attribute and another may have more.
 613      Having this last means the non-architecture specific code needn't
 614      care.  */
 615   CGEN_ATTR_TYPE (CGEN_MAX_INSN_ATTRS) attrs;
 616 #define CGEN_INSN_ATTRS(insn) (&(insn)->attrs)
 617 /* Return value of attribute ATTR in INSN.  */
 618 #define CGEN_INSN_ATTR(insn, attr) \
 619 CGEN_ATTR_VALUE (insn, CGEN_INSN_ATTRS (insn), attr)
 620 };
 621
 622 /* Instruction lists.
 623    This is used for adding new entries and for creating the hash lists.  */
 624
 625 typedef struct cgen_insn_list
 626 {
 627   struct cgen_insn_list * next;
 628   const CGEN_INSN * insn;
 629 } CGEN_INSN_LIST;
 630
 631 /* The table of instructions.  */
 632
 633 typedef struct
 634 {
 635   /* Pointer to initial [compiled in] entries.  */
 636   const CGEN_INSN * init_entries;
 637
 638   /* Size of an entry (since the attribute member is variable sized).  */
 639   unsigned int entry_size;
 640
 641   /* Number of entries in `init_entries', including trailing NULL entry.  */
 642   unsigned int num_init_entries;
 643
 644   /* Values added at runtime.  */
 645   CGEN_INSN_LIST * new_entries;
 646
 647   /* Assembler hash function.  */
 648   unsigned int (* asm_hash) PARAMS ((const char *));
 649
 650   /* Number of entries in assembler hash table.  */
 651   unsigned int asm_hash_table_size;
 652
 653   /* Disassembler hash function.  */
 654   unsigned int (* dis_hash) PARAMS ((const char *, unsigned long));
 655
 656   /* Number of entries in disassembler hash table.  */
 657   unsigned int dis_hash_table_size;
 658 } CGEN_INSN_TABLE;
 659
 660 /* ??? This is currently used by the simulator.
 661    We want this to be fast and the simulator currently doesn't handle
 662    runtime added instructions so this is ok.  An alternative would be to
 663    store the index in the table.  */
 664 extern const CGEN_INSN CGEN_SYM (insn_table_entries)[];
 665 #define CGEN_INSN_INDEX(insn) ((int) ((insn) - CGEN_SYM (insn_table_entries)))
 666 #define CGEN_INSN_ENTRY(n) (& CGEN_SYM (insn_table_entries) [n])
 667
 668 /* Return number of instructions.  This includes any added at runtime.  */
 669
 670 int cgen_insn_count PARAMS ((void));
 671
 672 /* The assembler insn table is hashed based on some function of the mnemonic
 673    (the actually hashing done is up to the target, but we provide a few
 674    examples like the first letter or a function of the entire mnemonic).
 675    The index of each entry is the index of the corresponding table entry.
 676    The value of each entry is the index of the next entry, with a 0
 677    terminating (thus the first entry is reserved).  */
 678
 679 #ifndef CGEN_ASM_HASH
 680 #ifdef CGEN_MNEMONIC_OPERANDS
 681 #define CGEN_ASM_HASH_SIZE 127
 682 #define CGEN_ASM_HASH(string) (*(unsigned char *) (string) % CGEN_ASM_HASH_SIZE)
 683 #else
 684 #define CGEN_ASM_HASH_SIZE 128
 685 #define CGEN_ASM_HASH(string) (*(unsigned char *) (string) % CGEN_ASM_HASH_SIZE) /*FIXME*/
 686 #endif
 687 #endif
 688
 689 unsigned int CGEN_SYM (asm_hash_insn) PARAMS ((const char *));
 690 CGEN_INSN_LIST * cgen_asm_lookup_insn PARAMS ((const char *));
 691 #define CGEN_ASM_LOOKUP_INSN(insn) cgen_asm_lookup_insn (insn)
 692 #define CGEN_ASM_NEXT_INSN(insn) ((insn)->next)
 693
 694 /* The disassembler insn table is hashed based on some function of machine
 695    instruction (the actually hashing done is up to the target).  */
 696
 697 /* It doesn't make much sense to provide a default here,
 698    but while this is under development we do.
 699    BUFFER is a pointer to the bytes of the insn.
 700    INSN is the first CGEN_BASE_INSN_SIZE bytes as an int in host order.  */
 701 #ifndef CGEN_DIS_HASH
 702 #define CGEN_DIS_HASH_SIZE 256
 703 #define CGEN_DIS_HASH(buffer, insn) (*(unsigned char *) (buffer))
 704 #endif
 705
 706 unsigned int CGEN_SYM (dis_hash_insn) PARAMS ((const char *, unsigned long));
 707 CGEN_INSN_LIST * cgen_dis_lookup_insn PARAMS ((const char *, unsigned long));
 708 #define CGEN_DIS_LOOKUP_INSN(buf, insn) cgen_dis_lookup_insn (buf, insn)
 709 #define CGEN_DIS_NEXT_INSN(insn) ((insn)->next)
 710 \f
 711 /* Top level structures and functions.  */
 712
 713 typedef struct
 714 {
 715   CGEN_HW_ENTRY *        hw_list;
 716   /*CGEN_OPERAND_TABLE * operand_table; - FIXME:wip */
 717   CGEN_INSN_TABLE *      insn_table;
 718 } CGEN_OPCODE_DATA;
 719
 720 /* Each CPU has one of these.  */
 721 extern CGEN_OPCODE_DATA CGEN_SYM (opcode_data);
 722
 723 /* Global state access macros.
 724    Some of these are tucked away and accessed with cover fns.
 725    Simpler things like the current machine and endian are not.  */
 726
 727 extern int cgen_current_machine;
 728 #define CGEN_CURRENT_MACHINE cgen_current_machine
 729
 730 extern enum cgen_endian cgen_current_endian;
 731 #define CGEN_CURRENT_ENDIAN cgen_current_endian
 732
 733 /* Prototypes of major functions.  */
 734
 735 /* Set the current cpu (+ mach number, endian, etc.).  *?
 736 void cgen_set_cpu PARAMS ((CGEN_OPCODE_DATA *, int, enum cgen_endian));
 737
 738 /* Initialize the assembler, disassembler.  */
 739 void cgen_asm_init PARAMS ((void));
 740 void cgen_dis_init PARAMS ((void));
 741
 742 /* `init_tables' must be called before `xxx_supported'.  */
 743 void CGEN_SYM (init_tables) PARAMS ((int));
 744 void CGEN_SYM (init_asm) PARAMS ((int, enum cgen_endian));
 745 void CGEN_SYM (init_dis) PARAMS ((int, enum cgen_endian));
 746 void CGEN_SYM (init_parse) PARAMS ((void));
 747 void CGEN_SYM (init_print) PARAMS ((void));
 748 void CGEN_SYM (init_insert) PARAMS ((void));
 749 void CGEN_SYM (init_extract) PARAMS ((void));
 750 const struct cgen_insn *
 751 CGEN_SYM (assemble_insn) PARAMS ((const char *, struct cgen_fields *,
 752                                   cgen_insn_t *, char **));
 753 #if 0 /* old */
 754 int CGEN_SYM (insn_supported) PARAMS ((const struct cgen_insn *));
 755 int CGEN_SYM (opval_supported) PARAMS ((const struct cgen_opval *));
 756 #endif
 757
 758 extern const CGEN_KEYWORD  CGEN_SYM (operand_mach);
 759 int CGEN_SYM (get_mach) PARAMS ((const char *));
 760
 761 CGEN_INLINE void
 762 CGEN_SYM (put_operand) PARAMS ((int, const long *,
 763                                 struct cgen_fields *));
 764 CGEN_INLINE long
 765 CGEN_SYM (get_operand) PARAMS ((int, const struct cgen_fields *));
 766
 767 CGEN_INLINE const char *
 768 CGEN_SYM (parse_operand) PARAMS ((int, const char **, struct cgen_fields *));
 769
 770 CGEN_INLINE const char *
 771 CGEN_SYM (validate_operand) PARAMS ((int, const struct cgen_fields *));
 772
 773 /* Default insn parser, printer.  */
 774 extern cgen_parse_fn CGEN_SYM (parse_insn);
 775 extern cgen_insert_fn CGEN_SYM (insert_insn);
 776 extern cgen_extract_fn CGEN_SYM (extract_insn);
 777 extern cgen_print_fn CGEN_SYM (print_insn);
 778
 779 /* Read in a cpu description file.  */
 780 const char * cgen_read_cpu_file PARAMS ((const char *));
 781
 782 #endif /* CGEN_H */