cgen/desc-cpu.scm

   1 ; Generate .c/.h versions of main elements of cpu description file.
   2 ; Copyright (C) 2000, 2001, 2002, 2003 Red Hat, Inc.
   3 ; This file is part of CGEN.
   4
   5 ; ISA support code.
   6
   7 (define (-gen-isa-table-defns)
   8   (logit 2 "Generating isa table defns ...\n")
   9
  10   (string-list
  11    "\
  12 /* Instruction set variants.  */
  13
  14 static const CGEN_ISA @arch@_cgen_isa_table[] = {
  15 "
  16    (string-list-map (lambda (isa)
  17                       (gen-obj-sanitize
  18                        isa
  19                        (string-append "  { "
  20                                       "\"" (obj:str-name isa) "\", "
  21                                       (number->string
  22                                        (isa-default-insn-bitsize isa))
  23                                       ", "
  24                                       (number->string
  25                                        (isa-base-insn-bitsize isa))
  26                                       ", "
  27                                       (number->string
  28                                        (isa-min-insn-bitsize isa))
  29                                       ", "
  30                                       (number->string
  31                                        (isa-max-insn-bitsize isa))
  32                                       " },\n")))
  33                     (current-isa-list))
  34    "\
  35   { 0, 0, 0, 0, 0 }
  36 };
  37 \n"
  38    )
  39 )
  40
  41 ; Mach support code.
  42
  43 ; Return C code to describe the various cpu variants.
  44 ; Currently this is quite simple, the various cpu names and their mach numbers
  45 ; are recorded in a "keyword" table.
  46 ; ??? No longer used as there is the mach attribute.
  47 ;
  48 ;(set! mach-table (make <keyword> 'mach "machine list"
  49 ;                       (make <attr-list> "" nil) ; FIXME: sanitization?
  50 ;                       (map (lambda (elm) (list (obj:name elm) (mach-number elm)))
  51 ;                            (current-mach-list))))
  52
  53 (define (-gen-mach-table-decls)
  54   (logit 2 "Generating machine table decls ...\n")
  55   "" ; (gen-decl mach-table)
  56 )
  57
  58 (define (-gen-mach-table-defns)
  59   (logit 2 "Generating machine table defns ...\n")
  60
  61   (string-list
  62    "\
  63 /* Machine variants.  */
  64
  65 static const CGEN_MACH @arch@_cgen_mach_table[] = {
  66 "
  67    (string-list-map (lambda (mach)
  68                       (gen-obj-sanitize
  69                        mach
  70                        (string-append "  { "
  71                                       "\"" (obj:str-name mach) "\", "
  72                                       "\"" (mach-bfd-name mach) "\", "
  73                                       (mach-enum mach) ", "
  74                                       (number->string (cpu-insn-chunk-bitsize (mach-cpu mach)))
  75                                       " },\n")))
  76                     (current-mach-list))
  77    "\
  78   { 0, 0, 0, 0 }
  79 };
  80 \n"
  81    )
  82 )
  83 \f
  84 ; Attribute support code.
  85
  86 ; Return C code to describe the various attributes.
  87
  88 (define (-gen-attr-table-decls)
  89   (logit 2 "Generating attribute table decls ...\n")
  90   (string-append
  91    "/* Attributes.  */\n"
  92    "extern const CGEN_ATTR_TABLE @arch@_cgen_hardware_attr_table[];\n"
  93    "extern const CGEN_ATTR_TABLE @arch@_cgen_ifield_attr_table[];\n"
  94    "extern const CGEN_ATTR_TABLE @arch@_cgen_operand_attr_table[];\n"
  95    "extern const CGEN_ATTR_TABLE @arch@_cgen_insn_attr_table[];\n"
  96    "\n"
  97    )
  98 )
  99
 100 ; Alternative GEN-MASK argument to gen-bool-attrs.
 101 ; This uses the `A' macro to abbreviate the attribute definition.
 102
 103 (define (gen-A-attr-mask prefix name)
 104   (string-append "A(" (string-upcase (gen-c-symbol name)) ")")
 105 )
 106 \f
 107 ; Instruction fields support code.
 108
 109 ; Return C code to declare various ifield bits.
 110
 111 (define (gen-ifld-decls)
 112   (logit 2 "Generating instruction field decls ...\n")
 113   (string-list
 114    "/* Ifield support.  */\n\n"
 115    "extern const struct cgen_ifld @arch@_cgen_ifld_table[];\n\n"
 116    "/* Ifield attribute indices.  */\n\n"
 117    (gen-attr-enum-decl "cgen_ifld" (current-ifld-attr-list))
 118    (gen-enum-decl 'ifield_type "@arch@ ifield types"
 119                   "@ARCH@_"
 120                   (append (gen-obj-list-enums (non-derived-ifields (current-ifld-list)))
 121                           '((f-max))))
 122    "#define MAX_IFLD ((int) @ARCH@_F_MAX)\n\n"
 123    )
 124 )
 125
 126 ; Return C code to define the instruction field table,
 127 ; and any other ifield related definitions.
 128
 129 (define (gen-ifld-defns)
 130   (logit 2 "Generating ifield table ...\n")
 131   (let* ((ifld-list (current-ifld-list))
 132          (all-attrs (current-ifld-attr-list))
 133          (num-non-bools (attr-count-non-bools all-attrs)))
 134     (string-list
 135      "
 136 /* The instruction field table.  */
 137
 138 "
 139      (gen-define-with-symcat "A(a) (1 << CGEN_IFLD_" "a)")
 140      "
 141 const CGEN_IFLD @arch@_cgen_ifld_table[] =
 142 {
 143 "
 144      (string-list-map
 145       (lambda (ifld)
 146         (gen-obj-sanitize ifld
 147                           (string-append
 148                            "  { "
 149                            (ifld-enum ifld) ", "
 150                            "\"" (obj:str-name ifld) "\", "
 151                            (if
 152                             (or (has-attr? ifld 'VIRTUAL)
 153                                 (derived-ifield? ifld))
 154                              "0, 0, 0, 0,"
 155                              (string-append
 156                               (number->string (ifld-word-offset ifld)) ", "
 157                               (number->string (ifld-word-length ifld)) ", "
 158                               (number->string (ifld-start ifld #f)) ", "
 159                               (number->string (ifld-length ifld)) ", "))
 160                            (gen-obj-attr-defn 'ifld ifld all-attrs
 161                                       num-non-bools gen-A-attr-mask)
 162                            "  },\n")))
 163       ifld-list)
 164      "\
 165   { 0, 0, 0, 0, 0, 0, {0, {0}} }
 166 };
 167
 168 #undef A
 169
 170 "
 171      ))
 172 )
 173 \f
 174 ; Hardware support.
 175
 176 ; Return C code to declare the various hardware bits
 177 ; that can be (or must be) defined before including opcode/cgen.h.
 178
 179 (define (gen-hw-decls)
 180   (logit 2 "Generating hardware decls ...\n")
 181   (string-list
 182    "/* Hardware attribute indices.  */\n\n"
 183    (gen-attr-enum-decl "cgen_hw" (current-hw-attr-list))
 184    (gen-enum-decl 'cgen_hw_type "@arch@ hardware types"
 185                   "HW_" ; FIXME: @ARCH@_
 186                   (append (nub (map (lambda (hw)
 187                                       (cons (hw-sem-name hw)
 188                                             (cons '-
 189                                                   (atlist-attrs
 190                                                    (obj-atlist hw)))))
 191                                     (current-hw-list))
 192                                (lambda (elm) (car elm)))
 193                           '((max))))
 194    "#define MAX_HW ((int) HW_MAX)\n\n"
 195    )
 196 )
 197
 198 ; Return declarations of variables tables used by HW.
 199
 200 (define (-gen-hw-decl hw)
 201   (string-append
 202    (if (and (hw-indices hw)
 203             ; ??? Commented out as opcode changes are needed
 204             ) ; (not (obj-has-attr? (hw-indices hw) 'PRIVATE)))
 205        (gen-decl (hw-indices hw))
 206        "")
 207    (if (and (hw-values hw)
 208             ; ??? Commented out as opcode changes are needed
 209             ) ; (not (obj-has-attr? (hw-values hw) 'PRIVATE)))
 210        (gen-decl (hw-values hw))
 211        "")
 212    )
 213 )
 214
 215 ; Return C code to declare the various hardware bits
 216 ; that must be defined after including opcode/cgen.h.
 217
 218 (define (gen-hw-table-decls)
 219   (logit 2 "Generating hardware table decls ...\n")
 220   (string-list
 221    "/* Hardware decls.  */\n\n"
 222    (string-map -gen-hw-decl (current-hw-list))
 223    "\n"
 224    "extern const CGEN_HW_ENTRY @arch@_cgen_hw_table[];\n"
 225    )
 226 )
 227
 228 ; Return definitions of variables tables used by HW.
 229 ; Only do this for `PRIVATE' elements.  Public ones are emitted elsewhere.
 230
 231 (define (-gen-hw-defn hw)
 232   (string-append
 233    (if (and (hw-indices hw)
 234             (obj-has-attr? (hw-indices hw) 'PRIVATE))
 235        (gen-defn (hw-indices hw))
 236        "")
 237    (if (and (hw-values hw)
 238             (obj-has-attr? (hw-values hw) 'PRIVATE))
 239        (gen-defn (hw-values hw))
 240        "")
 241    )
 242 )
 243
 244 ; Generate the tables for the various hardware bits (register names, etc.).
 245 ; A table is generated for each element, and then another table is generated
 246 ; which collects them all together.
 247 ; Uses include looking up a particular register set so that a new reg
 248 ; can be added to it [at runtime].
 249
 250 (define (gen-hw-table-defns)
 251   (logit 2 "Generating hardware table ...\n")
 252   (let* ((all-attrs (current-hw-attr-list))
 253          (num-non-bools (attr-count-non-bools all-attrs)))
 254     (string-list
 255      (string-list-map gen-defn (current-kw-list))
 256      (string-list-map -gen-hw-defn (current-hw-list))
 257      "
 258 /* The hardware table.  */
 259
 260 "
 261      (gen-define-with-symcat "A(a) (1 << CGEN_HW_" "a)")
 262      "
 263 const CGEN_HW_ENTRY @arch@_cgen_hw_table[] =
 264 {
 265 "
 266      (string-list-map
 267       (lambda (hw)
 268         (gen-obj-sanitize hw
 269                           (string-list
 270                            "  { "
 271                            "\"" (obj:str-name hw) "\", "
 272                            (hw-enum hw) ", "
 273                            ; ??? No element currently requires both indices and
 274                            ; values specs so we only output the needed one.
 275                            (or (and (hw-indices hw)
 276                                     (send (hw-indices hw) 'gen-table-entry))
 277                                (and (hw-values hw)
 278                                     (send (hw-values hw) 'gen-table-entry))
 279                                "CGEN_ASM_NONE, 0, ")
 280                            (gen-obj-attr-defn 'hw hw all-attrs
 281                                               num-non-bools gen-A-attr-mask)
 282                            " },\n")))
 283       (current-hw-list))
 284      "\
 285   { 0, 0, CGEN_ASM_NONE, 0, {0, {0}} }
 286 };
 287
 288 #undef A
 289
 290 "
 291      ))
 292 )
 293 \f
 294 ; Utilities of cgen-opc.h.
 295
 296 ; Return #define's of several constants.
 297 ; FIXME: Some of these to be moved into table of structs, one per cpu family.
 298
 299 (define (-gen-hash-defines)
 300   (logit 2 "Generating #define's ...\n")
 301   (string-list
 302    "#define CGEN_ARCH @arch@\n\n"
 303    "/* Given symbol S, return @arch@_cgen_<S>.  */\n"
 304    (gen-define-with-symcat "CGEN_SYM(s) @arch@" "_cgen_" "s")
 305    "\n\n/* Selected cpu families.  */\n"
 306    ; FIXME: Move to sim's arch.h.
 307    (string-map (lambda (cpu)
 308                  (gen-obj-sanitize cpu
 309                                    (string-append "#define HAVE_CPU_"
 310                                                   (string-upcase (gen-sym cpu))
 311                                                   "\n")))
 312                (current-cpu-list))
 313    "\n"
 314    "#define CGEN_INSN_LSB0_P " (if (current-arch-insn-lsb0?) "1" "0")
 315    "\n\n"
 316    "/* Minimum size of any insn (in bytes).  */\n"
 317    "#define CGEN_MIN_INSN_SIZE "
 318    (number->string (bits->bytes
 319                     (apply min (map isa-min-insn-bitsize (current-isa-list)))))
 320    "\n\n"
 321    "/* Maximum size of any insn (in bytes).  */\n"
 322    "#define CGEN_MAX_INSN_SIZE "
 323    (number->string (bits->bytes
 324                     (apply max (map isa-max-insn-bitsize (current-isa-list)))))
 325    "\n\n"
 326    ; This tells the assembler/disassembler whether or not it can use an int to
 327    ; record insns, which is faster.  Since this controls the typedef of the
 328    ; insn buffer, only enable this if all isas support it.
 329    "#define CGEN_INT_INSN_P "
 330    (if (all-true? (map isa-integral-insn? (current-isa-list))) "1" "0")
 331    "\n"
 332    "\n"
 333    "/* Maximum number of syntax elements in an instruction.  */\n"
 334    "#define CGEN_ACTUAL_MAX_SYNTAX_ELEMENTS "
 335    ; The +2 account for the leading "MNEM" and trailing 0.
 336    (number->string (+ 2 (apply max (map (lambda (insn)
 337                                           (length (syntax-break-out (insn-syntax insn))))
 338                                         (current-insn-list)))))
 339    "\n"
 340    "\n"
 341    "/* CGEN_MNEMONIC_OPERANDS is defined if mnemonics have operands.\n"
 342    "   e.g. In \"b,a foo\" the \",a\" is an operand.  If mnemonics have operands\n"
 343    "   we can't hash on everything up to the space.  */\n"
 344    (if strip-mnemonic?
 345        "/*#define CGEN_MNEMONIC_OPERANDS*/\n"
 346        "#define CGEN_MNEMONIC_OPERANDS\n")
 347    "\n"
 348    ; "/* Maximum number of operands any insn or macro-insn has.  */\n"
 349    ; FIXME: Should compute.
 350    ; "#define CGEN_MAX_INSN_OPERANDS 16\n"
 351    ; "\n"
 352    "/* Maximum number of fields in an instruction.  */\n"
 353    "#define CGEN_ACTUAL_MAX_IFMT_OPERANDS "
 354    (number->string (apply max (map (lambda (f) (length (ifmt-ifields f)))
 355                                    (current-ifmt-list))))
 356    "\n\n"
 357   )
 358 )
 359 \f
 360 ; Operand support.
 361
 362 ; Return C code to declare various operand bits.
 363
 364 (define (gen-operand-decls)
 365   (logit 2 "Generating operand decls ...\n")
 366   (string-list
 367    "/* Operand attribute indices.  */\n\n"
 368    (gen-attr-enum-decl "cgen_operand" (current-op-attr-list))
 369    (gen-enum-decl 'cgen_operand_type "@arch@ operand types"
 370                   "@ARCH@_OPERAND_"
 371                   (nub (append (gen-obj-list-enums (current-op-list))
 372                                '((max)))
 373                        car))
 374    "/* Number of operands types.  */\n"
 375    "#define MAX_OPERANDS " (number->string (length (gen-obj-list-enums (current-op-list)))) "\n\n"
 376    ; was: "#define MAX_OPERANDS ((int) @ARCH@_OPERAND_MAX)\n\n"
 377    "/* Maximum number of operands referenced by any insn.  */\n"
 378    "#define MAX_OPERAND_INSTANCES "
 379    (number->string (max-operand-instances))
 380    "\n\n"
 381    )
 382 )
 383
 384 ; Generate C code to define the operand table.
 385
 386 (define ifld-number-cache #f)
 387 (define (ifld-number f)
 388   (if (not ifld-number-cache)
 389       (let* ((ls (find (lambda (f) (not (has-attr? f 'VIRTUAL)))
 390                        (non-derived-ifields (current-ifld-list))))
 391              (numls (iota (length ls))))
 392         (set! ifld-number-cache
 393               (map (lambda (elt num) (cons (obj:name elt) num))
 394                    ls numls))))
 395   (number->string (cdr (assoc (obj:name f) ifld-number-cache))))
 396
 397 (define (gen-maybe-multi-ifld-of-op op)
 398   (let* ((idx (op:index op))
 399          (ty (hw-index:type idx))
 400          (fld (hw-index:value idx)))
 401     (gen-maybe-multi-ifld ty fld)))
 402
 403 (define (gen-maybe-multi-ifld ty fld)
 404   (let* ((field-ref "0")
 405          (field-count "0"))
 406     (if (equal? ty 'ifield)
 407         (if (multi-ifield? fld)
 408             (begin
 409               (set! field-ref (string-append "&" (ifld-enum fld) "_MULTI_IFIELD[0]"))
 410               (set! field-count (number->string (length (elm-get fld 'subfields)))))
 411             ; else
 412               (set! field-ref (string-append "&@arch@_cgen_ifld_table[" (ifld-enum fld) "]"))))
 413     (string-append "{ " field-count ", { (const PTR) " field-ref " } }")))
 414
 415 (define (gen-multi-ifield-nodes)
 416   (let ((multis (find multi-ifield? (current-ifld-list))))
 417     (apply string-append
 418            (append
 419
 420             '("\n\n/* multi ifield declarations */\n\n")
 421             (map
 422              (lambda (ifld)
 423                (string-append
 424                 "const CGEN_MAYBE_MULTI_IFLD "
 425                 (ifld-enum ifld) "_MULTI_IFIELD [];\n"))
 426              multis)
 427
 428             '("\n\n/* multi ifield definitions */\n\n")
 429             (map
 430              (lambda (ifld)
 431                (string-append
 432                 "const CGEN_MAYBE_MULTI_IFLD "
 433                 (ifld-enum ifld) "_MULTI_IFIELD [] =\n{"
 434                 (apply string-append
 435                        (map (lambda (x) (string-append "\n    " (gen-maybe-multi-ifld 'ifield x) ","))
 436                             (elm-get ifld 'subfields)))
 437                 "\n    { 0, { (const PTR) 0 } }\n};\n"))
 438              multis)))))
 439
 440 (define (gen-operand-table)
 441   (logit 2 "Generating operand table ...\n")
 442   (let* ((all-attrs (current-op-attr-list))
 443          (num-non-bools (attr-count-non-bools all-attrs)))
 444     (string-list
 445      "
 446 /* The operand table.  */
 447
 448 "
 449      (gen-define-with-symcat "A(a) (1 << CGEN_OPERAND_" "a)")
 450      (gen-define-with-symcat "OPERAND(op) @ARCH@_OPERAND_" "op")
 451 "
 452 const CGEN_OPERAND @arch@_cgen_operand_table[] =
 453 {
 454 "
 455      (string-list-map
 456       (lambda (op)
 457         (gen-obj-sanitize op
 458                           (string-append
 459                            "/* " (obj:str-name op) ": " (obj:comment op) " */\n"
 460                           (if (or (derived-operand? op)
 461                                   (anyof-operand? op))
 462                               ""
 463                               (string-append
 464                                  "  { "
 465                                  "\"" (obj:str-name op) "\", "
 466                                  (op-enum op) ", "
 467                                  (hw-enum (op:hw-name op)) ", "
 468                                  (number->string (op:start op)) ", "
 469                                  (number->string (op:length op)) ",\n"
 470                                  "    "
 471                                  (gen-maybe-multi-ifld-of-op op) ", \n"
 472                                  "    "
 473                                  (gen-obj-attr-defn 'operand op all-attrs
 474                                                     num-non-bools gen-A-attr-mask)
 475                                  "  },\n"
 476                               )))))
 477       (current-op-list))
 478      "/* sentinel */\n\
 479   { 0, 0, 0, 0, 0,\n    { 0, { (const PTR) 0 } },\n    { 0, { 0 } } }
 480 };
 481
 482 #undef A
 483
 484 "
 485      )
 486     )
 487 )
 488 \f
 489 ; Instruction table support.
 490
 491 ; Return C code to declare various insn bits.
 492
 493 (define (gen-insn-decls)
 494   (logit 2 "Generating instruction decls ...\n")
 495   (string-list
 496    "/* Insn attribute indices.  */\n\n"
 497    (gen-attr-enum-decl "cgen_insn" (current-insn-attr-list))
 498    )
 499 )
 500
 501 ; Generate an insn table entry for INSN.
 502 ; ALL-ATTRS is a list of all instruction attributes.
 503 ; NUM-NON-BOOLS is the number of non-boolean insn attributes.
 504
 505 (define (gen-insn-table-entry insn all-attrs num-non-bools)
 506   (gen-obj-sanitize
 507    insn
 508    (string-list
 509     "/* " (insn-syntax insn) " */\n"
 510     "  {\n"
 511     "    "
 512     (if (has-attr? insn 'ALIAS) "-1" (insn-enum insn)) ", "
 513     "\"" (obj:str-name insn) "\", "
 514     "\"" (insn-mnemonic insn) "\", "
 515     ;(if (has-attr? insn 'ALIAS) "0" (number->string (insn-length insn))) ",\n"
 516     (number->string (insn-length insn)) ",\n"
 517 ; ??? There is currently a problem with embedded newlines, and this might
 518 ; best be put in another file [the table is already pretty big].
 519 ; Might also wish to output bytecodes instead.
 520 ;    "    "
 521 ;    (if (insn-semantics insn)
 522 ;       (string-append "\""
 523 ;                      (with-output-to-string
 524 ;                        ; ??? Should we do macro expansion here?
 525 ;                        (lambda () (display (insn-semantics insn))))
 526 ;                      "\"")
 527 ;       "0")
 528 ;    ",\n"
 529     ; ??? Might wish to output the raw format spec here instead
 530     ; (either as plain text or bytecodes).
 531     ; Values could be lazily computed and cached.
 532     "    "
 533     (gen-obj-attr-defn 'insn insn all-attrs num-non-bools gen-A-attr-mask)
 534     "\n  },\n"))
 535 )
 536
 537 ; Generate insn table.
 538
 539 (define (gen-insn-table)
 540   (logit 2 "Generating instruction table ...\n")
 541   (let* ((all-attrs (current-insn-attr-list))
 542          (num-non-bools (attr-count-non-bools all-attrs)))
 543     (string-write
 544      "
 545 /* The instruction table.  */
 546
 547 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 548 "
 549      (gen-define-with-symcat "A(a) (1 << CGEN_INSN_" "a)")
 550 "
 551 static const CGEN_IBASE @arch@_cgen_insn_table[MAX_INSNS] =
 552 {
 553   /* Special null first entry.
 554      A `num' value of zero is thus invalid.
 555      Also, the special `invalid' insn resides here.  */
 556   { 0, 0, 0, 0, {0, {0}} },\n"
 557
 558      (lambda ()
 559        (string-write-map (lambda (insn)
 560                            (logit 3 "Generating insn table entry for " (obj:name insn) " ...\n")
 561                            (gen-insn-table-entry insn all-attrs num-non-bools))
 562                          (non-multi-insns (current-insn-list))))
 563
 564      "\
 565 };
 566
 567 #undef OP
 568 #undef A
 569
 570 "
 571      )
 572     )
 573 )
 574 \f
 575 ; Cpu table handling support.
 576 ;
 577 ; ??? A lot of this can live in a machine independent file, but there's
 578 ; currently no place to put this file (there's no libcgen).  libopcodes is the
 579 ; wrong place as some simulator ports use this but they don't use libopcodes.
 580
 581 ; Return C routines to open/close a cpu description table.
 582 ; This is defined here and not in cgen-opc.in because it refers to
 583 ; CGEN_{ASM,DIS}_HASH and insn_table/macro_insn_table which is defined
 584 ; earlier in the file.  ??? Things can certainly be rearranged though
 585 ; and opcodes/cgen.sh modified to insert the generated part into the middle
 586 ; of the file like is done for assembler/disassembler support.
 587
 588 (define (-gen-cpu-open)
 589   (string-append
 590    "\
 591 static const CGEN_MACH * lookup_mach_via_bfd_name
 592   PARAMS ((const CGEN_MACH *, const char *));
 593 static void build_hw_table  PARAMS ((CGEN_CPU_TABLE *));
 594 static void build_ifield_table  PARAMS ((CGEN_CPU_TABLE *));
 595 static void build_operand_table PARAMS ((CGEN_CPU_TABLE *));
 596 static void build_insn_table    PARAMS ((CGEN_CPU_TABLE *));
 597 static void @arch@_cgen_rebuild_tables PARAMS ((CGEN_CPU_TABLE *));
 598
 599 /* Subroutine of @arch@_cgen_cpu_open to look up a mach via its bfd name.  */
 600
 601 static const CGEN_MACH *
 602 lookup_mach_via_bfd_name (table, name)
 603      const CGEN_MACH *table;
 604      const char *name;
 605 {
 606   while (table->name)
 607     {
 608       if (strcmp (name, table->bfd_name) == 0)
 609         return table;
 610       ++table;
 611     }
 612   abort ();
 613 }
 614
 615 /* Subroutine of @arch@_cgen_cpu_open to build the hardware table.  */
 616
 617 static void
 618 build_hw_table (cd)
 619      CGEN_CPU_TABLE *cd;
 620 {
 621   int i;
 622   int machs = cd->machs;
 623   const CGEN_HW_ENTRY *init = & @arch@_cgen_hw_table[0];
 624   /* MAX_HW is only an upper bound on the number of selected entries.
 625      However each entry is indexed by it's enum so there can be holes in
 626      the table.  */
 627   const CGEN_HW_ENTRY **selected =
 628     (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
 629
 630   cd->hw_table.init_entries = init;
 631   cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
 632   memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
 633   /* ??? For now we just use machs to determine which ones we want.  */
 634   for (i = 0; init[i].name != NULL; ++i)
 635     if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
 636         & machs)
 637       selected[init[i].type] = &init[i];
 638   cd->hw_table.entries = selected;
 639   cd->hw_table.num_entries = MAX_HW;
 640 }
 641
 642 /* Subroutine of @arch@_cgen_cpu_open to build the hardware table.  */
 643
 644 static void
 645 build_ifield_table (cd)
 646      CGEN_CPU_TABLE *cd;
 647 {
 648   cd->ifld_table = & @arch@_cgen_ifld_table[0];
 649 }
 650
 651 /* Subroutine of @arch@_cgen_cpu_open to build the hardware table.  */
 652
 653 static void
 654 build_operand_table (cd)
 655      CGEN_CPU_TABLE *cd;
 656 {
 657   int i;
 658   int machs = cd->machs;
 659   const CGEN_OPERAND *init = & @arch@_cgen_operand_table[0];
 660   /* MAX_OPERANDS is only an upper bound on the number of selected entries.
 661      However each entry is indexed by it's enum so there can be holes in
 662      the table.  */
 663   const CGEN_OPERAND **selected =
 664     (const CGEN_OPERAND **) xmalloc (MAX_OPERANDS * sizeof (CGEN_OPERAND *));
 665
 666   cd->operand_table.init_entries = init;
 667   cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
 668   memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
 669   /* ??? For now we just use mach to determine which ones we want.  */
 670   for (i = 0; init[i].name != NULL; ++i)
 671     if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
 672         & machs)
 673       selected[init[i].type] = &init[i];
 674   cd->operand_table.entries = selected;
 675   cd->operand_table.num_entries = MAX_OPERANDS;
 676 }
 677
 678 /* Subroutine of @arch@_cgen_cpu_open to build the hardware table.
 679    ??? This could leave out insns not supported by the specified mach/isa,
 680    but that would cause errors like \"foo only supported by bar\" to become
 681    \"unknown insn\", so for now we include all insns and require the app to
 682    do the checking later.
 683    ??? On the other hand, parsing of such insns may require their hardware or
 684    operand elements to be in the table [which they mightn't be].  */
 685
 686 static void
 687 build_insn_table (cd)
 688      CGEN_CPU_TABLE *cd;
 689 {
 690   int i;
 691   const CGEN_IBASE *ib = & @arch@_cgen_insn_table[0];
 692   CGEN_INSN *insns = (CGEN_INSN *) xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
 693
 694   memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
 695   for (i = 0; i < MAX_INSNS; ++i)
 696     insns[i].base = &ib[i];
 697   cd->insn_table.init_entries = insns;
 698   cd->insn_table.entry_size = sizeof (CGEN_IBASE);
 699   cd->insn_table.num_init_entries = MAX_INSNS;
 700 }
 701
 702 /* Subroutine of @arch@_cgen_cpu_open to rebuild the tables.  */
 703
 704 static void
 705 @arch@_cgen_rebuild_tables (cd)
 706      CGEN_CPU_TABLE *cd;
 707 {
 708   int i;
 709   unsigned int isas = cd->isas;
 710   unsigned int machs = cd->machs;
 711
 712   cd->int_insn_p = CGEN_INT_INSN_P;
 713
 714   /* Data derived from the isa spec.  */
 715 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
 716   cd->default_insn_bitsize = UNSET;
 717   cd->base_insn_bitsize = UNSET;
 718   cd->min_insn_bitsize = 65535; /* some ridiculously big number */
 719   cd->max_insn_bitsize = 0;
 720   for (i = 0; i < MAX_ISAS; ++i)
 721     if (((1 << i) & isas) != 0)
 722       {
 723         const CGEN_ISA *isa = & @arch@_cgen_isa_table[i];
 724
 725         /* Default insn sizes of all selected isas must be
 726            equal or we set the result to 0, meaning \"unknown\".  */
 727         if (cd->default_insn_bitsize == UNSET)
 728           cd->default_insn_bitsize = isa->default_insn_bitsize;
 729         else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
 730           ; /* this is ok */
 731         else
 732           cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
 733
 734         /* Base insn sizes of all selected isas must be equal
 735            or we set the result to 0, meaning \"unknown\".  */
 736         if (cd->base_insn_bitsize == UNSET)
 737           cd->base_insn_bitsize = isa->base_insn_bitsize;
 738         else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
 739           ; /* this is ok */
 740         else
 741           cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
 742
 743         /* Set min,max insn sizes.  */
 744         if (isa->min_insn_bitsize < cd->min_insn_bitsize)
 745           cd->min_insn_bitsize = isa->min_insn_bitsize;
 746         if (isa->max_insn_bitsize > cd->max_insn_bitsize)
 747           cd->max_insn_bitsize = isa->max_insn_bitsize;
 748       }
 749
 750   /* Data derived from the mach spec.  */
 751   for (i = 0; i < MAX_MACHS; ++i)
 752     if (((1 << i) & machs) != 0)
 753       {
 754         const CGEN_MACH *mach = & @arch@_cgen_mach_table[i];
 755
 756         if (mach->insn_chunk_bitsize != 0)
 757         {
 758           if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
 759             {
 760               fprintf (stderr, \"@arch@_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\\n\",
 761                        cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
 762               abort ();
 763             }
 764
 765           cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
 766         }
 767       }
 768
 769   /* Determine which hw elements are used by MACH.  */
 770   build_hw_table (cd);
 771
 772   /* Build the ifield table.  */
 773   build_ifield_table (cd);
 774
 775   /* Determine which operands are used by MACH/ISA.  */
 776   build_operand_table (cd);
 777
 778   /* Build the instruction table.  */
 779   build_insn_table (cd);
 780 }
 781
 782 /* Initialize a cpu table and return a descriptor.
 783    It's much like opening a file, and must be the first function called.
 784    The arguments are a set of (type/value) pairs, terminated with
 785    CGEN_CPU_OPEN_END.
 786
 787    Currently supported values:
 788    CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
 789    CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
 790    CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
 791    CGEN_CPU_OPEN_ENDIAN:  specify endian choice
 792    CGEN_CPU_OPEN_END:     terminates arguments
 793
 794    ??? Simultaneous multiple isas might not make sense, but it's not (yet)
 795    precluded.
 796
 797    ??? We only support ISO C stdargs here, not K&R.
 798    Laziness, plus experiment to see if anything requires K&R - eventually
 799    K&R will no longer be supported - e.g. GDB is currently trying this.  */
 800
 801 CGEN_CPU_DESC
 802 @arch@_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
 803 {
 804   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
 805   static int init_p;
 806   unsigned int isas = 0;  /* 0 = \"unspecified\" */
 807   unsigned int machs = 0; /* 0 = \"unspecified\" */
 808   enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
 809   va_list ap;
 810
 811   if (! init_p)
 812     {
 813       init_tables ();
 814       init_p = 1;
 815     }
 816
 817   memset (cd, 0, sizeof (*cd));
 818
 819   va_start (ap, arg_type);
 820   while (arg_type != CGEN_CPU_OPEN_END)
 821     {
 822       switch (arg_type)
 823         {
 824         case CGEN_CPU_OPEN_ISAS :
 825           isas = va_arg (ap, unsigned int);
 826           break;
 827         case CGEN_CPU_OPEN_MACHS :
 828           machs = va_arg (ap, unsigned int);
 829           break;
 830         case CGEN_CPU_OPEN_BFDMACH :
 831           {
 832             const char *name = va_arg (ap, const char *);
 833             const CGEN_MACH *mach =
 834               lookup_mach_via_bfd_name (@arch@_cgen_mach_table, name);
 835
 836             machs |= 1 << mach->num;
 837             break;
 838           }
 839         case CGEN_CPU_OPEN_ENDIAN :
 840           endian = va_arg (ap, enum cgen_endian);
 841           break;
 842         default :
 843           fprintf (stderr, \"@arch@_cgen_cpu_open: unsupported argument `%d'\\n\",
 844                    arg_type);
 845           abort (); /* ??? return NULL? */
 846         }
 847       arg_type = va_arg (ap, enum cgen_cpu_open_arg);
 848     }
 849   va_end (ap);
 850
 851   /* mach unspecified means \"all\" */
 852   if (machs == 0)
 853     machs = (1 << MAX_MACHS) - 1;
 854   /* base mach is always selected */
 855   machs |= 1;
 856   /* isa unspecified means \"all\" */
 857   if (isas == 0)
 858     isas = (1 << MAX_ISAS) - 1;
 859   if (endian == CGEN_ENDIAN_UNKNOWN)
 860     {
 861       /* ??? If target has only one, could have a default.  */
 862       fprintf (stderr, \"@arch@_cgen_cpu_open: no endianness specified\\n\");
 863       abort ();
 864     }
 865
 866   cd->isas = isas;
 867   cd->machs = machs;
 868   cd->endian = endian;
 869   /* FIXME: for the sparc case we can determine insn-endianness statically.
 870      The worry here is where both data and insn endian can be independently
 871      chosen, in which case this function will need another argument.
 872      Actually, will want to allow for more arguments in the future anyway.  */
 873   cd->insn_endian = endian;
 874
 875   /* Table (re)builder.  */
 876   cd->rebuild_tables = @arch@_cgen_rebuild_tables;
 877   @arch@_cgen_rebuild_tables (cd);
 878
 879   /* Default to not allowing signed overflow.  */
 880   cd->signed_overflow_ok_p = 0;
 881
 882   return (CGEN_CPU_DESC) cd;
 883 }
 884
 885 /* Cover fn to @arch@_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
 886    MACH_NAME is the bfd name of the mach.  */
 887
 888 CGEN_CPU_DESC
 889 @arch@_cgen_cpu_open_1 (mach_name, endian)
 890      const char *mach_name;
 891      enum cgen_endian endian;
 892 {
 893   return @arch@_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
 894                                CGEN_CPU_OPEN_ENDIAN, endian,
 895                                CGEN_CPU_OPEN_END);
 896 }
 897
 898 /* Close a cpu table.
 899    ??? This can live in a machine independent file, but there's currently
 900    no place to put this file (there's no libcgen).  libopcodes is the wrong
 901    place as some simulator ports use this but they don't use libopcodes.  */
 902
 903 void
 904 @arch@_cgen_cpu_close (cd)
 905      CGEN_CPU_DESC cd;
 906 {
 907   unsigned int i;
 908   const CGEN_INSN *insns;
 909
 910   if (cd->macro_insn_table.init_entries)
 911     {
 912       insns = cd->macro_insn_table.init_entries;
 913       for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
 914         {
 915           if (CGEN_INSN_RX ((insns)))
 916             regfree (CGEN_INSN_RX (insns));
 917         }
 918     }
 919
 920   if (cd->insn_table.init_entries)
 921     {
 922       insns = cd->insn_table.init_entries;
 923       for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
 924         {
 925           if (CGEN_INSN_RX (insns))
 926             regfree (CGEN_INSN_RX (insns));
 927         }
 928     }
 929
 930
 931
 932   if (cd->macro_insn_table.init_entries)
 933     free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
 934
 935   if (cd->insn_table.init_entries)
 936     free ((CGEN_INSN *) cd->insn_table.init_entries);
 937
 938   if (cd->hw_table.entries)
 939     free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
 940
 941   if (cd->operand_table.entries)
 942     free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
 943
 944   free (cd);
 945 }
 946
 947 ")
 948 )
 949
 950 ; General initialization C code
 951 ; Code is appended during processing.
 952
 953 (define -cputab-init-code "")
 954 (define (cputab-add-init! code)
 955   (set! -cputab-init-code (string-append -cputab-init-code code))
 956 )
 957
 958 ; Return the C code to define the various initialization functions.
 959 ; This does not include assembler/disassembler specific stuff.
 960 ; Generally, this function doesn't do anything.
 961 ; It exists to allow a global-static-constructor kind of thing should
 962 ; one ever be necessary.
 963
 964 (define (gen-init-fns)
 965   (logit 2 "Generating init fns ...\n")
 966   (string-append
 967    "\
 968 /* Initialize anything needed to be done once, before any cpu_open call.  */
 969 static void init_tables PARAMS ((void));
 970
 971 static void
 972 init_tables ()
 973 {\n"
 974    -cputab-init-code
 975    "}\n\n"
 976   )
 977 )
 978 \f
 979 ; Top level C code generators
 980
 981 ; FIXME: Create enum objects for all the enums we explicitly declare here.
 982 ; Then they'd be usable and we wouldn't have to special case them here.
 983
 984 (define (cgen-desc.h)
 985   (logit 1 "Generating " (current-arch-name) " desc.h ...\n")
 986   (string-write
 987    (gen-c-copyright "CPU data header for @arch@."
 988                   CURRENT-COPYRIGHT CURRENT-PACKAGE)
 989    "\
 990 #ifndef @ARCH@_CPU_H
 991 #define @ARCH@_CPU_H
 992
 993 "
 994    -gen-hash-defines
 995    ; This is defined in arch.h.  It's not defined here as there is yet to
 996    ; be a need for it in the assembler/disassembler.
 997    ;(gen-enum-decl 'model_type "model types"
 998    ;              "MODEL_"
 999    ;              (append (map list (map obj:name (current-model-list))) '((max))))
1000    ;"#define MAX_MODELS ((int) MODEL_MAX)\n\n"
1001    "/* Enums.  */\n\n"
1002    (string-map gen-decl (current-enum-list))
1003    "/* Attributes.  */\n\n"
1004    (string-map gen-decl (current-attr-list))
1005    "/* Number of architecture variants.  */\n"
1006    ; If there is only 1 isa, leave out special handling.  */
1007    (if (= (length (current-isa-list)) 1)
1008        "#define MAX_ISAS  1\n"
1009        "#define MAX_ISAS  ((int) ISA_MAX)\n")
1010    "#define MAX_MACHS ((int) MACH_MAX)\n\n"
1011    gen-ifld-decls
1012    gen-hw-decls
1013    gen-operand-decls
1014    gen-insn-decls
1015    "/* cgen.h uses things we just defined.  */\n"
1016    "#include \"opcode/cgen.h\"\n\n"
1017    -gen-attr-table-decls
1018    -gen-mach-table-decls
1019    gen-hw-table-decls
1020    "\n"
1021    (lambda () (gen-extra-cpu.h (opc-file-path) (current-arch-name)))
1022    "
1023
1024 #endif /* @ARCH@_CPU_H */
1025 "
1026    )
1027 )
1028
1029 ; This file contains the "top level" definitions of the cpu.
1030 ; This includes various elements of the description file, expressed in C.
1031 ;
1032 ; ??? A lot of this file can go in a machine-independent file!  However,
1033 ; some simulators don't use the cgen opcodes support so there is currently
1034 ; no place to put this file.  To be revisited when we do have such a place.
1035
1036 (define (cgen-desc.c)
1037   (logit 1 "Generating " (current-arch-name) " desc.c ...\n")
1038   (string-write
1039    (gen-c-copyright "CPU data for @arch@."
1040                   CURRENT-COPYRIGHT CURRENT-PACKAGE)
1041    "\
1042 #include \"sysdep.h\"
1043 #include <stdio.h>
1044 #include <stdarg.h>
1045 #include \"ansidecl.h\"
1046 #include \"bfd.h\"
1047 #include \"symcat.h\"
1048 #include \"@arch@-desc.h\"
1049 #include \"@arch@-opc.h\"
1050 #include \"opintl.h\"
1051 #include \"libiberty.h\"
1052 #include \"xregex.h\"
1053 \n"
1054    (lambda () (gen-extra-cpu.c (opc-file-path) (current-arch-name)))
1055    gen-attr-table-defns
1056    -gen-isa-table-defns
1057    -gen-mach-table-defns
1058    gen-hw-table-defns
1059    gen-ifld-defns
1060    gen-multi-ifield-nodes
1061    gen-operand-table
1062    gen-insn-table
1063    gen-init-fns
1064    -gen-cpu-open
1065    )
1066 )