sim/igen/igen.c

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