sim/igen/igen.c

   1 /* The IGEN simulator generator for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2013 Free Software Foundation, Inc.
   4
   5    Contributed by Andrew Cagney.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22
  23
  24 #include <getopt.h>
  25
  26 #include "misc.h"
  27 #include "lf.h"
  28 #include "table.h"
  29 #include "config.h"
  30 #include "filter.h"
  31
  32 #include "igen.h"
  33
  34 #include "ld-insn.h"
  35 #include "ld-decode.h"
  36 #include "ld-cache.h"
  37
  38 #include "gen.h"
  39
  40 #include "gen-model.h"
  41 #include "gen-icache.h"
  42 #include "gen-itable.h"
  43 #include "gen-idecode.h"
  44 #include "gen-semantics.h"
  45 #include "gen-engine.h"
  46 #include "gen-support.h"
  47 #include "gen-engine.h"
  48
  49
  50 /****************************************************************/
  51
  52
  53 /* Semantic functions */
  54
  55 int
  56 print_semantic_function_formal (lf *file, int nr_prefetched_words)
  57 {
  58   int nr = 0;
  59   int word_nr;
  60   if (options.gen.icache || nr_prefetched_words < 0)
  61     {
  62       nr += lf_printf (file, "SIM_DESC sd,\n");
  63       nr += lf_printf (file, "%sidecode_cache *cache_entry,\n",
  64                        options.module.global.prefix.l);
  65       nr += lf_printf (file, "%sinstruction_address cia",
  66                        options.module.global.prefix.l);
  67     }
  68   else if (options.gen.smp)
  69     {
  70       nr += lf_printf (file, "sim_cpu *cpu,\n");
  71       for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
  72         {
  73           nr += lf_printf (file, "%sinstruction_word instruction_%d,\n",
  74                            options.module.global.prefix.l, word_nr);
  75         }
  76       nr += lf_printf (file, "%sinstruction_address cia",
  77                        options.module.global.prefix.l);
  78     }
  79   else
  80     {
  81       nr += lf_printf (file, "SIM_DESC sd,\n");
  82       for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
  83         {
  84           nr += lf_printf (file, "%sinstruction_word instruction_%d,\n",
  85                            options.module.global.prefix.l, word_nr);
  86         }
  87       nr += lf_printf (file, "%sinstruction_address cia",
  88                        options.module.global.prefix.l);
  89     }
  90   return nr;
  91 }
  92
  93 int
  94 print_semantic_function_actual (lf *file, int nr_prefetched_words)
  95 {
  96   int nr = 0;
  97   int word_nr;
  98   if (options.gen.icache || nr_prefetched_words < 0)
  99     {
 100       nr += lf_printf (file, "sd, cache_entry, cia");
 101     }
 102   else
 103     {
 104       if (options.gen.smp)
 105         nr += lf_printf (file, "cpu");
 106       else
 107         nr += lf_printf (file, "sd");
 108       for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
 109         nr += lf_printf (file, ", instruction_%d", word_nr);
 110       nr += lf_printf (file, ", cia");
 111     }
 112   return nr;
 113 }
 114
 115 int
 116 print_semantic_function_type (lf *file)
 117 {
 118   int nr = 0;
 119   nr += lf_printf (file, "%sinstruction_address",
 120                    options.module.global.prefix.l);
 121   return nr;
 122 }
 123
 124
 125 /* Idecode functions */
 126
 127 int
 128 print_icache_function_formal (lf *file, int nr_prefetched_words)
 129 {
 130   int nr = 0;
 131   int word_nr;
 132   if (options.gen.smp)
 133     nr += lf_printf (file, "sim_cpu *cpu,\n");
 134   else
 135     nr += lf_printf (file, "SIM_DESC sd,\n");
 136   for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
 137     nr += lf_printf (file, " %sinstruction_word instruction_%d,\n",
 138                      options.module.global.prefix.l, word_nr);
 139   nr += lf_printf (file, " %sinstruction_address cia,\n",
 140                    options.module.global.prefix.l);
 141   nr += lf_printf (file, " %sidecode_cache *cache_entry",
 142                    options.module.global.prefix.l);
 143   return nr;
 144 }
 145
 146 int
 147 print_icache_function_actual (lf *file, int nr_prefetched_words)
 148 {
 149   int nr = 0;
 150   int word_nr;
 151   if (options.gen.smp)
 152     nr += lf_printf (file, "cpu");
 153   else
 154     nr += lf_printf (file, "sd");
 155   for (word_nr = 0; word_nr < nr_prefetched_words; word_nr++)
 156     nr += lf_printf (file, ", instruction_%d", word_nr);
 157   nr += lf_printf (file, ", cia, cache_entry");
 158   return nr;
 159 }
 160
 161 int
 162 print_icache_function_type (lf *file)
 163 {
 164   int nr;
 165   if (options.gen.semantic_icache)
 166     {
 167       nr = print_semantic_function_type (file);
 168     }
 169   else
 170     {
 171       nr = lf_printf (file, "%sidecode_semantic *",
 172                       options.module.global.prefix.l);
 173     }
 174   return nr;
 175 }
 176
 177
 178 /* Function names */
 179
 180 static int
 181 print_opcode_bits (lf *file, opcode_bits *bits)
 182 {
 183   int nr = 0;
 184   if (bits == NULL)
 185     return nr;
 186   nr += lf_putchr (file, '_');
 187   nr += lf_putstr (file, bits->field->val_string);
 188   if (bits->opcode->is_boolean && bits->value == 0)
 189     nr += lf_putint (file, bits->opcode->boolean_constant);
 190   else if (!bits->opcode->is_boolean)
 191     {
 192       if (bits->opcode->last < bits->field->last)
 193         nr +=
 194           lf_putint (file,
 195                      bits->value << (bits->field->last - bits->opcode->last));
 196       else
 197         nr += lf_putint (file, bits->value);
 198     }
 199   nr += print_opcode_bits (file, bits->next);
 200   return nr;
 201 }
 202
 203 static int
 204 print_c_name (lf *file, const char *name)
 205 {
 206   int nr = 0;
 207   const char *pos;
 208   for (pos = name; *pos != '\0'; pos++)
 209     {
 210       switch (*pos)
 211         {
 212         case '/':
 213         case '-':
 214           break;
 215         case ' ':
 216         case '.':
 217           nr += lf_putchr (file, '_');
 218           break;
 219         default:
 220           nr += lf_putchr (file, *pos);
 221           break;
 222         }
 223     }
 224   return nr;
 225 }
 226
 227 extern int
 228 print_function_name (lf *file,
 229                      const char *basename,
 230                      const char *format_name,
 231                      const char *model_name,
 232                      opcode_bits *expanded_bits,
 233                      lf_function_name_prefixes prefix)
 234 {
 235   int nr = 0;
 236   /* the prefix */
 237   switch (prefix)
 238     {
 239     case function_name_prefix_semantics:
 240       nr += lf_printf (file, "%s", options.module.semantics.prefix.l);
 241       nr += lf_printf (file, "semantic_");
 242       break;
 243     case function_name_prefix_idecode:
 244       nr += lf_printf (file, "%s", options.module.idecode.prefix.l);
 245       nr += lf_printf (file, "idecode_");
 246       break;
 247     case function_name_prefix_itable:
 248       nr += lf_printf (file, "%sitable_", options.module.itable.prefix.l);
 249       break;
 250     case function_name_prefix_icache:
 251       nr += lf_printf (file, "%s", options.module.icache.prefix.l);
 252       nr += lf_printf (file, "icache_");
 253       break;
 254     case function_name_prefix_engine:
 255       nr += lf_printf (file, "%s", options.module.engine.prefix.l);
 256       nr += lf_printf (file, "engine_");
 257     default:
 258       break;
 259     }
 260
 261   if (model_name != NULL)
 262     {
 263       nr += print_c_name (file, model_name);
 264       nr += lf_printf (file, "_");
 265     }
 266
 267   /* the function name */
 268   nr += print_c_name (file, basename);
 269
 270   /* the format name if available */
 271   if (format_name != NULL)
 272     {
 273       nr += lf_printf (file, "_");
 274       nr += print_c_name (file, format_name);
 275     }
 276
 277   /* the suffix */
 278   nr += print_opcode_bits (file, expanded_bits);
 279
 280   return nr;
 281 }
 282
 283
 284 void
 285 print_my_defines (lf *file,
 286                   const char *basename,
 287                   const char *format_name, opcode_bits *expanded_bits)
 288 {
 289   /* #define MY_INDEX xxxxx */
 290   lf_indent_suppress (file);
 291   lf_printf (file, "#undef MY_INDEX\n");
 292   lf_indent_suppress (file);
 293   lf_printf (file, "#define MY_INDEX ");
 294   print_function_name (file,
 295                        basename, format_name, NULL,
 296                        NULL, function_name_prefix_itable);
 297   lf_printf (file, "\n");
 298   /* #define MY_PREFIX xxxxxx */
 299   lf_indent_suppress (file);
 300   lf_printf (file, "#undef ");
 301   print_function_name (file,
 302                        basename, format_name, NULL,
 303                        expanded_bits, function_name_prefix_none);
 304   lf_printf (file, "\n");
 305   lf_indent_suppress (file);
 306   lf_printf (file, "#undef MY_PREFIX\n");
 307   lf_indent_suppress (file);
 308   lf_printf (file, "#define MY_PREFIX ");
 309   print_function_name (file,
 310                        basename, format_name, NULL,
 311                        expanded_bits, function_name_prefix_none);
 312   lf_printf (file, "\n");
 313   /* #define MY_NAME xxxxxx */
 314   lf_indent_suppress (file);
 315   lf_indent_suppress (file);
 316   lf_printf (file, "#undef MY_NAME\n");
 317   lf_indent_suppress (file);
 318   lf_printf (file, "#define MY_NAME \"");
 319   print_function_name (file,
 320                        basename, format_name, NULL,
 321                        expanded_bits, function_name_prefix_none);
 322   lf_printf (file, "\"\n");
 323 }
 324
 325
 326 static int
 327 print_itrace_prefix (lf *file)
 328 {
 329   const char *prefix = "trace_prefix (";
 330   int indent = strlen (prefix);
 331   lf_printf (file, "%sSD, CPU, cia, CIA, TRACE_LINENUM_P (CPU), \\\n",
 332              prefix);
 333   lf_indent (file, +indent);
 334   lf_printf (file, "%sitable[MY_INDEX].file, \\\n",
 335              options.module.itable.prefix.l);
 336   lf_printf (file, "%sitable[MY_INDEX].line_nr, \\\n",
 337              options.module.itable.prefix.l);
 338   lf_printf (file, "\"");
 339   return indent;
 340 }
 341
 342
 343 static void
 344 print_itrace_format (lf *file, insn_mnemonic_entry *assembler)
 345 {
 346   /* pass=1 is fmt string; pass=2 is arguments */
 347   int pass;
 348   /* print the format string */
 349   for (pass = 1; pass <= 2; pass++)
 350     {
 351       const char *chp = assembler->format;
 352       chp++;                    /* skip the leading quote */
 353       /* write out the format/args */
 354       while (*chp != '\0')
 355         {
 356           if (chp[0] == '\\' && (chp[1] == '<' || chp[1] == '>'))
 357             {
 358               if (pass == 1)
 359                 lf_putchr (file, chp[1]);
 360               chp += 2;
 361             }
 362           else if (chp[0] == '<' || chp[0] == '%')
 363             {
 364               /* parse [ "%" ... ] "<" [ func "#" ] param ">" */
 365               const char *fmt;
 366               const char *func;
 367               int strlen_func;
 368               const char *param;
 369               int strlen_param;
 370               /* the "%" ... "<" format */
 371               fmt = chp;
 372               while (chp[0] != '<' && chp[0] != '\0')
 373                 chp++;
 374               if (chp[0] != '<')
 375                 error (assembler->line, "Missing `<' after `%%'\n");
 376               chp++;
 377               /* [ "func" # ] OR "param" */
 378               func = chp;
 379               param = chp;
 380               while (chp[0] != '>' && chp[0] != '#' && chp[0] != '\0')
 381                 chp++;
 382               strlen_func = chp - func;
 383               if (chp[0] == '#')
 384                 {
 385                   chp++;
 386                   param = chp;
 387                   while (chp[0] != '>' && chp[0] != '\0')
 388                     chp++;
 389                 }
 390               strlen_param = chp - param;
 391               if (chp[0] != '>')
 392                 error (assembler->line,
 393                        "Missing closing `>' in assembler string\n");
 394               chp++;
 395               /* now process it */
 396               if (pass == 2)
 397                 lf_printf (file, ", \\\n");
 398               if (strncmp (fmt, "<", 1) == 0)
 399                 /* implicit long int format */
 400                 {
 401                   if (pass == 1)
 402                     lf_printf (file, "%%ld");
 403                   else
 404                     {
 405                       lf_printf (file, "(long) ");
 406                       lf_write (file, param, strlen_param);
 407                     }
 408                 }
 409               else if (strncmp (fmt, "%<", 2) == 0)
 410                 /* explicit format */
 411                 {
 412                   if (pass == 1)
 413                     lf_printf (file, "%%");
 414                   else
 415                     lf_write (file, param, strlen_param);
 416                 }
 417               else if (strncmp (fmt, "%s<", 3) == 0)
 418                 /* string format */
 419                 {
 420                   if (pass == 1)
 421                     lf_printf (file, "%%s");
 422                   else
 423                     {
 424                       lf_printf (file, "%sstr_",
 425                                  options.module.global.prefix.l);
 426                       lf_write (file, func, strlen_func);
 427                       lf_printf (file, " (SD_, ");
 428                       lf_write (file, param, strlen_param);
 429                       lf_printf (file, ")");
 430                     }
 431                 }
 432               else if (strncmp (fmt, "%lx<", 4) == 0)
 433                 /* simple hex */
 434                 {
 435                   if (pass == 1)
 436                     lf_printf (file, "%%lx");
 437                   else
 438                     {
 439                       lf_printf (file, "(unsigned long) ");
 440                       lf_write (file, param, strlen_param);
 441                     }
 442                 }
 443               else if (strncmp (fmt, "%#lx<", 5) == 0)
 444                 /* simple hex with 0x prefix */
 445                 {
 446                   if (pass == 1)
 447                     lf_printf (file, "%%#lx");
 448                   else
 449                     {
 450                       lf_printf (file, "(unsigned long) ");
 451                       lf_write (file, param, strlen_param);
 452                     }
 453                 }
 454               else if (strncmp (fmt, "%08lx<", 6) == 0)
 455                 /* simple hex */
 456                 {
 457                   if (pass == 1)
 458                     lf_printf (file, "%%08lx");
 459                   else
 460                     {
 461                       lf_printf (file, "(unsigned long) ");
 462                       lf_write (file, param, strlen_param);
 463                     }
 464                 }
 465               else
 466                 error (assembler->line, "Unknown assembler string format\n");
 467             }
 468           else
 469             {
 470               if (pass == 1)
 471                 lf_putchr (file, chp[0]);
 472               chp += 1;
 473             }
 474         }
 475     }
 476   lf_printf (file, ");\n");
 477 }
 478
 479
 480 void
 481 print_itrace (lf *file, insn_entry * insn, int idecode)
 482 {
 483   /* NB: Here we escape each EOLN. This is so that the the compiler
 484      treats a trace function call as a single line.  Consequently any
 485      errors in the line are refered back to the same igen assembler
 486      source line */
 487   const char *phase = (idecode) ? "DECODE" : "INSN";
 488   lf_printf (file, "\n");
 489   lf_indent_suppress (file);
 490   lf_printf (file, "#if defined (WITH_TRACE)\n");
 491   lf_printf (file, "/* generate a trace prefix if any tracing enabled */\n");
 492   lf_printf (file, "if (TRACE_ANY_P (CPU))\n");
 493   lf_printf (file, "  {\n");
 494   lf_indent (file, +4);
 495   {
 496     if (insn->mnemonics != NULL)
 497       {
 498         insn_mnemonic_entry *assembler = insn->mnemonics;
 499         int is_first = 1;
 500         do
 501           {
 502             if (assembler->condition != NULL)
 503               {
 504                 int indent;
 505                 lf_printf (file, "%sif (%s)\n",
 506                            is_first ? "" : "else ", assembler->condition);
 507                 lf_indent (file, +2);
 508                 lf_print__line_ref (file, assembler->line);
 509                 indent = print_itrace_prefix (file);
 510                 print_itrace_format (file, assembler);
 511                 lf_print__internal_ref (file);
 512                 lf_indent (file, -indent);
 513                 lf_indent (file, -2);
 514                 if (assembler->next == NULL)
 515                   error (assembler->line,
 516                          "Missing final unconditional assembler\n");
 517               }
 518             else
 519               {
 520                 int indent;
 521                 if (!is_first)
 522                   {
 523                     lf_printf (file, "else\n");
 524                     lf_indent (file, +2);
 525                   }
 526                 lf_print__line_ref (file, assembler->line);
 527                 indent = print_itrace_prefix (file);
 528                 print_itrace_format (file, assembler);
 529                 lf_print__internal_ref (file);
 530                 lf_indent (file, -indent);
 531                 if (!is_first)
 532                   lf_indent (file, -2);
 533                 if (assembler->next != NULL)
 534                   error (assembler->line,
 535                          "Unconditional assembler is not last\n");
 536               }
 537             is_first = 0;
 538             assembler = assembler->next;
 539           }
 540         while (assembler != NULL);
 541       }
 542     else
 543       {
 544         int indent;
 545         lf_indent (file, +2);
 546         lf_print__line_ref (file, insn->line);
 547         indent = print_itrace_prefix (file);
 548         lf_printf (file, "%%s\", \\\n");
 549         lf_printf (file, "itable[MY_INDEX].name);\n");
 550         lf_print__internal_ref (file);
 551         lf_indent (file, -indent);
 552         lf_indent (file, -2);
 553       }
 554     lf_printf (file, "/* trace the instruction execution if enabled */\n");
 555     lf_printf (file, "if (TRACE_%s_P (CPU))\n", phase);
 556     lf_printf (file,
 557                "  trace_generic (SD, CPU, TRACE_%s_IDX, \" %%s\", itable[MY_INDEX].name);\n",
 558                phase);
 559   }
 560   lf_indent (file, -4);
 561   lf_printf (file, "  }\n");
 562   lf_indent_suppress (file);
 563   lf_printf (file, "#endif\n");
 564 }
 565
 566
 567 void
 568 print_sim_engine_abort (lf *file, const char *message)
 569 {
 570   lf_printf (file, "sim_engine_abort (SD, CPU, cia, ");
 571   lf_printf (file, "\"%s\"", message);
 572   lf_printf (file, ");\n");
 573 }
 574
 575
 576 void
 577 print_include (lf *file, igen_module module)
 578 {
 579   lf_printf (file, "#include \"%s%s.h\"\n", module.prefix.l, module.suffix.l);
 580 }
 581
 582 void
 583 print_include_inline (lf *file, igen_module module)
 584 {
 585   lf_printf (file, "#if C_REVEALS_MODULE_P (%s_INLINE)\n", module.suffix.u);
 586   lf_printf (file, "#include \"%s%s.c\"\n", module.prefix.l, module.suffix.l);
 587   lf_printf (file, "#else\n");
 588   print_include (file, module);
 589   lf_printf (file, "#endif\n");
 590   lf_printf (file, "\n");
 591 }
 592
 593 void
 594 print_includes (lf *file)
 595 {
 596   lf_printf (file, "\n");
 597   lf_printf (file, "#include \"sim-inline.c\"\n");
 598   lf_printf (file, "\n");
 599   print_include_inline (file, options.module.itable);
 600   print_include_inline (file, options.module.idecode);
 601   print_include_inline (file, options.module.support);
 602 }
 603
 604
 605 /****************************************************************/
 606
 607
 608 static void
 609 gen_semantics_h (lf *file, insn_list *semantics, int max_nr_words)
 610 {
 611   int word_nr;
 612   insn_list *semantic;
 613   for (word_nr = -1; word_nr <= max_nr_words; word_nr++)
 614     {
 615       lf_printf (file, "typedef ");
 616       print_semantic_function_type (file);
 617       lf_printf (file, " %sidecode_semantic", options.module.global.prefix.l);
 618       if (word_nr >= 0)
 619         lf_printf (file, "_%d", word_nr);
 620       lf_printf (file, "\n(");
 621       lf_indent (file, +1);
 622       print_semantic_function_formal (file, word_nr);
 623       lf_indent (file, -1);
 624       lf_printf (file, ");\n");
 625       lf_printf (file, "\n");
 626     }
 627   switch (options.gen.code)
 628     {
 629     case generate_calls:
 630       for (semantic = semantics; semantic != NULL; semantic = semantic->next)
 631         {
 632           /* Ignore any special/internal instructions */
 633           if (semantic->insn->nr_words == 0)
 634             continue;
 635           print_semantic_declaration (file,
 636                                       semantic->insn,
 637                                       semantic->expanded_bits,
 638                                       semantic->opcodes,
 639                                       semantic->nr_prefetched_words);
 640         }
 641       break;
 642     case generate_jumps:
 643       lf_print__this_file_is_empty (file, "generating jumps");
 644       break;
 645     }
 646 }
 647
 648
 649 static void
 650 gen_semantics_c (lf *file, insn_list *semantics, cache_entry *cache_rules)
 651 {
 652   if (options.gen.code == generate_calls)
 653     {
 654       insn_list *semantic;
 655       print_includes (file);
 656       print_include (file, options.module.semantics);
 657       lf_printf (file, "\n");
 658
 659       for (semantic = semantics; semantic != NULL; semantic = semantic->next)
 660         {
 661           /* Ignore any special/internal instructions */
 662           if (semantic->insn->nr_words == 0)
 663             continue;
 664           print_semantic_definition (file,
 665                                      semantic->insn,
 666                                      semantic->expanded_bits,
 667                                      semantic->opcodes,
 668                                      cache_rules,
 669                                      semantic->nr_prefetched_words);
 670         }
 671     }
 672   else
 673     {
 674       lf_print__this_file_is_empty (file, "generating jump engine");
 675     }
 676 }
 677
 678
 679 /****************************************************************/
 680
 681
 682 static void
 683 gen_icache_h (lf *file,
 684               insn_list *semantic,
 685               function_entry * functions, int max_nr_words)
 686 {
 687   int word_nr;
 688   for (word_nr = 0; word_nr <= max_nr_words; word_nr++)
 689     {
 690       lf_printf (file, "typedef ");
 691       print_icache_function_type (file);
 692       lf_printf (file, " %sidecode_icache_%d\n(",
 693                  options.module.global.prefix.l, word_nr);
 694       print_icache_function_formal (file, word_nr);
 695       lf_printf (file, ");\n");
 696       lf_printf (file, "\n");
 697     }
 698   if (options.gen.code == generate_calls && options.gen.icache)
 699     {
 700       function_entry_traverse (file, functions,
 701                                print_icache_internal_function_declaration,
 702                                NULL);
 703       while (semantic != NULL)
 704         {
 705           print_icache_declaration (file,
 706                                     semantic->insn,
 707                                     semantic->expanded_bits,
 708                                     semantic->opcodes,
 709                                     semantic->nr_prefetched_words);
 710           semantic = semantic->next;
 711         }
 712     }
 713   else
 714     {
 715       lf_print__this_file_is_empty (file, "generating jump engine");
 716     }
 717 }
 718
 719 static void
 720 gen_icache_c (lf *file,
 721               insn_list *semantic,
 722               function_entry * functions, cache_entry *cache_rules)
 723 {
 724   /* output `internal' invalid/floating-point unavailable functions
 725      where needed */
 726   if (options.gen.code == generate_calls && options.gen.icache)
 727     {
 728       lf_printf (file, "\n");
 729       lf_printf (file, "#include \"cpu.h\"\n");
 730       lf_printf (file, "#include \"idecode.h\"\n");
 731       lf_printf (file, "#include \"semantics.h\"\n");
 732       lf_printf (file, "#include \"icache.h\"\n");
 733       lf_printf (file, "#include \"support.h\"\n");
 734       lf_printf (file, "\n");
 735       function_entry_traverse (file, functions,
 736                                print_icache_internal_function_definition,
 737                                NULL);
 738       lf_printf (file, "\n");
 739       while (semantic != NULL)
 740         {
 741           print_icache_definition (file,
 742                                    semantic->insn,
 743                                    semantic->expanded_bits,
 744                                    semantic->opcodes,
 745                                    cache_rules,
 746                                    semantic->nr_prefetched_words);
 747           semantic = semantic->next;
 748         }
 749     }
 750   else
 751     {
 752       lf_print__this_file_is_empty (file, "generating jump engine");
 753     }
 754 }
 755
 756
 757 /****************************************************************/
 758
 759
 760 static void
 761 gen_idecode_h (lf *file,
 762                gen_table *gen, insn_table *insns, cache_entry *cache_rules)
 763 {
 764   lf_printf (file, "typedef unsigned%d %sinstruction_word;\n",
 765              options.insn_bit_size, options.module.global.prefix.l);
 766   if (options.gen.delayed_branch)
 767     {
 768       lf_printf (file, "typedef struct _%sinstruction_address {\n",
 769                  options.module.global.prefix.l);
 770       lf_printf (file, "  address_word ip; /* instruction pointer */\n");
 771       lf_printf (file, "  address_word dp; /* delayed-slot pointer */\n");
 772       lf_printf (file, "} %sinstruction_address;\n",
 773                  options.module.global.prefix.l);
 774     }
 775   else
 776     {
 777       lf_printf (file, "typedef address_word %sinstruction_address;\n",
 778                  options.module.global.prefix.l);
 779
 780     }
 781   if (options.gen.nia == nia_is_invalid
 782       && strlen (options.module.global.prefix.u) > 0)
 783     {
 784       lf_indent_suppress (file);
 785       lf_printf (file, "#define %sINVALID_INSTRUCTION_ADDRESS ",
 786                  options.module.global.prefix.u);
 787       lf_printf (file, "INVALID_INSTRUCTION_ADDRESS\n");
 788     }
 789   lf_printf (file, "\n");
 790   print_icache_struct (file, insns, cache_rules);
 791   lf_printf (file, "\n");
 792   if (options.gen.icache)
 793     {
 794       ERROR ("FIXME - idecode with icache suffering from bit-rot");
 795     }
 796   else
 797     {
 798       gen_list *entry;
 799       for (entry = gen->tables; entry != NULL; entry = entry->next)
 800         {
 801           print_idecode_issue_function_header (file,
 802                                                (options.gen.multi_sim
 803                                                 ? entry->model->name
 804                                                 : NULL),
 805                                                is_function_declaration,
 806                                                1 /*ALWAYS ONE WORD */ );
 807         }
 808       if (options.gen.multi_sim)
 809         {
 810           print_idecode_issue_function_header (file,
 811                                                NULL,
 812                                                is_function_variable,
 813                                                1 /*ALWAYS ONE WORD */ );
 814         }
 815     }
 816 }
 817
 818
 819 static void
 820 gen_idecode_c (lf *file,
 821                gen_table *gen, insn_table *isa, cache_entry *cache_rules)
 822 {
 823   /* the intro */
 824   print_includes (file);
 825   print_include_inline (file, options.module.semantics);
 826   lf_printf (file, "\n");
 827
 828   print_idecode_globals (file);
 829   lf_printf (file, "\n");
 830
 831   switch (options.gen.code)
 832     {
 833     case generate_calls:
 834       {
 835         gen_list *entry;
 836         for (entry = gen->tables; entry != NULL; entry = entry->next)
 837           {
 838             print_idecode_lookups (file, entry->table, cache_rules);
 839
 840             /* output the main idecode routine */
 841             if (!options.gen.icache)
 842               {
 843                 print_idecode_issue_function_header (file,
 844                                                      (options.gen.multi_sim
 845                                                       ? entry->model->name
 846                                                       : NULL),
 847                                                      1 /*is definition */ ,
 848                                                      1 /*ALWAYS ONE WORD */ );
 849                 lf_printf (file, "{\n");
 850                 lf_indent (file, +2);
 851                 lf_printf (file, "%sinstruction_address nia;\n",
 852                            options.module.global.prefix.l);
 853                 print_idecode_body (file, entry->table, "nia =");
 854                 lf_printf (file, "return nia;");
 855                 lf_indent (file, -2);
 856                 lf_printf (file, "}\n");
 857               }
 858           }
 859         break;
 860       }
 861     case generate_jumps:
 862       {
 863         lf_print__this_file_is_empty (file, "generating a jump engine");
 864         break;
 865       }
 866     }
 867 }
 868
 869
 870 /****************************************************************/
 871
 872
 873 static void
 874 gen_run_c (lf *file, gen_table *gen)
 875 {
 876   gen_list *entry;
 877   lf_printf (file, "#include \"sim-main.h\"\n");
 878   lf_printf (file, "#include \"engine.h\"\n");
 879   lf_printf (file, "#include \"idecode.h\"\n");
 880   lf_printf (file, "#include \"bfd.h\"\n");
 881   lf_printf (file, "\n");
 882
 883   if (options.gen.multi_sim)
 884     {
 885       print_idecode_issue_function_header (file, NULL, is_function_variable,
 886                                            1);
 887       lf_printf (file, "\n");
 888       print_engine_run_function_header (file, NULL, is_function_variable);
 889       lf_printf (file, "\n");
 890     }
 891
 892   lf_printf (file, "void\n");
 893   lf_printf (file, "sim_engine_run (SIM_DESC sd,\n");
 894   lf_printf (file, "                int next_cpu_nr,\n");
 895   lf_printf (file, "                int nr_cpus,\n");
 896   lf_printf (file, "                int siggnal)\n");
 897   lf_printf (file, "{\n");
 898   lf_indent (file, +2);
 899   if (options.gen.multi_sim)
 900     {
 901       lf_printf (file, "int mach;\n");
 902       lf_printf (file, "if (STATE_ARCHITECTURE (sd) == NULL)\n");
 903       lf_printf (file, "  mach = 0;\n");
 904       lf_printf (file, "else\n");
 905       lf_printf (file, "  mach = STATE_ARCHITECTURE (sd)->mach;\n");
 906       lf_printf (file, "switch (mach)\n");
 907       lf_printf (file, "  {\n");
 908       lf_indent (file, +2);
 909       for (entry = gen->tables; entry != NULL; entry = entry->next)
 910         {
 911           if (options.gen.default_model != NULL
 912               && (strcmp (entry->model->name, options.gen.default_model) == 0
 913                   || strcmp (entry->model->full_name,
 914                              options.gen.default_model) == 0))
 915             lf_printf (file, "default:\n");
 916           lf_printf (file, "case bfd_mach_%s:\n", entry->model->full_name);
 917           lf_indent (file, +2);
 918           print_function_name (file, "issue", NULL,     /* format name */
 919                                NULL,    /* NO processor */
 920                                NULL,    /* expanded bits */
 921                                function_name_prefix_idecode);
 922           lf_printf (file, " = ");
 923           print_function_name (file, "issue", NULL,     /* format name */
 924                                entry->model->name, NULL,        /* expanded bits */
 925                                function_name_prefix_idecode);
 926           lf_printf (file, ";\n");
 927           print_function_name (file, "run", NULL,       /* format name */
 928                                NULL,    /* NO processor */
 929                                NULL,    /* expanded bits */
 930                                function_name_prefix_engine);
 931           lf_printf (file, " = ");
 932           print_function_name (file, "run", NULL,       /* format name */
 933                                entry->model->name, NULL,        /* expanded bits */
 934                                function_name_prefix_engine);
 935           lf_printf (file, ";\n");
 936           lf_printf (file, "break;\n");
 937           lf_indent (file, -2);
 938         }
 939       if (options.gen.default_model == NULL)
 940         {
 941           lf_printf (file, "default:\n");
 942           lf_indent (file, +2);
 943           lf_printf (file, "sim_engine_abort (sd, NULL, NULL_CIA,\n");
 944           lf_printf (file,
 945                      "                  \"sim_engine_run - unknown machine\");\n");
 946           lf_printf (file, "break;\n");
 947           lf_indent (file, -2);
 948         }
 949       lf_indent (file, -2);
 950       lf_printf (file, "  }\n");
 951     }
 952   print_function_name (file, "run", NULL,       /* format name */
 953                        NULL,    /* NO processor */
 954                        NULL,    /* expanded bits */
 955                        function_name_prefix_engine);
 956   lf_printf (file, " (sd, next_cpu_nr, nr_cpus, siggnal);\n");
 957   lf_indent (file, -2);
 958   lf_printf (file, "}\n");
 959 }
 960
 961 /****************************************************************/
 962
 963 static gen_table *
 964 do_gen (insn_table *isa, decode_table *decode_rules)
 965 {
 966   gen_table *gen;
 967   if (decode_rules == NULL)
 968     error (NULL, "Must specify a decode table\n");
 969   if (isa == NULL)
 970     error (NULL, "Must specify an instruction table\n");
 971   if (decode_table_max_word_nr (decode_rules) > 0)
 972     options.gen.multi_word = decode_table_max_word_nr (decode_rules);
 973   gen = make_gen_tables (isa, decode_rules);
 974   gen_tables_expand_insns (gen);
 975   gen_tables_expand_semantics (gen);
 976   return gen;
 977 }
 978
 979 /****************************************************************/
 980
 981 igen_options options;
 982
 983 int
 984 main (int argc, char **argv, char **envp)
 985 {
 986   cache_entry *cache_rules = NULL;
 987   lf_file_references file_references = lf_include_references;
 988   decode_table *decode_rules = NULL;
 989   insn_table *isa = NULL;
 990   gen_table *gen = NULL;
 991   char *real_file_name = NULL;
 992   int is_header = 0;
 993   int ch;
 994   lf *standard_out =
 995     lf_open ("-", "stdout", lf_omit_references, lf_is_text, "igen");
 996
 997   INIT_OPTIONS ();
 998
 999   if (argc == 1)
1000     {
1001       printf ("Usage:\n");
1002       printf ("\n");
1003       printf ("  igen <config-opts> ... <input-opts>... <output-opts>...\n");
1004       printf ("\n");
1005       printf ("Config options:\n");
1006       printf ("\n");
1007       printf ("  -B <bit-size>\n");
1008       printf ("\t Set the number of bits in an instruction (deprecated).\n");
1009       printf
1010         ("\t This option can now be set directly in the instruction table.\n");
1011       printf ("\n");
1012       printf ("  -D <data-structure>\n");
1013       printf
1014         ("\t Dump the specified data structure to stdout. Valid structures include:\n");
1015       printf
1016         ("\t processor-names - list the names of all the processors (models)\n");
1017       printf ("\n");
1018       printf ("  -F <filter-list>\n");
1019       printf
1020         ("\t Filter out any instructions with a non-empty flags field that contains\n");
1021       printf ("\t a flag not listed in the <filter-list>.\n");
1022       printf ("\n");
1023       printf ("  -H <high-bit>\n");
1024       printf
1025         ("\t Set the number of the high (most significant) instruction bit (deprecated).\n");
1026       printf
1027         ("\t This option can now be set directly in the instruction table.\n");
1028       printf ("\n");
1029       printf ("  -I <directory>\n");
1030       printf
1031         ("\t Add <directory> to the list of directories searched when opening a file\n");
1032       printf ("\n");
1033       printf ("  -M <model-list>\n");
1034       printf
1035         ("\t Filter out any instructions that do not support at least one of the listed\n");
1036       printf
1037         ("\t models (An instructions with no model information is considered to support\n");
1038       printf ("\t all models.).\n");
1039       printf ("\n");
1040       printf ("  -N <nr-cpus>\n");
1041       printf ("\t Generate a simulator supporting <nr-cpus>\n");
1042       printf
1043         ("\t Specify `-N 0' to disable generation of the SMP. Specifying `-N 1' will\n");
1044       printf
1045         ("\t still generate an SMP enabled simulator but will only support one CPU.\n");
1046       printf ("\n");
1047       printf ("  -T <mechanism>\n");
1048       printf
1049         ("\t Override the decode mechanism specified by the decode rules\n");
1050       printf ("\n");
1051       printf ("  -P <prefix>\n");
1052       printf
1053         ("\t Prepend global names (except itable) with the string <prefix>.\n");
1054       printf
1055         ("\t Specify -P <module>=<prefix> to set a specific <module>'s prefix.\n");
1056       printf ("\n");
1057       printf ("  -S <suffix>\n");
1058       printf
1059         ("\t Replace a global name (suffix) (except itable) with the string <suffix>.\n");
1060       printf
1061         ("\t Specify -S <module>=<suffix> to change a specific <module>'s name (suffix).\n");
1062       printf ("\n");
1063       printf ("  -Werror\n");
1064       printf ("\t Make warnings errors\n");
1065       printf ("  -Wnodiscard\n");
1066       printf
1067         ("\t Suppress warnings about discarded functions and instructions\n");
1068       printf ("  -Wnowidth\n");
1069       printf
1070         ("\t Suppress warnings about instructions with invalid widths\n");
1071       printf ("  -Wnounimplemented\n");
1072       printf ("\t Suppress warnings about unimplemented instructions\n");
1073       printf ("\n");
1074       printf ("  -G [!]<gen-option>\n");
1075       printf ("\t Any of the following options:\n");
1076       printf ("\n");
1077       printf
1078         ("\t decode-duplicate       - Override the decode rules, forcing the duplication of\n");
1079       printf ("\t                          semantic functions\n");
1080       printf
1081         ("\t decode-combine         - Combine any duplicated entries within a table\n");
1082       printf
1083         ("\t decode-zero-reserved   - Override the decode rules, forcing reserved bits to be\n");
1084       printf ("\t                          treated as zero.\n");
1085       printf
1086         ("\t decode-switch-is-goto  - Overfide the padded-switch code type as a goto-switch\n");
1087       printf ("\n");
1088       printf
1089         ("\t gen-conditional-issue  - conditionally issue each instruction\n");
1090       printf
1091         ("\t gen-delayed-branch     - need both cia and nia passed around\n");
1092       printf
1093         ("\t gen-direct-access      - use #defines to directly access values\n");
1094       printf
1095         ("\t gen-zero-r<N>          - arch assumes GPR(<N>) == 0, keep it that way\n");
1096       printf
1097         ("\t gen-icache[=<N>        - generate an instruction cracking cache of size <N>\n");
1098       printf ("\t                          Default size is %d\n",
1099               options.gen.icache_size);
1100       printf
1101         ("\t gen-insn-in-icache     - save original instruction when cracking\n");
1102       printf
1103         ("\t gen-multi-sim[=MODEL]  - generate multiple simulators - one per model\n");
1104       printf
1105         ("\t                          If specified MODEL is made the default architecture.\n");
1106       printf
1107         ("\t                          By default, a single simulator that will\n");
1108       printf
1109         ("\t                          execute any instruction is generated\n");
1110       printf
1111         ("\t gen-multi-word         - generate code allowing for multi-word insns\n");
1112       printf
1113         ("\t gen-semantic-icache    - include semantic code in cracking functions\n");
1114       printf
1115         ("\t gen-slot-verification  - perform slot verification as part of decode\n");
1116       printf ("\t gen-nia-invalid        - NIA defaults to nia_invalid\n");
1117       printf ("\t gen-nia-void           - do not compute/return NIA\n");
1118       printf ("\n");
1119       printf
1120         ("\t trace-combine          - report combined entries a rule application\n");
1121       printf
1122         ("\t trace-entries          - report entries after a rules application\n");
1123       printf ("\t trace-rule-rejection   - report each rule as rejected\n");
1124       printf ("\t trace-rule-selection   - report each rule as selected\n");
1125       printf
1126         ("\t trace-insn-insertion   - report each instruction as it is inserted into a decode table\n");
1127       printf
1128         ("\t trace-rule-expansion   - report each instruction as it is expanded (before insertion into a decode table)\n");
1129       printf ("\t trace-all              - enable all trace options\n");
1130       printf ("\n");
1131       printf
1132         ("\t field-widths           - instruction formats specify widths (deprecated)\n");
1133       printf
1134         ("\t                          By default, an instruction format specifies bit\n");
1135       printf ("\t                          positions\n");
1136       printf
1137         ("\t                          This option can now be set directly in the\n");
1138       printf ("\t                          instruction table\n");
1139       printf
1140         ("\t jumps                  - use jumps instead of function calls\n");
1141       printf
1142         ("\t omit-line-numbers      - do not include line number information in the output\n");
1143       printf ("\n");
1144       printf ("Input options:\n");
1145       printf ("\n");
1146       printf ("  -k <cache-rules> (deprecated)\n");
1147       printf ("  -o <decode-rules>\n");
1148       printf ("  -i <instruction-table>\n");
1149       printf ("\n");
1150       printf ("Output options:\n");
1151       printf ("\n");
1152       printf ("  -x                    Perform expansion (required)\n");
1153       printf
1154         ("  -n <real-name>        Specify the real name of the next output file\n");
1155       printf
1156         ("  -h                 Generate the header (.h) file rather than the body (.c)\n");
1157       printf ("  -c <output-file>      output icache\n");
1158       printf ("  -d <output-file>      output idecode\n");
1159       printf ("  -e <output-file>      output engine\n");
1160       printf ("  -f <output-file>      output support functions\n");
1161       printf ("  -m <output-file>      output model\n");
1162       printf ("  -r <output-file>      output multi-sim run\n");
1163       printf ("  -s <output-file>      output schematic\n");
1164       printf ("  -t <output-file>      output itable\n");
1165     }
1166
1167   while ((ch = getopt (argc, argv,
1168                        "B:D:F:G:H:I:M:N:P:T:W:o:k:i:n:hc:d:e:m:r:s:t:f:x"))
1169          != -1)
1170     {
1171       fprintf (stderr, "  -%c ", ch);
1172       if (optarg)
1173         fprintf (stderr, "%s ", optarg);
1174       fprintf (stderr, "\\\n");
1175
1176       switch (ch)
1177         {
1178
1179         case 'M':
1180           filter_parse (&options.model_filter, optarg);
1181           break;
1182
1183         case 'D':
1184           if (strcmp (optarg, "processor-names"))
1185             {
1186               char *processor;
1187               for (processor = filter_next (options.model_filter, "");
1188                    processor != NULL;
1189                    processor = filter_next (options.model_filter, processor))
1190                 lf_printf (standard_out, "%s\n", processor);
1191             }
1192           else
1193             error (NULL, "Unknown data structure %s, not dumped\n", optarg);
1194           break;
1195
1196         case 'F':
1197           filter_parse (&options.flags_filter, optarg);
1198           break;
1199
1200         case 'I':
1201           {
1202             table_include **dir = &options.include;
1203             while ((*dir) != NULL)
1204               dir = &(*dir)->next;
1205             (*dir) = ZALLOC (table_include);
1206             (*dir)->dir = strdup (optarg);
1207           }
1208           break;
1209
1210         case 'B':
1211           options.insn_bit_size = a2i (optarg);
1212           if (options.insn_bit_size <= 0
1213               || options.insn_bit_size > max_insn_bit_size)
1214             {
1215               error (NULL, "Instruction bitsize must be in range 1..%d\n",
1216                      max_insn_bit_size);
1217             }
1218           if (options.hi_bit_nr != options.insn_bit_size - 1
1219               && options.hi_bit_nr != 0)
1220             {
1221               error (NULL, "Conflict betweem hi-bit-nr and insn-bit-size\n");
1222             }
1223           break;
1224
1225         case 'H':
1226           options.hi_bit_nr = a2i (optarg);
1227           if (options.hi_bit_nr != options.insn_bit_size - 1
1228               && options.hi_bit_nr != 0)
1229             {
1230               error (NULL, "Conflict between hi-bit-nr and insn-bit-size\n");
1231             }
1232           break;
1233
1234         case 'N':
1235           options.gen.smp = a2i (optarg);
1236           break;
1237
1238         case 'P':
1239         case 'S':
1240           {
1241             igen_module *names;
1242             igen_name *name;
1243             char *chp;
1244             chp = strchr (optarg, '=');
1245             if (chp == NULL)
1246               {
1247                 names = &options.module.global;
1248                 chp = optarg;
1249               }
1250             else
1251               {
1252                 chp = chp + 1;  /* skip `=' */
1253                 names = NULL;
1254                 if (strncmp (optarg, "global=", chp - optarg) == 0)
1255                   {
1256                     names = &options.module.global;
1257                   }
1258                 if (strncmp (optarg, "engine=", chp - optarg) == 0)
1259                   {
1260                     names = &options.module.engine;
1261                   }
1262                 if (strncmp (optarg, "icache=", chp - optarg) == 0)
1263                   {
1264                     names = &options.module.icache;
1265                   }
1266                 if (strncmp (optarg, "idecode=", chp - optarg) == 0)
1267                   {
1268                     names = &options.module.idecode;
1269                   }
1270                 if (strncmp (optarg, "itable=", chp - optarg) == 0)
1271                   {
1272                     names = &options.module.itable;
1273                   }
1274                 if (strncmp (optarg, "semantics=", chp - optarg) == 0)
1275                   {
1276                     names = &options.module.semantics;
1277                   }
1278                 if (strncmp (optarg, "support=", chp - optarg) == 0)
1279                   {
1280                     names = &options.module.support;
1281                   }
1282                 if (names == NULL)
1283                   {
1284                     error (NULL, "Prefix `%s' unreconized\n", optarg);
1285                   }
1286               }
1287             switch (ch)
1288               {
1289               case 'P':
1290                 name = &names->prefix;
1291                 break;
1292               case 'S':
1293                 name = &names->suffix;
1294                 break;
1295               default:
1296                 abort ();       /* Bad switch.  */
1297               }
1298             name->u = strdup (chp);
1299             name->l = strdup (chp);
1300             chp = name->u;
1301             while (*chp)
1302               {
1303                 if (islower (*chp))
1304                   *chp = toupper (*chp);
1305                 chp++;
1306               }
1307             if (name == &options.module.global.prefix)
1308               {
1309                 options.module.engine.prefix = options.module.global.prefix;
1310                 options.module.icache.prefix = options.module.global.prefix;
1311                 options.module.idecode.prefix = options.module.global.prefix;
1312                 /* options.module.itable.prefix = options.module.global.prefix; */
1313                 options.module.semantics.prefix =
1314                   options.module.global.prefix;
1315                 options.module.support.prefix = options.module.global.prefix;
1316               }
1317             if (name == &options.module.global.suffix)
1318               {
1319                 options.module.engine.suffix = options.module.global.suffix;
1320                 options.module.icache.suffix = options.module.global.suffix;
1321                 options.module.idecode.suffix = options.module.global.suffix;
1322                 /* options.module.itable.suffix = options.module.global.suffix; */
1323                 options.module.semantics.suffix =
1324                   options.module.global.suffix;
1325                 options.module.support.suffix = options.module.global.suffix;
1326               }
1327             break;
1328           }
1329
1330         case 'W':
1331           {
1332             if (strcmp (optarg, "error") == 0)
1333               options.warning = error;
1334             else if (strcmp (optarg, "nodiscard") == 0)
1335               options.warn.discard = 0;
1336             else if (strcmp (optarg, "discard") == 0)
1337               options.warn.discard = 1;
1338             else if (strcmp (optarg, "nowidth") == 0)
1339               options.warn.width = 0;
1340             else if (strcmp (optarg, "width") == 0)
1341               options.warn.width = 1;
1342             else if (strcmp (optarg, "nounimplemented") == 0)
1343               options.warn.unimplemented = 0;
1344             else if (strcmp (optarg, "unimplemented") == 0)
1345               options.warn.unimplemented = 1;
1346             else
1347               error (NULL, "Unknown -W argument `%s'\n", optarg);
1348             break;
1349           }
1350
1351
1352         case 'G':
1353           {
1354             int enable_p;
1355             char *argp;
1356             if (strncmp (optarg, "no-", strlen ("no-")) == 0)
1357               {
1358                 argp = optarg + strlen ("no-");
1359                 enable_p = 0;
1360               }
1361             else if (strncmp (optarg, "!", strlen ("!")) == 0)
1362               {
1363                 argp = optarg + strlen ("no-");
1364                 enable_p = 0;
1365               }
1366             else
1367               {
1368                 argp = optarg;
1369                 enable_p = 1;
1370               }
1371             if (strcmp (argp, "decode-duplicate") == 0)
1372               {
1373                 options.decode.duplicate = enable_p;
1374               }
1375             else if (strcmp (argp, "decode-combine") == 0)
1376               {
1377                 options.decode.combine = enable_p;
1378               }
1379             else if (strcmp (argp, "decode-zero-reserved") == 0)
1380               {
1381                 options.decode.zero_reserved = enable_p;
1382               }
1383
1384             else if (strcmp (argp, "gen-conditional-issue") == 0)
1385               {
1386                 options.gen.conditional_issue = enable_p;
1387               }
1388             else if (strcmp (argp, "conditional-issue") == 0)
1389               {
1390                 options.gen.conditional_issue = enable_p;
1391                 options.warning (NULL,
1392                                  "Option conditional-issue replaced by gen-conditional-issue\n");
1393               }
1394             else if (strcmp (argp, "gen-delayed-branch") == 0)
1395               {
1396                 options.gen.delayed_branch = enable_p;
1397               }
1398             else if (strcmp (argp, "delayed-branch") == 0)
1399               {
1400                 options.gen.delayed_branch = enable_p;
1401                 options.warning (NULL,
1402                                  "Option delayed-branch replaced by gen-delayed-branch\n");
1403               }
1404             else if (strcmp (argp, "gen-direct-access") == 0)
1405               {
1406                 options.gen.direct_access = enable_p;
1407               }
1408             else if (strcmp (argp, "direct-access") == 0)
1409               {
1410                 options.gen.direct_access = enable_p;
1411                 options.warning (NULL,
1412                                  "Option direct-access replaced by gen-direct-access\n");
1413               }
1414             else if (strncmp (argp, "gen-zero-r", strlen ("gen-zero-r")) == 0)
1415               {
1416                 options.gen.zero_reg = enable_p;
1417                 options.gen.zero_reg_nr = atoi (argp + strlen ("gen-zero-r"));
1418               }
1419             else if (strncmp (argp, "zero-r", strlen ("zero-r")) == 0)
1420               {
1421                 options.gen.zero_reg = enable_p;
1422                 options.gen.zero_reg_nr = atoi (argp + strlen ("zero-r"));
1423                 options.warning (NULL,
1424                                  "Option zero-r<N> replaced by gen-zero-r<N>\n");
1425               }
1426             else if (strncmp (argp, "gen-icache", strlen ("gen-icache")) == 0)
1427               {
1428                 switch (argp[strlen ("gen-icache")])
1429                   {
1430                   case '=':
1431                     options.gen.icache_size =
1432                       atoi (argp + strlen ("gen-icache") + 1);
1433                     options.gen.icache = enable_p;
1434                     break;
1435                   case '\0':
1436                     options.gen.icache = enable_p;
1437                     break;
1438                   default:
1439                     error (NULL,
1440                            "Expecting -Ggen-icache or -Ggen-icache=<N>\n");
1441                   }
1442               }
1443             else if (strcmp (argp, "gen-insn-in-icache") == 0)
1444               {
1445                 options.gen.insn_in_icache = enable_p;
1446               }
1447             else if (strncmp (argp, "gen-multi-sim", strlen ("gen-multi-sim"))
1448                      == 0)
1449               {
1450                 char *arg = &argp[strlen ("gen-multi-sim")];
1451                 switch (arg[0])
1452                   {
1453                   case '=':
1454                     options.gen.multi_sim = enable_p;
1455                     options.gen.default_model = arg + 1;
1456                     if (!filter_is_member
1457                         (options.model_filter, options.gen.default_model))
1458                       error (NULL, "multi-sim model %s unknown\n",
1459                              options.gen.default_model);
1460                     break;
1461                   case '\0':
1462                     options.gen.multi_sim = enable_p;
1463                     options.gen.default_model = NULL;
1464                     break;
1465                   default:
1466                     error (NULL,
1467                            "Expecting -Ggen-multi-sim or -Ggen-multi-sim=<MODEL>\n");
1468                     break;
1469                   }
1470               }
1471             else if (strcmp (argp, "gen-multi-word") == 0)
1472               {
1473                 options.gen.multi_word = enable_p;
1474               }
1475             else if (strcmp (argp, "gen-semantic-icache") == 0)
1476               {
1477                 options.gen.semantic_icache = enable_p;
1478               }
1479             else if (strcmp (argp, "gen-slot-verification") == 0)
1480               {
1481                 options.gen.slot_verification = enable_p;
1482               }
1483             else if (strcmp (argp, "verify-slot") == 0)
1484               {
1485                 options.gen.slot_verification = enable_p;
1486                 options.warning (NULL,
1487                                  "Option verify-slot replaced by gen-slot-verification\n");
1488               }
1489             else if (strcmp (argp, "gen-nia-invalid") == 0)
1490               {
1491                 options.gen.nia = nia_is_invalid;
1492               }
1493             else if (strcmp (argp, "default-nia-minus-one") == 0)
1494               {
1495                 options.gen.nia = nia_is_invalid;
1496                 options.warning (NULL,
1497                                  "Option default-nia-minus-one replaced by gen-nia-invalid\n");
1498               }
1499             else if (strcmp (argp, "gen-nia-void") == 0)
1500               {
1501                 options.gen.nia = nia_is_void;
1502               }
1503             else if (strcmp (argp, "trace-all") == 0)
1504               {
1505                 memset (&options.trace, enable_p, sizeof (options.trace));
1506               }
1507             else if (strcmp (argp, "trace-combine") == 0)
1508               {
1509                 options.trace.combine = enable_p;
1510               }
1511             else if (strcmp (argp, "trace-entries") == 0)
1512               {
1513                 options.trace.entries = enable_p;
1514               }
1515             else if (strcmp (argp, "trace-rule-rejection") == 0)
1516               {
1517                 options.trace.rule_rejection = enable_p;
1518               }
1519             else if (strcmp (argp, "trace-rule-selection") == 0)
1520               {
1521                 options.trace.rule_selection = enable_p;
1522               }
1523             else if (strcmp (argp, "trace-insn-insertion") == 0)
1524               {
1525                 options.trace.insn_insertion = enable_p;
1526               }
1527             else if (strcmp (argp, "trace-insn-expansion") == 0)
1528               {
1529                 options.trace.insn_expansion = enable_p;
1530               }
1531             else if (strcmp (argp, "jumps") == 0)
1532               {
1533                 options.gen.code = generate_jumps;
1534               }
1535             else if (strcmp (argp, "field-widths") == 0)
1536               {
1537                 options.insn_specifying_widths = enable_p;
1538               }
1539             else if (strcmp (argp, "omit-line-numbers") == 0)
1540               {
1541                 file_references = lf_omit_references;
1542               }
1543             else
1544               {
1545                 error (NULL, "Unknown option %s\n", optarg);
1546               }
1547             break;
1548           }
1549
1550         case 'i':
1551           isa = load_insn_table (optarg, cache_rules);
1552           if (isa->illegal_insn == NULL)
1553             error (NULL, "illegal-instruction missing from insn table\n");
1554           break;
1555
1556         case 'x':
1557           gen = do_gen (isa, decode_rules);
1558           break;
1559
1560         case 'o':
1561           decode_rules = load_decode_table (optarg);
1562           break;
1563
1564         case 'k':
1565           if (isa != NULL)
1566             error (NULL, "Cache file must appear before the insn file\n");
1567           cache_rules = load_cache_table (optarg);
1568           break;
1569
1570         case 'n':
1571           real_file_name = strdup (optarg);
1572           break;
1573
1574         case 'h':
1575           is_header = 1;
1576           break;
1577
1578         case 'c':
1579         case 'd':
1580         case 'e':
1581         case 'f':
1582         case 'm':
1583         case 'r':
1584         case 's':
1585         case 't':
1586           {
1587             lf *file = lf_open (optarg, real_file_name, file_references,
1588                                 (is_header ? lf_is_h : lf_is_c),
1589                                 argv[0]);
1590             if (gen == NULL && ch != 't' && ch != 'm' && ch != 'f')
1591               {
1592                 options.warning (NULL,
1593                                  "Explicitly generate tables with -x option\n");
1594                 gen = do_gen (isa, decode_rules);
1595               }
1596             lf_print__file_start (file);
1597             switch (ch)
1598               {
1599               case 'm':
1600                 if (is_header)
1601                   gen_model_h (file, isa);
1602                 else
1603                   gen_model_c (file, isa);
1604                 break;
1605               case 't':
1606                 if (is_header)
1607                   gen_itable_h (file, isa);
1608                 else
1609                   gen_itable_c (file, isa);
1610                 break;
1611               case 'f':
1612                 if (is_header)
1613                   gen_support_h (file, isa);
1614                 else
1615                   gen_support_c (file, isa);
1616                 break;
1617               case 'r':
1618                 if (is_header)
1619                   options.warning (NULL, "-hr option ignored\n");
1620                 else
1621                   gen_run_c (file, gen);
1622                 break;
1623               case 's':
1624                 if (is_header)
1625                   gen_semantics_h (file, gen->semantics, isa->max_nr_words);
1626                 else
1627                   gen_semantics_c (file, gen->semantics, isa->caches);
1628                 break;
1629               case 'd':
1630                 if (is_header)
1631                   gen_idecode_h (file, gen, isa, cache_rules);
1632                 else
1633                   gen_idecode_c (file, gen, isa, cache_rules);
1634                 break;
1635               case 'e':
1636                 if (is_header)
1637                   gen_engine_h (file, gen, isa, cache_rules);
1638                 else
1639                   gen_engine_c (file, gen, isa, cache_rules);
1640                 break;
1641               case 'c':
1642                 if (is_header)
1643                   gen_icache_h (file,
1644                                 gen->semantics,
1645                                 isa->functions, isa->max_nr_words);
1646                 else
1647                   gen_icache_c (file,
1648                                 gen->semantics, isa->functions, cache_rules);
1649                 break;
1650               }
1651             lf_print__file_finish (file);
1652             lf_close (file);
1653             is_header = 0;
1654           }
1655           real_file_name = NULL;
1656           break;
1657         default:
1658           ERROR ("Bad switch");
1659         }
1660     }
1661   return (0);
1662 }