sim/igen/gen-icache.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 #include "misc.h"
  24 #include "lf.h"
  25 #include "table.h"
  26 #include "filter.h"
  27 #include "igen.h"
  28
  29 #include "ld-insn.h"
  30 #include "ld-decode.h"
  31
  32 #include "gen.h"
  33
  34 #include "gen-semantics.h"
  35 #include "gen-idecode.h"
  36 #include "gen-icache.h"
  37
  38
  39
  40 static void
  41 print_icache_function_header (lf *file,
  42                               const char *basename,
  43                               const char *format_name,
  44                               opcode_bits *expanded_bits,
  45                               int is_function_definition,
  46                               int nr_prefetched_words)
  47 {
  48   lf_printf (file, "\n");
  49   lf_print__function_type_function (file, print_icache_function_type,
  50                                     "EXTERN_ICACHE", " ");
  51   print_function_name (file,
  52                        basename, format_name, NULL,
  53                        expanded_bits, function_name_prefix_icache);
  54   lf_printf (file, "\n(");
  55   print_icache_function_formal (file, nr_prefetched_words);
  56   lf_printf (file, ")");
  57   if (!is_function_definition)
  58     lf_printf (file, ";");
  59   lf_printf (file, "\n");
  60 }
  61
  62
  63 void
  64 print_icache_declaration (lf *file,
  65                           insn_entry * insn,
  66                           opcode_bits *expanded_bits,
  67                           insn_opcodes *opcodes, int nr_prefetched_words)
  68 {
  69   print_icache_function_header (file,
  70                                 insn->name,
  71                                 insn->format_name,
  72                                 expanded_bits,
  73                                 0 /* is not function definition */ ,
  74                                 nr_prefetched_words);
  75 }
  76
  77
  78
  79 static void
  80 print_icache_extraction (lf *file,
  81                          const char *format_name,
  82                          cache_entry_type cache_type,
  83                          const char *entry_name,
  84                          const char *entry_type,
  85                          const char *entry_expression,
  86                          char *single_insn_field,
  87                          line_ref *line,
  88                          insn_field_entry *cur_field,
  89                          opcode_bits *expanded_bits,
  90                          icache_decl_type what_to_declare,
  91                          icache_body_type what_to_do)
  92 {
  93   const char *expression;
  94   opcode_bits *bits;
  95   char *reason;
  96   ASSERT (format_name != NULL);
  97   ASSERT (entry_name != NULL);
  98
  99   /* figure out exactly what should be going on here */
 100   switch (cache_type)
 101     {
 102     case scratch_value:
 103       if ((what_to_do & put_values_in_icache)
 104           || what_to_do == do_not_use_icache)
 105         {
 106           reason = "scratch";
 107           what_to_do = do_not_use_icache;
 108         }
 109       else
 110         return;
 111       break;
 112     case compute_value:
 113       if ((what_to_do & get_values_from_icache)
 114           || what_to_do == do_not_use_icache)
 115         {
 116           reason = "compute";
 117           what_to_do = do_not_use_icache;
 118         }
 119       else
 120         return;
 121       break;
 122     case cache_value:
 123       if ((what_to_declare != undef_variables)
 124           || !(what_to_do & put_values_in_icache))
 125         {
 126           reason = "cache";
 127           what_to_declare = ((what_to_do & put_values_in_icache)
 128                              ? declare_variables : what_to_declare);
 129         }
 130       else
 131         return;
 132       break;
 133     default:
 134       abort ();                 /* Bad switch.  */
 135     }
 136
 137   /* For the type, default to a simple unsigned */
 138   if (entry_type == NULL || strlen (entry_type) == 0)
 139     entry_type = "unsigned";
 140
 141   /* look through the set of expanded sub fields to see if this field
 142      has been given a constant value */
 143   for (bits = expanded_bits; bits != NULL; bits = bits->next)
 144     {
 145       if (bits->field == cur_field)
 146         break;
 147     }
 148
 149   /* Define a storage area for the cache element */
 150   switch (what_to_declare)
 151     {
 152     case undef_variables:
 153       /* We've finished with the #define value - destory it */
 154       lf_indent_suppress (file);
 155       lf_printf (file, "#undef %s\n", entry_name);
 156       return;
 157     case define_variables:
 158       /* Using direct access for this entry, clear any prior
 159          definition, then define it */
 160       lf_indent_suppress (file);
 161       lf_printf (file, "#undef %s\n", entry_name);
 162       /* Don't type cast pointer types! */
 163       lf_indent_suppress (file);
 164       if (strchr (entry_type, '*') != NULL)
 165         lf_printf (file, "#define %s (", entry_name);
 166       else
 167         lf_printf (file, "#define %s ((%s) ", entry_name, entry_type);
 168       break;
 169     case declare_variables:
 170       /* using variables to define the value */
 171       if (line != NULL)
 172         lf_print__line_ref (file, line);
 173       lf_printf (file, "%s const %s UNUSED = ", entry_type, entry_name);
 174       break;
 175     }
 176
 177
 178   /* define a value for that storage area as determined by what is in
 179      the cache */
 180   if (bits != NULL
 181       && single_insn_field != NULL
 182       && strcmp (entry_name, single_insn_field) == 0
 183       && strcmp (entry_name, cur_field->val_string) == 0
 184       && ((bits->opcode->is_boolean && bits->value == 0)
 185           || (!bits->opcode->is_boolean)))
 186     {
 187       /* The cache rule is specifying what to do with a simple
 188          instruction field.
 189
 190          Because of instruction expansion, the field is either a
 191          constant value or equal to the specified constant (boolean
 192          comparison). (The latter indicated by bits->value == 0).
 193
 194          The case of a field not being equal to the specified boolean
 195          value is handled later. */
 196       expression = "constant field";
 197       ASSERT (bits->field == cur_field);
 198       if (bits->opcode->is_boolean)
 199         {
 200           ASSERT (bits->value == 0);
 201           lf_printf (file, "%d", bits->opcode->boolean_constant);
 202         }
 203       else if (bits->opcode->last < bits->field->last)
 204         {
 205           lf_printf (file, "%d",
 206                      bits->value << (bits->field->last - bits->opcode->last));
 207         }
 208       else
 209         {
 210           lf_printf (file, "%d", bits->value);
 211         }
 212     }
 213   else if (bits != NULL
 214            && single_insn_field != NULL
 215            && strncmp (entry_name,
 216                        single_insn_field,
 217                        strlen (single_insn_field)) == 0
 218            && strncmp (entry_name + strlen (single_insn_field),
 219                        "_is_",
 220                        strlen ("_is_")) == 0
 221            && ((bits->opcode->is_boolean
 222                 && ((unsigned)
 223                     atol (entry_name + strlen (single_insn_field) +
 224                           strlen ("_is_")) == bits->opcode->boolean_constant))
 225                || (!bits->opcode->is_boolean)))
 226     {
 227       /* The cache rule defines an entry for the comparison between a
 228          single instruction field and a constant.  The value of the
 229          comparison in someway matches that of the opcode field that
 230          was made constant through expansion. */
 231       expression = "constant compare";
 232       if (bits->opcode->is_boolean)
 233         {
 234           lf_printf (file, "%d /* %s == %d */",
 235                      bits->value == 0,
 236                      single_insn_field, bits->opcode->boolean_constant);
 237         }
 238       else if (bits->opcode->last < bits->field->last)
 239         {
 240           lf_printf (file, "%d /* %s == %d */",
 241                      (atol
 242                       (entry_name + strlen (single_insn_field) +
 243                        strlen ("_is_")) ==
 244                       (bits->
 245                        value << (bits->field->last - bits->opcode->last))),
 246                      single_insn_field,
 247                      (bits->
 248                       value << (bits->field->last - bits->opcode->last)));
 249         }
 250       else
 251         {
 252           lf_printf (file, "%d /* %s == %d */",
 253                      (atol
 254                       (entry_name + strlen (single_insn_field) +
 255                        strlen ("_is_")) == bits->value), single_insn_field,
 256                      bits->value);
 257         }
 258     }
 259   else
 260     {
 261       /* put the field in the local variable, possibly also enter it
 262          into the cache */
 263       expression = "extraction";
 264       /* handle the cache */
 265       if ((what_to_do & get_values_from_icache)
 266           || (what_to_do & put_values_in_icache))
 267         {
 268           lf_printf (file, "cache_entry->crack.%s.%s",
 269                      format_name, entry_name);
 270           if (what_to_do & put_values_in_icache)        /* also put it in the cache? */
 271             {
 272               lf_printf (file, " = ");
 273             }
 274         }
 275       if ((what_to_do & put_values_in_icache)
 276           || what_to_do == do_not_use_icache)
 277         {
 278           if (cur_field != NULL)
 279             {
 280               if (entry_expression != NULL && strlen (entry_expression) > 0)
 281                 error (line,
 282                        "Instruction field entry with nonempty expression\n");
 283               if (cur_field->first == 0
 284                   && cur_field->last == options.insn_bit_size - 1)
 285                 lf_printf (file, "(instruction_%d)", cur_field->word_nr);
 286               else if (cur_field->last == options.insn_bit_size - 1)
 287                 lf_printf (file, "MASKED%d (instruction_%d, %d, %d)",
 288                            options.insn_bit_size,
 289                            cur_field->word_nr,
 290                            i2target (options.hi_bit_nr, cur_field->first),
 291                            i2target (options.hi_bit_nr, cur_field->last));
 292               else
 293                 lf_printf (file, "EXTRACTED%d (instruction_%d, %d, %d)",
 294                            options.insn_bit_size,
 295                            cur_field->word_nr,
 296                            i2target (options.hi_bit_nr, cur_field->first),
 297                            i2target (options.hi_bit_nr, cur_field->last));
 298             }
 299           else
 300             {
 301               lf_printf (file, "%s", entry_expression);
 302             }
 303         }
 304     }
 305
 306   switch (what_to_declare)
 307     {
 308     case define_variables:
 309       lf_printf (file, ")");
 310       break;
 311     case undef_variables:
 312       break;
 313     case declare_variables:
 314       lf_printf (file, ";");
 315       break;
 316     }
 317
 318   ASSERT (reason != NULL && expression != NULL);
 319   lf_printf (file, " /* %s - %s */\n", reason, expression);
 320 }
 321
 322
 323 void
 324 print_icache_body (lf *file,
 325                    insn_entry * instruction,
 326                    opcode_bits *expanded_bits,
 327                    cache_entry *cache_rules,
 328                    icache_decl_type what_to_declare,
 329                    icache_body_type what_to_do, int nr_prefetched_words)
 330 {
 331   /* extract instruction fields */
 332   lf_printf (file, "/* Extraction: %s\n", instruction->name);
 333   lf_printf (file, "     ");
 334   switch (what_to_declare)
 335     {
 336     case define_variables:
 337       lf_printf (file, "#define");
 338       break;
 339     case declare_variables:
 340       lf_printf (file, "declare");
 341       break;
 342     case undef_variables:
 343       lf_printf (file, "#undef");
 344       break;
 345     }
 346   lf_printf (file, " ");
 347   switch (what_to_do)
 348     {
 349     case get_values_from_icache:
 350       lf_printf (file, "get-values-from-icache");
 351       break;
 352     case put_values_in_icache:
 353       lf_printf (file, "put-values-in-icache");
 354       break;
 355     case both_values_and_icache:
 356       lf_printf (file, "get-values-from-icache|put-values-in-icache");
 357       break;
 358     case do_not_use_icache:
 359       lf_printf (file, "do-not-use-icache");
 360       break;
 361     }
 362   lf_printf (file, "\n     ");
 363   print_insn_words (file, instruction);
 364   lf_printf (file, " */\n");
 365
 366   /* pass zero - fetch from memory any missing instructions.
 367
 368      Some of the instructions will have already been fetched (in the
 369      instruction array), others will still need fetching. */
 370   switch (what_to_do)
 371     {
 372     case get_values_from_icache:
 373       break;
 374     case put_values_in_icache:
 375     case both_values_and_icache:
 376     case do_not_use_icache:
 377       {
 378         int word_nr;
 379         switch (what_to_declare)
 380           {
 381           case undef_variables:
 382             break;
 383           case define_variables:
 384           case declare_variables:
 385             for (word_nr = nr_prefetched_words;
 386                  word_nr < instruction->nr_words; word_nr++)
 387               {
 388                 /* FIXME - should be using print_icache_extraction? */
 389                 lf_printf (file,
 390                            "%sinstruction_word instruction_%d UNUSED = ",
 391                            options.module.global.prefix.l, word_nr);
 392                 lf_printf (file, "IMEM%d_IMMED (cia, %d)",
 393                            options.insn_bit_size, word_nr);
 394                 lf_printf (file, ";\n");
 395               }
 396           }
 397       }
 398     }
 399
 400   /* if putting the instruction words in the cache, define references
 401      for them */
 402   if (options.gen.insn_in_icache)
 403     {
 404       /* FIXME: is the instruction_word type correct? */
 405       print_icache_extraction (file, instruction->format_name, cache_value, "insn",     /* name */
 406                                "instruction_word",      /* type */
 407                                "instruction",   /* expression */
 408                                NULL,    /* origin */
 409                                NULL,    /* line */
 410                                NULL, NULL, what_to_declare, what_to_do);
 411     }
 412   lf_printf (file, "\n");
 413
 414   /* pass one - process instruction fields.
 415
 416      If there is no cache rule, the default is to enter the field into
 417      the cache */
 418   {
 419     insn_word_entry *word;
 420     for (word = instruction->words; word != NULL; word = word->next)
 421       {
 422         insn_field_entry *cur_field;
 423         for (cur_field = word->first;
 424              cur_field->first < options.insn_bit_size;
 425              cur_field = cur_field->next)
 426           {
 427             /* Always expand named fields (even if constant), so
 428                references are valid.  */
 429             if (cur_field->type == insn_field_string)
 430               {
 431                 cache_entry *cache_rule;
 432                 cache_entry_type value_type = cache_value;
 433                 line_ref *value_line = instruction->line;
 434                 /* check the cache table to see if it contains a rule
 435                    overriding the default cache action for an
 436                    instruction field */
 437                 for (cache_rule = cache_rules;
 438                      cache_rule != NULL; cache_rule = cache_rule->next)
 439                   {
 440                     if (filter_is_subset (instruction->field_names,
 441                                           cache_rule->original_fields)
 442                         && strcmp (cache_rule->name,
 443                                    cur_field->val_string) == 0)
 444                       {
 445                         value_type = cache_rule->entry_type;
 446                         value_line = cache_rule->line;
 447                         if (value_type == compute_value)
 448                           {
 449                             options.warning (cache_rule->line,
 450                                              "instruction field of type `compute' changed to `cache'\n");
 451                             cache_rule->entry_type = cache_value;
 452                           }
 453                         break;
 454                       }
 455                   }
 456                 /* Define an entry for the field within the
 457                    instruction */
 458                 print_icache_extraction (file, instruction->format_name, value_type, cur_field->val_string,     /* name */
 459                                          NULL,  /* type */
 460                                          NULL,  /* expression */
 461                                          cur_field->val_string, /* insn field */
 462                                          value_line,
 463                                          cur_field,
 464                                          expanded_bits,
 465                                          what_to_declare, what_to_do);
 466               }
 467           }
 468       }
 469   }
 470
 471   /* pass two - any cache fields not processed above */
 472   {
 473     cache_entry *cache_rule;
 474     for (cache_rule = cache_rules;
 475          cache_rule != NULL; cache_rule = cache_rule->next)
 476       {
 477         if (filter_is_subset (instruction->field_names,
 478                               cache_rule->original_fields)
 479             && !filter_is_member (instruction->field_names, cache_rule->name))
 480           {
 481             char *single_field =
 482               filter_next (cache_rule->original_fields, "");
 483             if (filter_next (cache_rule->original_fields, single_field) !=
 484                 NULL)
 485               single_field = NULL;
 486             print_icache_extraction (file, instruction->format_name, cache_rule->entry_type, cache_rule->name, cache_rule->type, cache_rule->expression, single_field, cache_rule->line, NULL,  /* cur_field */
 487                                      expanded_bits,
 488                                      what_to_declare, what_to_do);
 489           }
 490       }
 491   }
 492
 493   lf_print__internal_ref (file);
 494 }
 495
 496
 497
 498 typedef struct _form_fields form_fields;
 499 struct _form_fields
 500 {
 501   char *name;
 502   filter *fields;
 503   form_fields *next;
 504 };
 505
 506 static form_fields *
 507 insn_table_cache_fields (insn_table *isa)
 508 {
 509   form_fields *forms = NULL;
 510   insn_entry *insn;
 511   for (insn = isa->insns; insn != NULL; insn = insn->next)
 512     {
 513       form_fields **form = &forms;
 514       while (1)
 515         {
 516           if (*form == NULL)
 517             {
 518               /* new format name, add it */
 519               form_fields *new_form = ZALLOC (form_fields);
 520               new_form->name = insn->format_name;
 521               filter_add (&new_form->fields, insn->field_names);
 522               *form = new_form;
 523               break;
 524             }
 525           else if (strcmp ((*form)->name, insn->format_name) == 0)
 526             {
 527               /* already present, add field names to the existing list */
 528               filter_add (&(*form)->fields, insn->field_names);
 529               break;
 530             }
 531           form = &(*form)->next;
 532         }
 533     }
 534   return forms;
 535 }
 536
 537
 538
 539 extern void
 540 print_icache_struct (lf *file, insn_table *isa, cache_entry *cache_rules)
 541 {
 542   /* Create a list of all the different instruction formats with their
 543      corresponding field names. */
 544   form_fields *formats = insn_table_cache_fields (isa);
 545
 546   lf_printf (file, "\n");
 547   lf_printf (file, "#define WITH_%sIDECODE_CACHE_SIZE %d\n",
 548              options.module.global.prefix.u,
 549              (options.gen.icache ? options.gen.icache_size : 0));
 550   lf_printf (file, "\n");
 551
 552   /* create an instruction cache if being used */
 553   if (options.gen.icache)
 554     {
 555       lf_printf (file, "typedef struct _%sidecode_cache {\n",
 556                  options.module.global.prefix.l);
 557       lf_indent (file, +2);
 558       {
 559         form_fields *format;
 560         lf_printf (file, "unsigned_word address;\n");
 561         lf_printf (file, "void *semantic;\n");
 562         lf_printf (file, "union {\n");
 563         lf_indent (file, +2);
 564         for (format = formats; format != NULL; format = format->next)
 565           {
 566             lf_printf (file, "struct {\n");
 567             lf_indent (file, +2);
 568             {
 569               cache_entry *cache_rule;
 570               char *field;
 571               /* space for any instruction words */
 572               if (options.gen.insn_in_icache)
 573                 lf_printf (file, "instruction_word insn[%d];\n",
 574                            isa->max_nr_words);
 575               /* define an entry for any applicable cache rules */
 576               for (cache_rule = cache_rules;
 577                    cache_rule != NULL; cache_rule = cache_rule->next)
 578                 {
 579                   /* nb - sort of correct - should really check against
 580                      individual instructions */
 581                   if (filter_is_subset
 582                       (format->fields, cache_rule->original_fields))
 583                     {
 584                       char *memb;
 585                       lf_printf (file, "%s %s;",
 586                                  (cache_rule->type == NULL
 587                                   ? "unsigned"
 588                                   : cache_rule->type), cache_rule->name);
 589                       lf_printf (file, " /*");
 590                       for (memb =
 591                            filter_next (cache_rule->original_fields, "");
 592                            memb != NULL;
 593                            memb =
 594                            filter_next (cache_rule->original_fields, memb))
 595                         {
 596                           lf_printf (file, " %s", memb);
 597                         }
 598                       lf_printf (file, " */\n");
 599                     }
 600                 }
 601               /* define an entry for any fields not covered by a cache rule */
 602               for (field = filter_next (format->fields, "");
 603                    field != NULL; field = filter_next (format->fields, field))
 604                 {
 605                   cache_entry *cache_rule;
 606                   int found_rule = 0;
 607                   for (cache_rule = cache_rules;
 608                        cache_rule != NULL; cache_rule = cache_rule->next)
 609                     {
 610                       if (strcmp (cache_rule->name, field) == 0)
 611                         {
 612                           found_rule = 1;
 613                           break;
 614                         }
 615                     }
 616                   if (!found_rule)
 617                     lf_printf (file, "unsigned %s; /* default */\n", field);
 618                 }
 619             }
 620             lf_indent (file, -2);
 621             lf_printf (file, "} %s;\n", format->name);
 622           }
 623         lf_indent (file, -2);
 624         lf_printf (file, "} crack;\n");
 625       }
 626       lf_indent (file, -2);
 627       lf_printf (file, "} %sidecode_cache;\n",
 628                  options.module.global.prefix.l);
 629     }
 630   else
 631     {
 632       /* alernativly, since no cache, emit a dummy definition for
 633          idecode_cache so that code refering to the type can still compile */
 634       lf_printf (file, "typedef void %sidecode_cache;\n",
 635                  options.module.global.prefix.l);
 636     }
 637   lf_printf (file, "\n");
 638 }
 639
 640
 641
 642 static void
 643 print_icache_function (lf *file,
 644                        insn_entry * instruction,
 645                        opcode_bits *expanded_bits,
 646                        insn_opcodes *opcodes,
 647                        cache_entry *cache_rules, int nr_prefetched_words)
 648 {
 649   int indent;
 650
 651   /* generate code to enter decoded instruction into the icache */
 652   lf_printf (file, "\n");
 653   lf_print__function_type_function (file, print_icache_function_type,
 654                                     "EXTERN_ICACHE", "\n");
 655   indent = print_function_name (file,
 656                                 instruction->name,
 657                                 instruction->format_name,
 658                                 NULL,
 659                                 expanded_bits, function_name_prefix_icache);
 660   indent += lf_printf (file, " ");
 661   lf_indent (file, +indent);
 662   lf_printf (file, "(");
 663   print_icache_function_formal (file, nr_prefetched_words);
 664   lf_printf (file, ")\n");
 665   lf_indent (file, -indent);
 666
 667   /* function header */
 668   lf_printf (file, "{\n");
 669   lf_indent (file, +2);
 670
 671   print_my_defines (file,
 672                     instruction->name,
 673                     instruction->format_name, expanded_bits);
 674   print_itrace (file, instruction, 1 /*putting-value-in-cache */ );
 675
 676   print_idecode_validate (file, instruction, opcodes);
 677
 678   lf_printf (file, "\n");
 679   lf_printf (file, "{\n");
 680   lf_indent (file, +2);
 681   if (options.gen.semantic_icache)
 682     lf_printf (file, "unsigned_word nia;\n");
 683   print_icache_body (file,
 684                      instruction,
 685                      expanded_bits,
 686                      cache_rules,
 687                      (options.gen.direct_access
 688                       ? define_variables
 689                       : declare_variables),
 690                      (options.gen.semantic_icache
 691                       ? both_values_and_icache
 692                       : put_values_in_icache), nr_prefetched_words);
 693
 694   lf_printf (file, "\n");
 695   lf_printf (file, "cache_entry->address = cia;\n");
 696   lf_printf (file, "cache_entry->semantic = ");
 697   print_function_name (file,
 698                        instruction->name,
 699                        instruction->format_name,
 700                        NULL, expanded_bits, function_name_prefix_semantics);
 701   lf_printf (file, ";\n");
 702   lf_printf (file, "\n");
 703
 704   if (options.gen.semantic_icache)
 705     {
 706       lf_printf (file, "/* semantic routine */\n");
 707       print_semantic_body (file, instruction, expanded_bits, opcodes);
 708       lf_printf (file, "return nia;\n");
 709     }
 710
 711   if (!options.gen.semantic_icache)
 712     {
 713       lf_printf (file, "/* return the function proper */\n");
 714       lf_printf (file, "return ");
 715       print_function_name (file,
 716                            instruction->name,
 717                            instruction->format_name,
 718                            NULL,
 719                            expanded_bits, function_name_prefix_semantics);
 720       lf_printf (file, ";\n");
 721     }
 722
 723   if (options.gen.direct_access)
 724     {
 725       print_icache_body (file,
 726                          instruction,
 727                          expanded_bits,
 728                          cache_rules,
 729                          undef_variables,
 730                          (options.gen.semantic_icache
 731                           ? both_values_and_icache
 732                           : put_values_in_icache), nr_prefetched_words);
 733     }
 734
 735   lf_indent (file, -2);
 736   lf_printf (file, "}\n");
 737   lf_indent (file, -2);
 738   lf_printf (file, "}\n");
 739 }
 740
 741
 742 void
 743 print_icache_definition (lf *file,
 744                          insn_entry * insn,
 745                          opcode_bits *expanded_bits,
 746                          insn_opcodes *opcodes,
 747                          cache_entry *cache_rules, int nr_prefetched_words)
 748 {
 749   print_icache_function (file,
 750                          insn,
 751                          expanded_bits,
 752                          opcodes, cache_rules, nr_prefetched_words);
 753 }
 754
 755
 756
 757 void
 758 print_icache_internal_function_declaration (lf *file,
 759                                             function_entry * function,
 760                                             void *data)
 761 {
 762   ASSERT (options.gen.icache);
 763   if (function->is_internal)
 764     {
 765       lf_printf (file, "\n");
 766       lf_print__function_type_function (file, print_icache_function_type,
 767                                         "INLINE_ICACHE", "\n");
 768       print_function_name (file,
 769                            function->name,
 770                            NULL, NULL, NULL, function_name_prefix_icache);
 771       lf_printf (file, "\n(");
 772       print_icache_function_formal (file, 0);
 773       lf_printf (file, ");\n");
 774     }
 775 }
 776
 777
 778 void
 779 print_icache_internal_function_definition (lf *file,
 780                                            function_entry * function,
 781                                            void *data)
 782 {
 783   ASSERT (options.gen.icache);
 784   if (function->is_internal)
 785     {
 786       lf_printf (file, "\n");
 787       lf_print__function_type_function (file, print_icache_function_type,
 788                                         "INLINE_ICACHE", "\n");
 789       print_function_name (file,
 790                            function->name,
 791                            NULL, NULL, NULL, function_name_prefix_icache);
 792       lf_printf (file, "\n(");
 793       print_icache_function_formal (file, 0);
 794       lf_printf (file, ")\n");
 795       lf_printf (file, "{\n");
 796       lf_indent (file, +2);
 797       lf_printf (file, "/* semantic routine */\n");
 798       if (options.gen.semantic_icache)
 799         {
 800           lf_print__line_ref (file, function->code->line);
 801           table_print_code (file, function->code);
 802           lf_printf (file,
 803                      "error (\"Internal function must longjump\\n\");\n");
 804           lf_printf (file, "return 0;\n");
 805         }
 806       else
 807         {
 808           lf_printf (file, "return ");
 809           print_function_name (file,
 810                                function->name,
 811                                NULL,
 812                                NULL, NULL, function_name_prefix_semantics);
 813           lf_printf (file, ";\n");
 814         }
 815
 816       lf_print__internal_ref (file);
 817       lf_indent (file, -2);
 818       lf_printf (file, "}\n");
 819     }
 820 }