sim/ppc/gen-icache.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 3 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, see <http://www.gnu.org/licenses/>.
  17
  18     */
  19
  20 #include <stdlib.h>
  21
  22 #include "misc.h"
  23 #include "lf.h"
  24 #include "table.h"
  25
  26 #include "filter.h"
  27
  28 #include "ld-decode.h"
  29 #include "ld-cache.h"
  30 #include "ld-insn.h"
  31
  32 #include "igen.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                              insn_bits *expanded_bits,
  44                              int is_function_definition)
  45 {
  46   lf_printf(file, "\n");
  47   lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "EXTERN_ICACHE", " ");
  48   print_function_name(file,
  49                       basename,
  50                       expanded_bits,
  51                       function_name_prefix_icache);
  52   lf_printf(file, "\n(%s)", ICACHE_FUNCTION_FORMAL);
  53   if (!is_function_definition)
  54     lf_printf(file, ";");
  55   lf_printf(file, "\n");
  56 }
  57
  58
  59 void
  60 print_icache_declaration(insn_table *entry,
  61                          lf *file,
  62                          void *data,
  63                          insn *instruction,
  64                          int depth)
  65 {
  66   if (generate_expanded_instructions) {
  67     ASSERT(entry->nr_insn == 1);
  68     print_icache_function_header(file,
  69                                  entry->insns->file_entry->fields[insn_name],
  70                                  entry->expanded_bits,
  71                                  0/* is not function definition */);
  72   }
  73   else {
  74     print_icache_function_header(file,
  75                                  instruction->file_entry->fields[insn_name],
  76                                  NULL,
  77                                  0/* is not function definition */);
  78   }
  79 }
  80
  81
  82
  83 static void
  84 print_icache_extraction(lf *file,
  85                         insn *instruction,
  86                         const char *entry_name,
  87                         const char *entry_type,
  88                         const char *entry_expression,
  89                         const char *original_name,
  90                         const char *file_name,
  91                         int line_nr,
  92                         insn_field *cur_field,
  93                         insn_bits *bits,
  94                         icache_decl_type what_to_declare,
  95                         icache_body_type what_to_do,
  96                         const char *reason)
  97 {
  98   const char *expression;
  99   ASSERT(entry_name != NULL);
 100
 101   /* Define a storage area for the cache element */
 102   if (what_to_declare == undef_variables) {
 103     /* We've finished with the value - destory it */
 104     lf_indent_suppress(file);
 105     lf_printf(file, "#undef %s\n", entry_name);
 106     return;
 107   }
 108   else if (what_to_declare == define_variables) {
 109     lf_indent_suppress(file);
 110     lf_printf(file, "#define %s ", entry_name);
 111   }
 112   else {
 113     if (file_name != NULL)
 114       lf_print__external_reference(file, line_nr, file_name);
 115     lf_printf(file, "%s const %s UNUSED = ",
 116               entry_type == NULL ? "unsigned" : entry_type,
 117               entry_name);
 118   }
 119
 120   /* define a value for that storage area as determined by what is in
 121      the cache */
 122   if (bits != NULL
 123       && strcmp(entry_name, cur_field->val_string) == 0
 124       && ((bits->opcode->is_boolean && bits->value == 0)
 125           || (!bits->opcode->is_boolean))) {
 126     /* The simple field has been made constant (as a result of
 127        expanding instructions or similar).  Remember that for a
 128        boolean field, value is either 0 (implying the required
 129        boolean_constant) or nonzero (implying some other value and
 130        handled later below) - Define the variable accordingly */
 131     expression = "constant field";
 132     ASSERT(bits->field == cur_field);
 133     ASSERT(entry_type == NULL);
 134     if (bits->opcode->is_boolean)
 135       lf_printf(file, "%d", bits->opcode->boolean_constant);
 136     else if (bits->opcode->last < bits->field->last)
 137       lf_printf(file, "%d",
 138                 bits->value << (bits->field->last - bits->opcode->last));
 139     else
 140       lf_printf(file, "%d", bits->value);
 141   }
 142   else if (bits != NULL
 143            && original_name != NULL
 144            && strncmp(entry_name,
 145                       original_name, strlen(original_name)) == 0
 146            && strncmp(entry_name + strlen(original_name),
 147                       "_is_", strlen("_is_")) == 0
 148            && ((bits->opcode->is_boolean
 149                 && (atol(entry_name + strlen(original_name) + strlen("_is_"))
 150                     == bits->opcode->boolean_constant))
 151                || (!bits->opcode->is_boolean))) {
 152     expression = "constant compare";
 153     /* An entry, derived from ORIGINAL_NAME, is testing to see of the
 154        ORIGINAL_NAME has a specific constant value.  That value
 155        matching a boolean or constant field */
 156     if (bits->opcode->is_boolean)
 157       lf_printf(file, "%d /* %s == %d */",
 158                 bits->value == 0,
 159                 original_name,
 160                 bits->opcode->boolean_constant);
 161     else if (bits->opcode->last < bits->field->last)
 162       lf_printf(file, "%d /* %s == %d */",
 163                 (atol(entry_name + strlen(original_name) + strlen("_is_"))
 164                  == (bits->value << (bits->field->last - bits->opcode->last))),
 165                 original_name,
 166                 (bits->value << (bits->field->last - bits->opcode->last)));
 167     else
 168       lf_printf(file, "%d /* %s == %d */",
 169                 (atol(entry_name + strlen(original_name) + strlen("_is_"))
 170                  == bits->value),
 171                 original_name,
 172                 bits->value);
 173   }
 174   else {
 175     /* put the field in the local variable, possibly also enter it
 176        into the cache */
 177     expression = "extraction";
 178     /* handle the cache */
 179     if ((what_to_do & get_values_from_icache)
 180         || (what_to_do & put_values_in_icache)) {
 181       lf_printf(file, "cache_entry->crack.%s.%s",
 182                 instruction->file_entry->fields[insn_form],
 183                 entry_name);
 184       if (what_to_do & put_values_in_icache) /* also put it in the cache? */
 185         lf_printf(file, " = ");
 186     }
 187     if ((what_to_do & put_values_in_icache)
 188         || what_to_do == do_not_use_icache) {
 189       if (cur_field != NULL && strcmp(entry_name, cur_field->val_string) == 0)
 190         lf_printf(file, "EXTRACTED32(instruction, %d, %d)",
 191                   i2target(hi_bit_nr, cur_field->first),
 192                   i2target(hi_bit_nr, cur_field->last));
 193       else if (entry_expression != NULL)
 194         lf_printf(file, "%s", entry_expression);
 195       else
 196         lf_printf(file, "eval_%s", entry_name);
 197     }
 198   }
 199
 200   if (!((what_to_declare == define_variables)
 201         || (what_to_declare == undef_variables)))
 202     lf_printf(file, ";");
 203   if (reason != NULL)
 204     lf_printf(file, " /* %s - %s */", reason, expression);
 205   lf_printf(file, "\n");
 206 }
 207
 208
 209 void
 210 print_icache_body(lf *file,
 211                   insn *instruction,
 212                   insn_bits *expanded_bits,
 213                   cache_table *cache_rules,
 214                   icache_decl_type what_to_declare,
 215                   icache_body_type what_to_do)
 216 {
 217   insn_field *cur_field;
 218
 219   /* extract instruction fields */
 220   lf_printf(file, "/* extraction: %s ",
 221             instruction->file_entry->fields[insn_format]);
 222   switch (what_to_declare) {
 223   case define_variables:
 224     lf_printf(file, "#define");
 225     break;
 226   case declare_variables:
 227     lf_printf(file, "declare");
 228     break;
 229   case undef_variables:
 230     lf_printf(file, "#undef");
 231     break;
 232   }
 233   lf_printf(file, " ");
 234   switch (what_to_do) {
 235   case get_values_from_icache:
 236     lf_printf(file, "get-values-from-icache");
 237     break;
 238   case put_values_in_icache:
 239     lf_printf(file, "put-values-in-icache");
 240     break;
 241   case both_values_and_icache:
 242     lf_printf(file, "get-values-from-icache|put-values-in-icache");
 243     break;
 244   case do_not_use_icache:
 245     lf_printf(file, "do-not-use-icache");
 246     break;
 247   }
 248   lf_printf(file, " */\n");
 249
 250   for (cur_field = instruction->fields->first;
 251        cur_field->first < insn_bit_size;
 252        cur_field = cur_field->next) {
 253     if (cur_field->is_string) {
 254       insn_bits *bits;
 255       int found_rule = 0;
 256       /* find any corresponding value */
 257       for (bits = expanded_bits;
 258            bits != NULL;
 259            bits = bits->last) {
 260         if (bits->field == cur_field)
 261           break;
 262       }
 263       /* try the cache rule table for what to do */
 264       {
 265         cache_table *cache_rule;
 266         for (cache_rule = cache_rules;
 267              cache_rule != NULL;
 268              cache_rule = cache_rule->next) {
 269           if (strcmp(cur_field->val_string, cache_rule->field_name) == 0) {
 270             found_rule = 1;
 271             if (cache_rule->type == scratch_value
 272                 && ((what_to_do & put_values_in_icache)
 273                     || what_to_do == do_not_use_icache))
 274               print_icache_extraction(file,
 275                                       instruction,
 276                                       cache_rule->derived_name,
 277                                       cache_rule->type_def,
 278                                       cache_rule->expression,
 279                                       cache_rule->field_name,
 280                                       cache_rule->file_entry->file_name,
 281                                       cache_rule->file_entry->line_nr,
 282                                       cur_field,
 283                                       bits,
 284                                       what_to_declare,
 285                                       do_not_use_icache,
 286                                       "icache scratch");
 287             else if (cache_rule->type == compute_value
 288                      && ((what_to_do & get_values_from_icache)
 289                          || what_to_do == do_not_use_icache))
 290               print_icache_extraction(file,
 291                                       instruction,
 292                                       cache_rule->derived_name,
 293                                       cache_rule->type_def,
 294                                       cache_rule->expression,
 295                                       cache_rule->field_name,
 296                                       cache_rule->file_entry->file_name,
 297                                       cache_rule->file_entry->line_nr,
 298                                       cur_field,
 299                                       bits,
 300                                       what_to_declare,
 301                                       do_not_use_icache,
 302                                       "semantic compute");
 303             else if (cache_rule->type == cache_value
 304                      && ((what_to_declare != undef_variables)
 305                          || !(what_to_do & put_values_in_icache)))
 306               print_icache_extraction(file,
 307                                       instruction,
 308                                       cache_rule->derived_name,
 309                                       cache_rule->type_def,
 310                                       cache_rule->expression,
 311                                       cache_rule->field_name,
 312                                       cache_rule->file_entry->file_name,
 313                                       cache_rule->file_entry->line_nr,
 314                                       cur_field,
 315                                       bits,
 316                                       ((what_to_do & put_values_in_icache)
 317                                        ? declare_variables
 318                                        : what_to_declare),
 319                                       what_to_do,
 320                                       "in icache");
 321           }
 322         }
 323       }
 324       /* No rule at all, assume that this is needed in the semantic
 325          function (when values are extracted from the icache) and
 326          hence must be put into the cache */
 327       if (found_rule == 0
 328           && ((what_to_declare != undef_variables)
 329               || !(what_to_do & put_values_in_icache)))
 330         print_icache_extraction(file,
 331                                 instruction,
 332                                 cur_field->val_string,
 333                                 NULL, NULL, NULL, /* type, exp, orig */
 334                                 instruction->file_entry->file_name,
 335                                 instruction->file_entry->line_nr,
 336                                 cur_field,
 337                                 bits,
 338                                 ((what_to_do & put_values_in_icache)
 339                                  ? declare_variables
 340                                  : what_to_declare),
 341                                 what_to_do,
 342                                 "default in icache");
 343       /* any thing else ... */
 344     }
 345   }
 346
 347   lf_print__internal_reference(file);
 348
 349   if ((code & generate_with_insn_in_icache)) {
 350     lf_printf(file, "\n");
 351     print_icache_extraction(file,
 352                             instruction,
 353                             "insn",
 354                             "instruction_word",
 355                             "instruction",
 356                             NULL, /* origin */
 357                             NULL, 0, /* file_name & line_nr */
 358                             NULL, NULL,
 359                             what_to_declare,
 360                             what_to_do,
 361                             NULL);
 362   }
 363 }
 364
 365
 366
 367 typedef struct _icache_tree icache_tree;
 368 struct _icache_tree {
 369   char *name;
 370   icache_tree *next;
 371   icache_tree *children;
 372 };
 373
 374 static icache_tree *
 375 icache_tree_insert(icache_tree *tree,
 376                    char *name)
 377 {
 378   icache_tree *new_tree;
 379   /* find it */
 380   icache_tree **ptr_to_cur_tree = &tree->children;
 381   icache_tree *cur_tree = *ptr_to_cur_tree;
 382   while (cur_tree != NULL
 383          && strcmp(cur_tree->name, name) < 0) {
 384     ptr_to_cur_tree = &cur_tree->next;
 385     cur_tree = *ptr_to_cur_tree;
 386   }
 387   ASSERT(cur_tree == NULL
 388          || strcmp(cur_tree->name, name) >= 0);
 389   /* already in the tree */
 390   if (cur_tree != NULL
 391       && strcmp(cur_tree->name, name) == 0)
 392     return cur_tree;
 393   /* missing, insert it */
 394   ASSERT(cur_tree == NULL
 395          || strcmp(cur_tree->name, name) > 0);
 396   new_tree = ZALLOC(icache_tree);
 397   new_tree->name = name;
 398   new_tree->next = cur_tree;
 399   *ptr_to_cur_tree = new_tree;
 400   return new_tree;
 401 }
 402
 403
 404 static icache_tree *
 405 insn_table_cache_fields(insn_table *table)
 406 {
 407   icache_tree *tree = ZALLOC(icache_tree);
 408   insn *instruction;
 409   for (instruction = table->insns;
 410        instruction != NULL;
 411        instruction = instruction->next) {
 412     insn_field *field;
 413     icache_tree *form =
 414       icache_tree_insert(tree,
 415                          instruction->file_entry->fields[insn_form]);
 416     for (field = instruction->fields->first;
 417          field != NULL;
 418          field = field->next) {
 419       if (field->is_string)
 420         icache_tree_insert(form, field->val_string);
 421     }
 422   }
 423   return tree;
 424 }
 425
 426
 427
 428 extern void
 429 print_icache_struct(insn_table *instructions,
 430                     cache_table *cache_rules,
 431                     lf *file)
 432 {
 433   icache_tree *tree = insn_table_cache_fields(instructions);
 434
 435   lf_printf(file, "\n");
 436   lf_printf(file, "#define WITH_IDECODE_CACHE_SIZE %d\n",
 437             (code & generate_with_icache) ? icache_size : 0);
 438   lf_printf(file, "\n");
 439
 440   /* create an instruction cache if being used */
 441   if ((code & generate_with_icache)) {
 442     icache_tree *form;
 443     lf_printf(file, "typedef struct _idecode_cache {\n");
 444     lf_printf(file, "  unsigned_word address;\n");
 445     lf_printf(file, "  void *semantic;\n");
 446     lf_printf(file, "  union {\n");
 447     for (form = tree->children;
 448          form != NULL;
 449          form = form->next) {
 450       icache_tree *field;
 451       lf_printf(file, "    struct {\n");
 452       if (code & generate_with_insn_in_icache)
 453         lf_printf(file, "      instruction_word insn;\n");
 454       for (field = form->children;
 455            field != NULL;
 456            field = field->next) {
 457         cache_table *cache_rule;
 458         int found_rule = 0;
 459         for (cache_rule = cache_rules;
 460              cache_rule != NULL;
 461              cache_rule = cache_rule->next) {
 462           if (strcmp(field->name, cache_rule->field_name) == 0) {
 463             found_rule = 1;
 464             if (cache_rule->derived_name != NULL)
 465               lf_printf(file, "      %s %s; /* %s */\n",
 466                         (cache_rule->type_def == NULL
 467                          ? "unsigned"
 468                          : cache_rule->type_def),
 469                         cache_rule->derived_name,
 470                         cache_rule->field_name);
 471           }
 472         }
 473         if (!found_rule)
 474           lf_printf(file, "      unsigned %s;\n", field->name);
 475       }
 476       lf_printf(file, "    } %s;\n", form->name);
 477     }
 478     lf_printf(file, "  } crack;\n");
 479     lf_printf(file, "} idecode_cache;\n");
 480   }
 481   else {
 482     /* alernativly, since no cache, emit a dummy definition for
 483        idecode_cache so that code refering to the type can still compile */
 484     lf_printf(file, "typedef void idecode_cache;\n");
 485   }
 486   lf_printf(file, "\n");
 487 }
 488
 489
 490
 491 static void
 492 print_icache_function(lf *file,
 493                       insn *instruction,
 494                       insn_bits *expanded_bits,
 495                       opcode_field *opcodes,
 496                       cache_table *cache_rules)
 497 {
 498   int indent;
 499
 500   /* generate code to enter decoded instruction into the icache */
 501   lf_printf(file, "\n");
 502   lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "EXTERN_ICACHE", "\n");
 503   indent = print_function_name(file,
 504                                instruction->file_entry->fields[insn_name],
 505                                expanded_bits,
 506                                function_name_prefix_icache);
 507   lf_indent(file, +indent);
 508   lf_printf(file, "(%s)\n", ICACHE_FUNCTION_FORMAL);
 509   lf_indent(file, -indent);
 510
 511   /* function header */
 512   lf_printf(file, "{\n");
 513   lf_indent(file, +2);
 514
 515   print_my_defines(file, expanded_bits, instruction->file_entry);
 516   print_itrace(file, instruction->file_entry, 1/*putting-value-in-cache*/);
 517
 518   print_idecode_validate(file, instruction, opcodes);
 519
 520   lf_printf(file, "\n");
 521   lf_printf(file, "{\n");
 522   lf_indent(file, +2);
 523   if ((code & generate_with_semantic_icache))
 524     lf_printf(file, "unsigned_word nia;\n");
 525   print_icache_body(file,
 526                     instruction,
 527                     expanded_bits,
 528                     cache_rules,
 529                     ((code & generate_with_direct_access)
 530                      ? define_variables
 531                      : declare_variables),
 532                     ((code & generate_with_semantic_icache)
 533                      ? both_values_and_icache
 534                      : put_values_in_icache));
 535
 536   lf_printf(file, "\n");
 537   lf_printf(file, "cache_entry->address = cia;\n");
 538   lf_printf(file, "cache_entry->semantic = ");
 539   print_function_name(file,
 540                       instruction->file_entry->fields[insn_name],
 541                       expanded_bits,
 542                       function_name_prefix_semantics);
 543   lf_printf(file, ";\n");
 544   lf_printf(file, "\n");
 545
 546   if ((code & generate_with_semantic_icache)) {
 547     lf_printf(file, "/* semantic routine */\n");
 548     print_semantic_body(file,
 549                         instruction,
 550                         expanded_bits,
 551                         opcodes);
 552     lf_printf(file, "return nia;\n");
 553   }
 554
 555   if (!(code & generate_with_semantic_icache)) {
 556     lf_printf(file, "/* return the function proper */\n");
 557     lf_printf(file, "return ");
 558     print_function_name(file,
 559                         instruction->file_entry->fields[insn_name],
 560                         expanded_bits,
 561                         function_name_prefix_semantics);
 562     lf_printf(file, ";\n");
 563   }
 564
 565   if ((code & generate_with_direct_access))
 566     print_icache_body(file,
 567                       instruction,
 568                       expanded_bits,
 569                       cache_rules,
 570                       undef_variables,
 571                       ((code & generate_with_semantic_icache)
 572                        ? both_values_and_icache
 573                        : put_values_in_icache));
 574
 575   lf_indent(file, -2);
 576   lf_printf(file, "}\n");
 577   lf_indent(file, -2);
 578   lf_printf(file, "}\n");
 579 }
 580
 581
 582 void
 583 print_icache_definition(insn_table *entry,
 584                         lf *file,
 585                         void *data,
 586                         insn *instruction,
 587                         int depth)
 588 {
 589   cache_table *cache_rules = (cache_table*)data;
 590   if (generate_expanded_instructions) {
 591     ASSERT(entry->nr_insn == 1
 592            && entry->opcode == NULL
 593            && entry->parent != NULL
 594            && entry->parent->opcode != NULL);
 595     ASSERT(entry->nr_insn == 1
 596            && entry->opcode == NULL
 597            && entry->parent != NULL
 598            && entry->parent->opcode != NULL
 599            && entry->parent->opcode_rule != NULL);
 600     print_icache_function(file,
 601                           entry->insns,
 602                           entry->expanded_bits,
 603                           entry->opcode,
 604                           cache_rules);
 605   }
 606   else {
 607     print_icache_function(file,
 608                           instruction,
 609                           NULL,
 610                           NULL,
 611                           cache_rules);
 612   }
 613 }
 614
 615
 616
 617 void
 618 print_icache_internal_function_declaration(insn_table *table,
 619                                            lf *file,
 620                                            void *data,
 621                                            table_entry *function)
 622 {
 623   ASSERT((code & generate_with_icache) != 0);
 624   if (it_is("internal", function->fields[insn_flags])) {
 625     lf_printf(file, "\n");
 626     lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "PSIM_INLINE_ICACHE",
 627                            "\n");
 628     print_function_name(file,
 629                         function->fields[insn_name],
 630                         NULL,
 631                         function_name_prefix_icache);
 632     lf_printf(file, "\n(%s);\n", ICACHE_FUNCTION_FORMAL);
 633   }
 634 }
 635
 636
 637 void
 638 print_icache_internal_function_definition(insn_table *table,
 639                                           lf *file,
 640                                           void *data,
 641                                           table_entry *function)
 642 {
 643   ASSERT((code & generate_with_icache) != 0);
 644   if (it_is("internal", function->fields[insn_flags])) {
 645     lf_printf(file, "\n");
 646     lf_print_function_type(file, ICACHE_FUNCTION_TYPE, "PSIM_INLINE_ICACHE",
 647                            "\n");
 648     print_function_name(file,
 649                         function->fields[insn_name],
 650                         NULL,
 651                         function_name_prefix_icache);
 652     lf_printf(file, "\n(%s)\n", ICACHE_FUNCTION_FORMAL);
 653     lf_printf(file, "{\n");
 654     lf_indent(file, +2);
 655     lf_printf(file, "/* semantic routine */\n");
 656     table_entry_print_cpp_line_nr(file, function);
 657     if ((code & generate_with_semantic_icache)) {
 658       lf_print__c_code(file, function->annex);
 659       lf_printf(file, "error(\"Internal function must longjump\\n\");\n");
 660       lf_printf(file, "return 0;\n");
 661     }
 662     else {
 663       lf_printf(file, "return ");
 664       print_function_name(file,
 665                           function->fields[insn_name],
 666                           NULL,
 667                           function_name_prefix_semantics);
 668       lf_printf(file, ";\n");
 669     }
 670
 671     lf_print__internal_reference(file);
 672     lf_indent(file, -2);
 673     lf_printf(file, "}\n");
 674   }
 675 }