1 /* The IGEN simulator generator for GDB, the GNU Debugger. 2 3 Copyright 2002-2014 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 } 821