| 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 | #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, "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, "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 | } |