1/* read-rtl-function.cc - Reader for RTL function dumps 2 Copyright (C) 2016-2022 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14for more details. 15 16You should have received a copy of the GNU General Public License 17along with GCC; see the file COPYING3. If not see 18<http://www.gnu.org/licenses/>. */ 19 20#include "config.h" 21#include "system.h" 22#include "coretypes.h" 23#include "target.h" 24#include "tree.h" 25#include "diagnostic.h" 26#include "read-md.h" 27#include "rtl.h" 28#include "cfghooks.h" 29#include "stringpool.h" 30#include "function.h" 31#include "tree-cfg.h" 32#include "cfg.h" 33#include "basic-block.h" 34#include "cfgrtl.h" 35#include "memmodel.h" 36#include "emit-rtl.h" 37#include "cgraph.h" 38#include "tree-pass.h" 39#include "toplev.h" 40#include "varasm.h" 41#include "read-rtl-function.h" 42#include "selftest.h" 43#include "selftest-rtl.h" 44#include "regs.h" 45#include "function-abi.h" 46 47/* Forward decls. */ 48class function_reader; 49class fixup; 50 51/* Edges are recorded when parsing the "insn-chain" directive, 52 and created at the end when all the blocks ought to exist. 53 This struct records an "edge-from" or "edge-to" directive seen 54 at LOC, which will be turned into an actual CFG edge once 55 the "insn-chain" is fully parsed. */ 56 57class deferred_edge 58{ 59public: 60 deferred_edge (file_location loc, int src_bb_idx, int dest_bb_idx, int flags) 61 : m_loc (loc), m_src_bb_idx (src_bb_idx), m_dest_bb_idx (dest_bb_idx), 62 m_flags (flags) 63 {} 64 65 file_location m_loc; 66 int m_src_bb_idx; 67 int m_dest_bb_idx; 68 int m_flags; 69}; 70 71/* Subclass of rtx_reader for reading function dumps. */ 72 73class function_reader : public rtx_reader 74{ 75 public: 76 function_reader (); 77 ~function_reader (); 78 79 /* Overridden vfuncs of class md_reader. */ 80 void handle_unknown_directive (file_location, const char *) FINAL OVERRIDE; 81 82 /* Overridden vfuncs of class rtx_reader. */ 83 rtx read_rtx_operand (rtx x, int idx) FINAL OVERRIDE; 84 void handle_any_trailing_information (rtx x) FINAL OVERRIDE; 85 rtx postprocess (rtx) FINAL OVERRIDE; 86 const char *finalize_string (char *stringbuf) FINAL OVERRIDE; 87 88 rtx_insn **get_insn_by_uid (int uid); 89 tree parse_mem_expr (const char *desc); 90 91 private: 92 void parse_function (); 93 void create_function (); 94 void parse_param (); 95 void parse_insn_chain (); 96 void parse_block (); 97 int parse_bb_idx (); 98 void parse_edge (basic_block block, bool from); 99 rtx_insn *parse_insn (file_location loc, const char *name); 100 void parse_cfg (file_location loc); 101 void parse_crtl (file_location loc); 102 void create_edges (); 103 104 int parse_enum_value (int num_values, const char *const *strings); 105 106 void read_rtx_operand_u (rtx x, int idx); 107 void read_rtx_operand_i_or_n (rtx x, int idx, char format_char); 108 rtx read_rtx_operand_r (rtx x); 109 rtx extra_parsing_for_operand_code_0 (rtx x, int idx); 110 111 void add_fixup_insn_uid (file_location loc, rtx insn, int operand_idx, 112 int insn_uid); 113 114 void add_fixup_note_insn_basic_block (file_location loc, rtx insn, 115 int operand_idx, int bb_idx); 116 117 void add_fixup_source_location (file_location loc, rtx_insn *insn, 118 const char *filename, int lineno, int colno); 119 120 void add_fixup_expr (file_location loc, rtx x, 121 const char *desc); 122 123 rtx consolidate_singletons (rtx x); 124 rtx parse_rtx (); 125 void maybe_read_location (rtx_insn *insn); 126 127 void handle_insn_uids (); 128 void apply_fixups (); 129 130 private: 131 struct uid_hash : int_hash <int, -1, -2> {}; 132 hash_map<uid_hash, rtx_insn *> m_insns_by_uid; 133 auto_vec<fixup *> m_fixups; 134 rtx_insn *m_first_insn; 135 auto_vec<tree> m_fake_scope; 136 char *m_name; 137 bool m_have_crtl_directive; 138 basic_block m_bb_to_insert_after; 139 auto_vec <deferred_edge> m_deferred_edges; 140 int m_highest_bb_idx; 141}; 142 143/* Abstract base class for recording post-processing steps that must be 144 done after reading a .rtl file. */ 145 146class fixup 147{ 148 public: 149 /* Constructor for a fixup at LOC affecting X. */ 150 fixup (file_location loc, rtx x) 151 : m_loc (loc), m_rtx (x) 152 {} 153 virtual ~fixup () {} 154 155 virtual void apply (function_reader *reader) const = 0; 156 157 protected: 158 file_location m_loc; 159 rtx m_rtx; 160}; 161 162/* An abstract subclass of fixup for post-processing steps that 163 act on a specific operand of a specific instruction. */ 164 165class operand_fixup : public fixup 166{ 167 public: 168 /* Constructor for a fixup at LOC affecting INSN's operand 169 with index OPERAND_IDX. */ 170 operand_fixup (file_location loc, rtx insn, int operand_idx) 171 : fixup (loc, insn), m_operand_idx (operand_idx) 172 {} 173 174 protected: 175 int m_operand_idx; 176}; 177 178/* A concrete subclass of operand_fixup: fixup an rtx_insn * 179 field based on an integer UID. */ 180 181class fixup_insn_uid : public operand_fixup 182{ 183 public: 184 /* Constructor for a fixup at LOC affecting INSN's operand 185 with index OPERAND_IDX. Record INSN_UID as the uid. */ 186 fixup_insn_uid (file_location loc, rtx insn, int operand_idx, int insn_uid) 187 : operand_fixup (loc, insn, operand_idx), 188 m_insn_uid (insn_uid) 189 {} 190 191 void apply (function_reader *reader) const; 192 193 private: 194 int m_insn_uid; 195}; 196 197/* A concrete subclass of operand_fixup: fix up a 198 NOTE_INSN_BASIC_BLOCK based on an integer block ID. */ 199 200class fixup_note_insn_basic_block : public operand_fixup 201{ 202 public: 203 fixup_note_insn_basic_block (file_location loc, rtx insn, int operand_idx, 204 int bb_idx) 205 : operand_fixup (loc, insn, operand_idx), 206 m_bb_idx (bb_idx) 207 {} 208 209 void apply (function_reader *reader) const; 210 211 private: 212 int m_bb_idx; 213}; 214 215/* A concrete subclass of fixup (not operand_fixup): fix up 216 the expr of an rtx (REG or MEM) based on a textual dump. */ 217 218class fixup_expr : public fixup 219{ 220 public: 221 fixup_expr (file_location loc, rtx x, const char *desc) 222 : fixup (loc, x), 223 m_desc (xstrdup (desc)) 224 {} 225 226 ~fixup_expr () { free (m_desc); } 227 228 void apply (function_reader *reader) const; 229 230 private: 231 char *m_desc; 232}; 233 234/* Return a textual description of the operand of INSN with 235 index OPERAND_IDX. */ 236 237static const char * 238get_operand_name (rtx insn, int operand_idx) 239{ 240 gcc_assert (is_a <rtx_insn *> (insn)); 241 switch (operand_idx) 242 { 243 case 0: 244 return "PREV_INSN"; 245 case 1: 246 return "NEXT_INSN"; 247 default: 248 return NULL; 249 } 250} 251 252/* Fixup an rtx_insn * field based on an integer UID, as read by READER. */ 253 254void 255fixup_insn_uid::apply (function_reader *reader) const 256{ 257 rtx_insn **insn_from_uid = reader->get_insn_by_uid (m_insn_uid); 258 if (insn_from_uid) 259 XEXP (m_rtx, m_operand_idx) = *insn_from_uid; 260 else 261 { 262 const char *op_name = get_operand_name (m_rtx, m_operand_idx); 263 if (op_name) 264 error_at (m_loc, 265 "insn with UID %i not found for operand %i (`%s') of insn %i", 266 m_insn_uid, m_operand_idx, op_name, INSN_UID (m_rtx)); 267 else 268 error_at (m_loc, 269 "insn with UID %i not found for operand %i of insn %i", 270 m_insn_uid, m_operand_idx, INSN_UID (m_rtx)); 271 } 272} 273 274/* Fix up a NOTE_INSN_BASIC_BLOCK based on an integer block ID. */ 275 276void 277fixup_note_insn_basic_block::apply (function_reader *) const 278{ 279 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, m_bb_idx); 280 gcc_assert (bb); 281 NOTE_BASIC_BLOCK (m_rtx) = bb; 282} 283 284/* Fix up the expr of an rtx (REG or MEM) based on a textual dump 285 read by READER. */ 286 287void 288fixup_expr::apply (function_reader *reader) const 289{ 290 tree expr = reader->parse_mem_expr (m_desc); 291 switch (GET_CODE (m_rtx)) 292 { 293 case REG: 294 set_reg_attrs_for_decl_rtl (expr, m_rtx); 295 break; 296 case MEM: 297 set_mem_expr (m_rtx, expr); 298 break; 299 default: 300 gcc_unreachable (); 301 } 302} 303 304/* Strip trailing whitespace from DESC. */ 305 306static void 307strip_trailing_whitespace (char *desc) 308{ 309 char *terminator = desc + strlen (desc); 310 while (desc < terminator) 311 { 312 terminator--; 313 if (ISSPACE (*terminator)) 314 *terminator = '\0'; 315 else 316 break; 317 } 318} 319 320/* Return the numeric value n for GET_NOTE_INSN_NAME (n) for STRING, 321 or fail if STRING isn't recognized. */ 322 323static int 324parse_note_insn_name (const char *string) 325{ 326 for (int i = 0; i < NOTE_INSN_MAX; i++) 327 if (strcmp (string, GET_NOTE_INSN_NAME (i)) == 0) 328 return i; 329 fatal_with_file_and_line ("unrecognized NOTE_INSN name: `%s'", string); 330} 331 332/* Return the register number for NAME, or return -1 if it isn't 333 recognized. */ 334 335static int 336lookup_reg_by_dump_name (const char *name) 337{ 338 for (int i = 0; i < FIRST_PSEUDO_REGISTER; i++) 339 if (reg_names[i][0] 340 && ! strcmp (name, reg_names[i])) 341 return i; 342 343 /* Also lookup virtuals. */ 344 if (!strcmp (name, "virtual-incoming-args")) 345 return VIRTUAL_INCOMING_ARGS_REGNUM; 346 if (!strcmp (name, "virtual-stack-vars")) 347 return VIRTUAL_STACK_VARS_REGNUM; 348 if (!strcmp (name, "virtual-stack-dynamic")) 349 return VIRTUAL_STACK_DYNAMIC_REGNUM; 350 if (!strcmp (name, "virtual-outgoing-args")) 351 return VIRTUAL_OUTGOING_ARGS_REGNUM; 352 if (!strcmp (name, "virtual-cfa")) 353 return VIRTUAL_CFA_REGNUM; 354 if (!strcmp (name, "virtual-preferred-stack-boundary")) 355 return VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM; 356 /* TODO: handle "virtual-reg-%d". */ 357 358 /* In compact mode, pseudos are printed with '< and '>' wrapping the regno, 359 offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the 360 first non-virtual pseudo is dumped as "<0>". */ 361 if (name[0] == '<' && name[strlen (name) - 1] == '>') 362 { 363 int dump_num = atoi (name + 1); 364 return dump_num + LAST_VIRTUAL_REGISTER + 1; 365 } 366 367 /* Not found. */ 368 return -1; 369} 370 371/* class function_reader : public rtx_reader */ 372 373/* function_reader's constructor. */ 374 375function_reader::function_reader () 376: rtx_reader (true), 377 m_first_insn (NULL), 378 m_name (NULL), 379 m_have_crtl_directive (false), 380 m_bb_to_insert_after (NULL), 381 m_highest_bb_idx (EXIT_BLOCK) 382{ 383} 384 385/* function_reader's destructor. */ 386 387function_reader::~function_reader () 388{ 389 int i; 390 fixup *f; 391 FOR_EACH_VEC_ELT (m_fixups, i, f) 392 delete f; 393 394 free (m_name); 395} 396 397/* Implementation of rtx_reader::handle_unknown_directive, 398 for parsing the remainder of a directive with name NAME 399 seen at START_LOC. 400 401 Require a top-level "function" directive, as emitted by 402 print_rtx_function, and parse it. */ 403 404void 405function_reader::handle_unknown_directive (file_location start_loc, 406 const char *name) 407{ 408 if (strcmp (name, "function")) 409 fatal_at (start_loc, "expected 'function'"); 410 411 if (flag_lto) 412 error ("%<__RTL%> function cannot be compiled with %<-flto%>"); 413 414 parse_function (); 415} 416 417/* Parse the output of print_rtx_function (or hand-written data in the 418 same format), having already parsed the "(function" heading, and 419 finishing immediately before the final ")". 420 421 The "param" and "crtl" clauses are optional. */ 422 423void 424function_reader::parse_function () 425{ 426 m_name = xstrdup (read_string (0)); 427 428 create_function (); 429 430 while (1) 431 { 432 int c = read_skip_spaces (); 433 if (c == ')') 434 { 435 unread_char (c); 436 break; 437 } 438 unread_char (c); 439 require_char ('('); 440 file_location loc = get_current_location (); 441 struct md_name directive; 442 read_name (&directive); 443 if (strcmp (directive.string, "param") == 0) 444 parse_param (); 445 else if (strcmp (directive.string, "insn-chain") == 0) 446 parse_insn_chain (); 447 else if (strcmp (directive.string, "crtl") == 0) 448 parse_crtl (loc); 449 else 450 fatal_with_file_and_line ("unrecognized directive: %s", 451 directive.string); 452 } 453 454 handle_insn_uids (); 455 456 apply_fixups (); 457 458 /* Rebuild the JUMP_LABEL field of any JUMP_INSNs in the chain, and the 459 LABEL_NUSES of any CODE_LABELs. 460 461 This has to happen after apply_fixups, since only after then do 462 LABEL_REFs have their label_ref_label set up. */ 463 rebuild_jump_labels (get_insns ()); 464 465 crtl->init_stack_alignment (); 466} 467 468/* Set up state for the function *before* fixups are applied. 469 470 Create "cfun" and a decl for the function. 471 By default, every function decl is hardcoded as 472 int test_1 (int i, int j, int k); 473 Set up various other state: 474 - the cfg and basic blocks (edges are created later, *after* fixups 475 are applied). 476 - add the function to the callgraph. */ 477 478void 479function_reader::create_function () 480{ 481 /* We start in cfgrtl mode, rather than cfglayout mode. */ 482 rtl_register_cfg_hooks (); 483 484 /* When run from selftests or "rtl1", cfun is NULL. 485 When run from "cc1" for a C function tagged with __RTL, cfun is the 486 tagged function. */ 487 if (!cfun) 488 { 489 tree fn_name = get_identifier (m_name ? m_name : "test_1"); 490 tree int_type = integer_type_node; 491 tree return_type = int_type; 492 tree arg_types[3] = {int_type, int_type, int_type}; 493 tree fn_type = build_function_type_array (return_type, 3, arg_types); 494 tree fndecl = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, fn_name, fn_type); 495 tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL, NULL_TREE, 496 return_type); 497 DECL_ARTIFICIAL (resdecl) = 1; 498 DECL_IGNORED_P (resdecl) = 1; 499 DECL_RESULT (fndecl) = resdecl; 500 allocate_struct_function (fndecl, false); 501 /* This sets cfun. */ 502 current_function_decl = fndecl; 503 } 504 505 gcc_assert (cfun); 506 gcc_assert (current_function_decl); 507 tree fndecl = current_function_decl; 508 509 /* Mark this function as being specified as __RTL. */ 510 cfun->curr_properties |= PROP_rtl; 511 512 /* cc1 normally inits DECL_INITIAL (fndecl) to be error_mark_node. 513 Create a dummy block for it. */ 514 DECL_INITIAL (fndecl) = make_node (BLOCK); 515 516 cfun->curr_properties = (PROP_cfg | PROP_rtl); 517 518 /* Do we need this to force cgraphunit.cc to output the function? */ 519 DECL_EXTERNAL (fndecl) = 0; 520 DECL_PRESERVE_P (fndecl) = 1; 521 522 /* Add to cgraph. */ 523 cgraph_node::finalize_function (fndecl, false); 524 525 /* Create bare-bones cfg. This creates the entry and exit blocks. */ 526 init_empty_tree_cfg_for_function (cfun); 527 ENTRY_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL; 528 EXIT_BLOCK_PTR_FOR_FN (cfun)->flags |= BB_RTL; 529 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun)); 530 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun)); 531 m_bb_to_insert_after = ENTRY_BLOCK_PTR_FOR_FN (cfun); 532 533} 534 535/* Look within the params of FNDECL for a param named NAME. 536 Return NULL_TREE if one isn't found. */ 537 538static tree 539find_param_by_name (tree fndecl, const char *name) 540{ 541 for (tree arg = DECL_ARGUMENTS (fndecl); arg; arg = TREE_CHAIN (arg)) 542 if (id_equal (DECL_NAME (arg), name)) 543 return arg; 544 return NULL_TREE; 545} 546 547/* Parse the content of a "param" directive, having already parsed the 548 "(param". Consume the trailing ')'. */ 549 550void 551function_reader::parse_param () 552{ 553 require_char_ws ('"'); 554 file_location loc = get_current_location (); 555 char *name = read_quoted_string (); 556 557 /* Lookup param by name. */ 558 tree t_param = find_param_by_name (cfun->decl, name); 559 if (!t_param) 560 fatal_at (loc, "param not found: %s", name); 561 562 /* Parse DECL_RTL. */ 563 require_char_ws ('('); 564 require_word_ws ("DECL_RTL"); 565 DECL_WRTL_CHECK (t_param)->decl_with_rtl.rtl = parse_rtx (); 566 require_char_ws (')'); 567 568 /* Parse DECL_RTL_INCOMING. */ 569 require_char_ws ('('); 570 require_word_ws ("DECL_RTL_INCOMING"); 571 DECL_INCOMING_RTL (t_param) = parse_rtx (); 572 require_char_ws (')'); 573 574 require_char_ws (')'); 575} 576 577/* Parse zero or more child insn elements within an 578 "insn-chain" element. Consume the trailing ')'. */ 579 580void 581function_reader::parse_insn_chain () 582{ 583 while (1) 584 { 585 int c = read_skip_spaces (); 586 file_location loc = get_current_location (); 587 if (c == ')') 588 break; 589 else if (c == '(') 590 { 591 struct md_name directive; 592 read_name (&directive); 593 if (strcmp (directive.string, "block") == 0) 594 parse_block (); 595 else 596 parse_insn (loc, directive.string); 597 } 598 else 599 fatal_at (loc, "expected '(' or ')'"); 600 } 601 602 create_edges (); 603} 604 605/* Parse zero or more child directives (edges and insns) within a 606 "block" directive, having already parsed the "(block " heading. 607 Consume the trailing ')'. */ 608 609void 610function_reader::parse_block () 611{ 612 /* Parse the index value from the dump. This will be an integer; 613 we don't support "entry" or "exit" here (unlike for edges). */ 614 struct md_name name; 615 read_name (&name); 616 int bb_idx = atoi (name.string); 617 618 /* The term "index" has two meanings for basic blocks in a CFG: 619 (a) the "index" field within struct basic_block_def. 620 (b) the index of a basic_block within the cfg's x_basic_block_info 621 vector, as accessed via BASIC_BLOCK_FOR_FN. 622 623 These can get out-of-sync when basic blocks are optimized away. 624 They get back in sync by "compact_blocks". 625 We reconstruct cfun->cfg->x_basic_block_info->m_vecdata with NULL 626 values in it for any missing basic blocks, so that (a) == (b) for 627 all of the blocks we create. The doubly-linked list of basic 628 blocks (next_bb/prev_bb) skips over these "holes". */ 629 630 if (m_highest_bb_idx < bb_idx) 631 m_highest_bb_idx = bb_idx; 632 633 size_t new_size = m_highest_bb_idx + 1; 634 if (basic_block_info_for_fn (cfun)->length () < new_size) 635 vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size, true); 636 637 last_basic_block_for_fn (cfun) = new_size; 638 639 /* Create the basic block. 640 641 We can't call create_basic_block and use the regular RTL block-creation 642 hooks, since this creates NOTE_INSN_BASIC_BLOCK instances. We don't 643 want to do that; we want to use the notes we were provided with. */ 644 basic_block bb = alloc_block (); 645 init_rtl_bb_info (bb); 646 bb->index = bb_idx; 647 bb->flags = BB_NEW | BB_RTL; 648 link_block (bb, m_bb_to_insert_after); 649 m_bb_to_insert_after = bb; 650 651 n_basic_blocks_for_fn (cfun)++; 652 SET_BASIC_BLOCK_FOR_FN (cfun, bb_idx, bb); 653 BB_SET_PARTITION (bb, BB_UNPARTITIONED); 654 655 /* Handle insns, edge-from and edge-to directives. */ 656 while (1) 657 { 658 int c = read_skip_spaces (); 659 file_location loc = get_current_location (); 660 if (c == ')') 661 break; 662 else if (c == '(') 663 { 664 struct md_name directive; 665 read_name (&directive); 666 if (strcmp (directive.string, "edge-from") == 0) 667 parse_edge (bb, true); 668 else if (strcmp (directive.string, "edge-to") == 0) 669 parse_edge (bb, false); 670 else 671 { 672 rtx_insn *insn = parse_insn (loc, directive.string); 673 set_block_for_insn (insn, bb); 674 if (!BB_HEAD (bb)) 675 BB_HEAD (bb) = insn; 676 BB_END (bb) = insn; 677 } 678 } 679 else 680 fatal_at (loc, "expected '(' or ')'"); 681 } 682} 683 684/* Subroutine of function_reader::parse_edge. 685 Parse a basic block index, handling "entry" and "exit". */ 686 687int 688function_reader::parse_bb_idx () 689{ 690 struct md_name name; 691 read_name (&name); 692 if (strcmp (name.string, "entry") == 0) 693 return ENTRY_BLOCK; 694 if (strcmp (name.string, "exit") == 0) 695 return EXIT_BLOCK; 696 return atoi (name.string); 697} 698 699/* Subroutine of parse_edge_flags. 700 Parse TOK, a token such as "FALLTHRU", converting to the flag value. 701 Issue an error if the token is unrecognized. */ 702 703static int 704parse_edge_flag_token (const char *tok) 705{ 706#define DEF_EDGE_FLAG(NAME,IDX) \ 707 do { \ 708 if (strcmp (tok, #NAME) == 0) \ 709 return EDGE_##NAME; \ 710 } while (0); 711#include "cfg-flags.def" 712#undef DEF_EDGE_FLAG 713 error ("unrecognized edge flag: %qs", tok); 714 return 0; 715} 716 717/* Subroutine of function_reader::parse_edge. 718 Parse STR and convert to a flag value (or issue an error). 719 The parser uses strtok and hence modifiers STR in-place. */ 720 721static int 722parse_edge_flags (char *str) 723{ 724 int result = 0; 725 726 char *tok = strtok (str, "| "); 727 while (tok) 728 { 729 result |= parse_edge_flag_token (tok); 730 tok = strtok (NULL, "| "); 731 } 732 733 return result; 734} 735 736/* Parse an "edge-from" or "edge-to" directive within the "block" 737 directive for BLOCK, having already parsed the "(edge" heading. 738 Consume the final ")". Record the edge within m_deferred_edges. 739 FROM is true for an "edge-from" directive, false for an "edge-to" 740 directive. */ 741 742void 743function_reader::parse_edge (basic_block block, bool from) 744{ 745 gcc_assert (block); 746 int this_bb_idx = block->index; 747 file_location loc = get_current_location (); 748 int other_bb_idx = parse_bb_idx (); 749 750 /* "(edge-from 2)" means src = 2, dest = this_bb_idx, whereas 751 "(edge-to 3)" means src = this_bb_idx, dest = 3. */ 752 int src_idx = from ? other_bb_idx : this_bb_idx; 753 int dest_idx = from ? this_bb_idx : other_bb_idx; 754 755 /* Optional "(flags)". */ 756 int flags = 0; 757 int c = read_skip_spaces (); 758 if (c == '(') 759 { 760 require_word_ws ("flags"); 761 require_char_ws ('"'); 762 char *str = read_quoted_string (); 763 flags = parse_edge_flags (str); 764 require_char_ws (')'); 765 } 766 else 767 unread_char (c); 768 769 require_char_ws (')'); 770 771 /* This BB already exists, but the other BB might not yet. 772 For now, save the edges, and create them at the end of insn-chain 773 processing. */ 774 /* For now, only process the (edge-from) to this BB, and (edge-to) 775 that go to the exit block. 776 FIXME: we don't yet verify that the edge-from and edge-to directives 777 are consistent. */ 778 if (from || dest_idx == EXIT_BLOCK) 779 m_deferred_edges.safe_push (deferred_edge (loc, src_idx, dest_idx, flags)); 780} 781 782/* Parse an rtx instruction, having parsed the opening and parenthesis, and 783 name NAME, seen at START_LOC, by calling read_rtx_code, calling 784 set_first_insn and set_last_insn as appropriate, and 785 adding the insn to the insn chain. 786 Consume the trailing ')'. */ 787 788rtx_insn * 789function_reader::parse_insn (file_location start_loc, const char *name) 790{ 791 rtx x = read_rtx_code (name); 792 if (!x) 793 fatal_at (start_loc, "expected insn type; got '%s'", name); 794 rtx_insn *insn = dyn_cast <rtx_insn *> (x); 795 if (!insn) 796 fatal_at (start_loc, "expected insn type; got '%s'", name); 797 798 /* Consume the trailing ')'. */ 799 require_char_ws (')'); 800 801 rtx_insn *last_insn = get_last_insn (); 802 803 /* Add "insn" to the insn chain. */ 804 if (last_insn) 805 { 806 gcc_assert (NEXT_INSN (last_insn) == NULL); 807 SET_NEXT_INSN (last_insn) = insn; 808 } 809 SET_PREV_INSN (insn) = last_insn; 810 811 /* Add it to the sequence. */ 812 set_last_insn (insn); 813 if (!m_first_insn) 814 { 815 m_first_insn = insn; 816 set_first_insn (insn); 817 } 818 819 if (rtx_code_label *label = dyn_cast <rtx_code_label *> (insn)) 820 maybe_set_max_label_num (label); 821 822 return insn; 823} 824 825/* Postprocessing subroutine for parse_insn_chain: all the basic blocks 826 should have been created by now; create the edges that were seen. */ 827 828void 829function_reader::create_edges () 830{ 831 int i; 832 deferred_edge *de; 833 FOR_EACH_VEC_ELT (m_deferred_edges, i, de) 834 { 835 /* The BBs should already have been created by parse_block. */ 836 basic_block src = BASIC_BLOCK_FOR_FN (cfun, de->m_src_bb_idx); 837 if (!src) 838 fatal_at (de->m_loc, "error: block index %i not found", 839 de->m_src_bb_idx); 840 basic_block dst = BASIC_BLOCK_FOR_FN (cfun, de->m_dest_bb_idx); 841 if (!dst) 842 fatal_at (de->m_loc, "error: block with index %i not found", 843 de->m_dest_bb_idx); 844 unchecked_make_edge (src, dst, de->m_flags); 845 } 846} 847 848/* Parse a "crtl" directive, having already parsed the "(crtl" heading 849 at location LOC. 850 Consume the final ")". */ 851 852void 853function_reader::parse_crtl (file_location loc) 854{ 855 if (m_have_crtl_directive) 856 error_at (loc, "more than one 'crtl' directive"); 857 m_have_crtl_directive = true; 858 859 /* return_rtx. */ 860 require_char_ws ('('); 861 require_word_ws ("return_rtx"); 862 crtl->return_rtx = parse_rtx (); 863 require_char_ws (')'); 864 865 require_char_ws (')'); 866} 867 868/* Parse operand IDX of X, returning X, or an equivalent rtx 869 expression (for consolidating singletons). 870 This is an overridden implementation of rtx_reader::read_rtx_operand for 871 function_reader, handling various extra data printed by print_rtx, 872 and sometimes calling the base class implementation. */ 873 874rtx 875function_reader::read_rtx_operand (rtx x, int idx) 876{ 877 RTX_CODE code = GET_CODE (x); 878 const char *format_ptr = GET_RTX_FORMAT (code); 879 const char format_char = format_ptr[idx]; 880 struct md_name name; 881 882 /* Override the regular parser for some format codes. */ 883 switch (format_char) 884 { 885 case 'e': 886 if (idx == 7 && CALL_P (x)) 887 { 888 m_in_call_function_usage = true; 889 rtx tem = rtx_reader::read_rtx_operand (x, idx); 890 m_in_call_function_usage = false; 891 return tem; 892 } 893 else 894 return rtx_reader::read_rtx_operand (x, idx); 895 break; 896 897 case 'u': 898 read_rtx_operand_u (x, idx); 899 /* Don't run regular parser for 'u'. */ 900 return x; 901 902 case 'i': 903 case 'n': 904 read_rtx_operand_i_or_n (x, idx, format_char); 905 /* Don't run regular parser for these codes. */ 906 return x; 907 908 case 'B': 909 gcc_assert (is_compact ()); 910 /* Compact mode doesn't store BBs. */ 911 /* Don't run regular parser. */ 912 return x; 913 914 case 'r': 915 /* Don't run regular parser for 'r'. */ 916 return read_rtx_operand_r (x); 917 918 default: 919 break; 920 } 921 922 /* Call base class implementation. */ 923 x = rtx_reader::read_rtx_operand (x, idx); 924 925 /* Handle any additional parsing needed to handle what the dump 926 could contain. */ 927 switch (format_char) 928 { 929 case '0': 930 x = extra_parsing_for_operand_code_0 (x, idx); 931 break; 932 933 case 'w': 934 if (!is_compact ()) 935 { 936 /* Strip away the redundant hex dump of the value. */ 937 require_char_ws ('['); 938 read_name (&name); 939 require_char_ws (']'); 940 } 941 break; 942 943 default: 944 break; 945 } 946 947 return x; 948} 949 950/* Parse operand IDX of X, of code 'u', when reading function dumps. 951 952 The RTL file recorded the ID of an insn (or 0 for NULL); we 953 must store this as a pointer, but the insn might not have 954 been loaded yet. Store the ID away for now, via a fixup. */ 955 956void 957function_reader::read_rtx_operand_u (rtx x, int idx) 958{ 959 /* In compact mode, the PREV/NEXT insn uids are not dumped, so skip 960 the "uu" when reading. */ 961 if (is_compact () && GET_CODE (x) != LABEL_REF) 962 return; 963 964 struct md_name name; 965 file_location loc = read_name (&name); 966 int insn_id = atoi (name.string); 967 if (insn_id) 968 add_fixup_insn_uid (loc, x, idx, insn_id); 969} 970 971/* Read a name, looking for a match against a string found in array 972 STRINGS of size NUM_VALUES. 973 Return the index of the matched string, or emit an error. */ 974 975int 976function_reader::parse_enum_value (int num_values, const char *const *strings) 977{ 978 struct md_name name; 979 read_name (&name); 980 for (int i = 0; i < num_values; i++) 981 { 982 if (strcmp (name.string, strings[i]) == 0) 983 return i; 984 } 985 error ("unrecognized enum value: %qs", name.string); 986 return 0; 987} 988 989/* Parse operand IDX of X, of code 'i' or 'n' (as specified by FORMAT_CHAR). 990 Special-cased handling of these, for reading function dumps. */ 991 992void 993function_reader::read_rtx_operand_i_or_n (rtx x, int idx, 994 char format_char) 995{ 996 /* Handle some of the extra information that print_rtx 997 can write out for these cases. */ 998 /* print_rtx only writes out operand 5 for notes 999 for NOTE_KIND values NOTE_INSN_DELETED_LABEL 1000 and NOTE_INSN_DELETED_DEBUG_LABEL. */ 1001 if (idx == 5 && NOTE_P (x)) 1002 return; 1003 1004 if (idx == 4 && INSN_P (x)) 1005 { 1006 maybe_read_location (as_a <rtx_insn *> (x)); 1007 return; 1008 } 1009 1010 /* INSN_CODEs aren't printed in compact mode, so don't attempt to 1011 parse them. */ 1012 if (is_compact () 1013 && INSN_P (x) 1014 && &INSN_CODE (x) == &XINT (x, idx)) 1015 { 1016 INSN_CODE (x) = -1; 1017 return; 1018 } 1019 1020 /* Handle UNSPEC and UNSPEC_VOLATILE's operand 1. */ 1021#if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0 1022 if (idx == 1 1023 && GET_CODE (x) == UNSPEC_VOLATILE) 1024 { 1025 XINT (x, 1) 1026 = parse_enum_value (NUM_UNSPECV_VALUES, unspecv_strings); 1027 return; 1028 } 1029#endif 1030#if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0 1031 if (idx == 1 1032 && (GET_CODE (x) == UNSPEC 1033 || GET_CODE (x) == UNSPEC_VOLATILE)) 1034 { 1035 XINT (x, 1) 1036 = parse_enum_value (NUM_UNSPEC_VALUES, unspec_strings); 1037 return; 1038 } 1039#endif 1040 1041 struct md_name name; 1042 read_name (&name); 1043 int value; 1044 if (format_char == 'n') 1045 value = parse_note_insn_name (name.string); 1046 else 1047 value = atoi (name.string); 1048 XINT (x, idx) = value; 1049} 1050 1051/* Parse the 'r' operand of X, returning X, or an equivalent rtx 1052 expression (for consolidating singletons). 1053 Special-cased handling of code 'r' for reading function dumps. */ 1054 1055rtx 1056function_reader::read_rtx_operand_r (rtx x) 1057{ 1058 struct md_name name; 1059 file_location loc = read_name (&name); 1060 int regno = lookup_reg_by_dump_name (name.string); 1061 if (regno == -1) 1062 fatal_at (loc, "unrecognized register: '%s'", name.string); 1063 1064 set_regno_raw (x, regno, 1); 1065 1066 /* Consolidate singletons. */ 1067 x = consolidate_singletons (x); 1068 1069 ORIGINAL_REGNO (x) = regno; 1070 1071 /* Parse extra stuff at end of 'r'. 1072 We may have zero, one, or two sections marked by square 1073 brackets. */ 1074 int ch = read_skip_spaces (); 1075 bool expect_original_regno = false; 1076 if (ch == '[') 1077 { 1078 file_location loc = get_current_location (); 1079 char *desc = read_until ("]", true); 1080 strip_trailing_whitespace (desc); 1081 const char *desc_start = desc; 1082 /* If ORIGINAL_REGNO (rtx) != regno, we will have: 1083 "orig:%i", ORIGINAL_REGNO (rtx). 1084 Consume it, we don't set ORIGINAL_REGNO, since we can 1085 get that from the 2nd copy later. */ 1086 if (startswith (desc, "orig:")) 1087 { 1088 expect_original_regno = true; 1089 desc_start += 5; 1090 /* Skip to any whitespace following the integer. */ 1091 const char *space = strchr (desc_start, ' '); 1092 if (space) 1093 desc_start = space + 1; 1094 } 1095 /* Any remaining text may be the REG_EXPR. Alternatively we have 1096 no REG_ATTRS, and instead we have ORIGINAL_REGNO. */ 1097 if (ISDIGIT (*desc_start)) 1098 { 1099 /* Assume we have ORIGINAL_REGNO. */ 1100 ORIGINAL_REGNO (x) = atoi (desc_start); 1101 } 1102 else 1103 { 1104 /* Assume we have REG_EXPR. */ 1105 add_fixup_expr (loc, x, desc_start); 1106 } 1107 free (desc); 1108 } 1109 else 1110 unread_char (ch); 1111 if (expect_original_regno) 1112 { 1113 require_char_ws ('['); 1114 char *desc = read_until ("]", true); 1115 ORIGINAL_REGNO (x) = atoi (desc); 1116 free (desc); 1117 } 1118 1119 return x; 1120} 1121 1122/* Additional parsing for format code '0' in dumps, handling a variety 1123 of special-cases in print_rtx, when parsing operand IDX of X. 1124 Return X, or possibly a reallocated copy of X. */ 1125 1126rtx 1127function_reader::extra_parsing_for_operand_code_0 (rtx x, int idx) 1128{ 1129 RTX_CODE code = GET_CODE (x); 1130 int c; 1131 struct md_name name; 1132 1133 if (idx == 1 && code == SYMBOL_REF) 1134 { 1135 /* Possibly wrote " [flags %#x]", SYMBOL_REF_FLAGS (in_rtx). */ 1136 c = read_skip_spaces (); 1137 if (c == '[') 1138 { 1139 file_location loc = read_name (&name); 1140 if (strcmp (name.string, "flags")) 1141 error_at (loc, "was expecting `%s'", "flags"); 1142 read_name (&name); 1143 SYMBOL_REF_FLAGS (x) = strtol (name.string, NULL, 16); 1144 1145 /* The standard RTX_CODE_SIZE (SYMBOL_REF) used when allocating 1146 x doesn't have space for the block_symbol information, so 1147 we must reallocate it if this flag is set. */ 1148 if (SYMBOL_REF_HAS_BLOCK_INFO_P (x)) 1149 { 1150 /* Emulate the allocation normally done by 1151 varasm.cc:create_block_symbol. */ 1152 unsigned int size = RTX_HDR_SIZE + sizeof (struct block_symbol); 1153 rtx new_x = (rtx) ggc_internal_alloc (size); 1154 1155 /* Copy data over from the smaller SYMBOL_REF. */ 1156 memcpy (new_x, x, RTX_CODE_SIZE (SYMBOL_REF)); 1157 x = new_x; 1158 1159 /* We can't reconstruct SYMBOL_REF_BLOCK; set it to NULL. */ 1160 SYMBOL_REF_BLOCK (x) = NULL; 1161 1162 /* Zero the offset. */ 1163 SYMBOL_REF_BLOCK_OFFSET (x) = 0; 1164 } 1165 1166 require_char (']'); 1167 } 1168 else 1169 unread_char (c); 1170 1171 /* If X had a non-NULL SYMBOL_REF_DECL, 1172 rtx_writer::print_rtx_operand_code_0 would have dumped it 1173 using print_node_brief. 1174 Skip the content for now. */ 1175 c = read_skip_spaces (); 1176 if (c == '<') 1177 { 1178 while (1) 1179 { 1180 char ch = read_char (); 1181 if (ch == '>') 1182 break; 1183 } 1184 } 1185 else 1186 unread_char (c); 1187 } 1188 else if (idx == 3 && code == NOTE) 1189 { 1190 /* Note-specific data appears for operand 3, which annoyingly 1191 is before the enum specifying which kind of note we have 1192 (operand 4). */ 1193 c = read_skip_spaces (); 1194 if (c == '[') 1195 { 1196 /* Possibly data for a NOTE_INSN_BASIC_BLOCK, of the form: 1197 [bb %d]. */ 1198 file_location bb_loc = read_name (&name); 1199 if (strcmp (name.string, "bb")) 1200 error_at (bb_loc, "was expecting `%s'", "bb"); 1201 read_name (&name); 1202 int bb_idx = atoi (name.string); 1203 add_fixup_note_insn_basic_block (bb_loc, x, idx, 1204 bb_idx); 1205 require_char_ws (']'); 1206 } 1207 else 1208 unread_char (c); 1209 } 1210 1211 return x; 1212} 1213 1214/* Implementation of rtx_reader::handle_any_trailing_information. 1215 Handle the various additional information that print-rtl.cc can 1216 write after the regular fields, when parsing X. */ 1217 1218void 1219function_reader::handle_any_trailing_information (rtx x) 1220{ 1221 struct md_name name; 1222 1223 switch (GET_CODE (x)) 1224 { 1225 case MEM: 1226 { 1227 int ch; 1228 require_char_ws ('['); 1229 read_name (&name); 1230 set_mem_alias_set (x, atoi (name.string)); 1231 /* We have either a MEM_EXPR, or a space. */ 1232 if (peek_char () != ' ') 1233 { 1234 file_location loc = get_current_location (); 1235 char *desc = read_until (" +", false); 1236 add_fixup_expr (loc, consolidate_singletons (x), desc); 1237 free (desc); 1238 } 1239 else 1240 read_char (); 1241 1242 /* We may optionally have '+' for MEM_OFFSET_KNOWN_P. */ 1243 ch = read_skip_spaces (); 1244 if (ch == '+') 1245 { 1246 read_name (&name); 1247 set_mem_offset (x, atoi (name.string)); 1248 } 1249 else 1250 unread_char (ch); 1251 1252 /* Handle optional " S" for MEM_SIZE. */ 1253 ch = read_skip_spaces (); 1254 if (ch == 'S') 1255 { 1256 read_name (&name); 1257 set_mem_size (x, atoi (name.string)); 1258 } 1259 else 1260 unread_char (ch); 1261 1262 /* Handle optional " A" for MEM_ALIGN. */ 1263 ch = read_skip_spaces (); 1264 if (ch == 'A' && peek_char () != 'S') 1265 { 1266 read_name (&name); 1267 set_mem_align (x, atoi (name.string)); 1268 } 1269 else 1270 unread_char (ch); 1271 1272 /* Handle optional " AS" for MEM_ADDR_SPACE. */ 1273 ch = read_skip_spaces (); 1274 if (ch == 'A' && peek_char () == 'S') 1275 { 1276 read_char (); 1277 read_name (&name); 1278 set_mem_addr_space (x, atoi (name.string)); 1279 } 1280 else 1281 unread_char (ch); 1282 1283 require_char (']'); 1284 } 1285 break; 1286 1287 case CODE_LABEL: 1288 /* Assume that LABEL_NUSES was not dumped. */ 1289 /* TODO: parse LABEL_KIND. */ 1290 /* For now, skip until closing ')'. */ 1291 do 1292 { 1293 char ch = read_char (); 1294 if (ch == ')') 1295 { 1296 unread_char (ch); 1297 break; 1298 } 1299 } 1300 while (1); 1301 break; 1302 1303 default: 1304 break; 1305 } 1306} 1307 1308/* Parse a tree dump for a MEM_EXPR in DESC and turn it back into a tree. 1309 We handle "<retval>" and param names within cfun, but for anything else 1310 we "cheat" by building a global VAR_DECL of type "int" with that name 1311 (returning the same global for a name if we see the same name more 1312 than once). */ 1313 1314tree 1315function_reader::parse_mem_expr (const char *desc) 1316{ 1317 tree fndecl = cfun->decl; 1318 1319 if (strcmp (desc, "<retval>") == 0) 1320 return DECL_RESULT (fndecl); 1321 1322 tree param = find_param_by_name (fndecl, desc); 1323 if (param) 1324 return param; 1325 1326 /* Search within decls we already created. 1327 FIXME: use a hash rather than linear search. */ 1328 int i; 1329 tree t; 1330 FOR_EACH_VEC_ELT (m_fake_scope, i, t) 1331 if (id_equal (DECL_NAME (t), desc)) 1332 return t; 1333 1334 /* Not found? Create it. 1335 This allows mimicking of real data but avoids having to specify 1336 e.g. names of locals, params etc. 1337 Though this way we don't know if we have a PARM_DECL vs a VAR_DECL, 1338 and we don't know the types. Fake it by making everything be 1339 a VAR_DECL of "int" type. */ 1340 t = build_decl (UNKNOWN_LOCATION, VAR_DECL, 1341 get_identifier (desc), 1342 integer_type_node); 1343 m_fake_scope.safe_push (t); 1344 return t; 1345} 1346 1347/* Record that at LOC we saw an insn uid INSN_UID for the operand with index 1348 OPERAND_IDX within INSN, so that the pointer value can be fixed up in 1349 later post-processing. */ 1350 1351void 1352function_reader::add_fixup_insn_uid (file_location loc, rtx insn, int operand_idx, 1353 int insn_uid) 1354{ 1355 m_fixups.safe_push (new fixup_insn_uid (loc, insn, operand_idx, insn_uid)); 1356} 1357 1358/* Record that at LOC we saw an basic block index BB_IDX for the operand with index 1359 OPERAND_IDX within INSN, so that the pointer value can be fixed up in 1360 later post-processing. */ 1361 1362void 1363function_reader::add_fixup_note_insn_basic_block (file_location loc, rtx insn, 1364 int operand_idx, int bb_idx) 1365{ 1366 m_fixups.safe_push (new fixup_note_insn_basic_block (loc, insn, operand_idx, 1367 bb_idx)); 1368} 1369 1370/* Placeholder hook for recording source location information seen in a dump. 1371 This is empty for now. */ 1372 1373void 1374function_reader::add_fixup_source_location (file_location, rtx_insn *, 1375 const char *, int, int) 1376{ 1377} 1378 1379/* Record that at LOC we saw textual description DESC of the MEM_EXPR or REG_EXPR 1380 of INSN, so that the fields can be fixed up in later post-processing. */ 1381 1382void 1383function_reader::add_fixup_expr (file_location loc, rtx insn, 1384 const char *desc) 1385{ 1386 gcc_assert (desc); 1387 /* Fail early if the RTL reader erroneously hands us an int. */ 1388 gcc_assert (!ISDIGIT (desc[0])); 1389 1390 m_fixups.safe_push (new fixup_expr (loc, insn, desc)); 1391} 1392 1393/* Helper function for consolidate_reg. Return the global rtx for 1394 the register with regno REGNO. */ 1395 1396static rtx 1397lookup_global_register (int regno) 1398{ 1399 /* We can't use a switch here, as some of the REGNUMs might not be constants 1400 for some targets. */ 1401 if (regno == STACK_POINTER_REGNUM) 1402 return stack_pointer_rtx; 1403 else if (regno == FRAME_POINTER_REGNUM) 1404 return frame_pointer_rtx; 1405 else if (regno == HARD_FRAME_POINTER_REGNUM) 1406 return hard_frame_pointer_rtx; 1407 else if (regno == ARG_POINTER_REGNUM) 1408 return arg_pointer_rtx; 1409 else if (regno == VIRTUAL_INCOMING_ARGS_REGNUM) 1410 return virtual_incoming_args_rtx; 1411 else if (regno == VIRTUAL_STACK_VARS_REGNUM) 1412 return virtual_stack_vars_rtx; 1413 else if (regno == VIRTUAL_STACK_DYNAMIC_REGNUM) 1414 return virtual_stack_dynamic_rtx; 1415 else if (regno == VIRTUAL_OUTGOING_ARGS_REGNUM) 1416 return virtual_outgoing_args_rtx; 1417 else if (regno == VIRTUAL_CFA_REGNUM) 1418 return virtual_cfa_rtx; 1419 else if (regno == VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM) 1420 return virtual_preferred_stack_boundary_rtx; 1421#ifdef return_ADDRESS_POINTER_REGNUM 1422 else if (regno == RETURN_ADDRESS_POINTER_REGNUM) 1423 return return_address_pointer_rtx; 1424#endif 1425 1426 return NULL; 1427} 1428 1429/* Ensure that the backend can cope with a REG with regno REGNO. 1430 Normally REG instances are created by gen_reg_rtx which updates 1431 regno_reg_rtx, growing it as necessary. 1432 The REG instances created from the dumpfile weren't created this 1433 way, so we need to manually update regno_reg_rtx. */ 1434 1435static void 1436ensure_regno (int regno) 1437{ 1438 if (reg_rtx_no < regno + 1) 1439 reg_rtx_no = regno + 1; 1440 1441 crtl->emit.ensure_regno_capacity (); 1442 gcc_assert (regno < crtl->emit.regno_pointer_align_length); 1443} 1444 1445/* Helper function for consolidate_singletons, for handling REG instances. 1446 Given REG instance X of some regno, return the singleton rtx for that 1447 regno, if it exists, or X. */ 1448 1449static rtx 1450consolidate_reg (rtx x) 1451{ 1452 gcc_assert (GET_CODE (x) == REG); 1453 1454 unsigned int regno = REGNO (x); 1455 1456 ensure_regno (regno); 1457 1458 /* Some register numbers have their rtx created in init_emit_regs 1459 e.g. stack_pointer_rtx for STACK_POINTER_REGNUM. 1460 Consolidate on this. */ 1461 rtx global_reg = lookup_global_register (regno); 1462 if (global_reg) 1463 return global_reg; 1464 1465 /* Populate regno_reg_rtx if necessary. */ 1466 if (regno_reg_rtx[regno] == NULL) 1467 regno_reg_rtx[regno] = x; 1468 /* Use it. */ 1469 gcc_assert (GET_CODE (regno_reg_rtx[regno]) == REG); 1470 gcc_assert (REGNO (regno_reg_rtx[regno]) == regno); 1471 if (GET_MODE (x) == GET_MODE (regno_reg_rtx[regno])) 1472 return regno_reg_rtx[regno]; 1473 1474 return x; 1475} 1476 1477/* When reading RTL function dumps, we must consolidate some 1478 rtx so that we use singletons where singletons are expected 1479 (e.g. we don't want multiple "(const_int 0 [0])" rtx, since 1480 these are tested via pointer equality against const0_rtx. 1481 1482 Return the equivalent singleton rtx for X, if any, otherwise X. */ 1483 1484rtx 1485function_reader::consolidate_singletons (rtx x) 1486{ 1487 if (!x) 1488 return x; 1489 1490 switch (GET_CODE (x)) 1491 { 1492 case PC: return pc_rtx; 1493 case RETURN: return ret_rtx; 1494 case SIMPLE_RETURN: return simple_return_rtx; 1495 1496 case REG: 1497 return consolidate_reg (x); 1498 1499 case CONST_INT: 1500 return gen_rtx_CONST_INT (GET_MODE (x), INTVAL (x)); 1501 1502 case CONST_VECTOR: 1503 return gen_rtx_CONST_VECTOR (GET_MODE (x), XVEC (x, 0)); 1504 1505 default: 1506 break; 1507 } 1508 1509 return x; 1510} 1511 1512/* Parse an rtx directive, including both the opening/closing parentheses, 1513 and the name. */ 1514 1515rtx 1516function_reader::parse_rtx () 1517{ 1518 require_char_ws ('('); 1519 struct md_name directive; 1520 read_name (&directive); 1521 rtx result 1522 = consolidate_singletons (read_rtx_code (directive.string)); 1523 require_char_ws (')'); 1524 1525 return result; 1526} 1527 1528/* Implementation of rtx_reader::postprocess for reading function dumps. 1529 Return the equivalent singleton rtx for X, if any, otherwise X. */ 1530 1531rtx 1532function_reader::postprocess (rtx x) 1533{ 1534 return consolidate_singletons (x); 1535} 1536 1537/* Implementation of rtx_reader::finalize_string for reading function dumps. 1538 Make a GC-managed copy of STRINGBUF. */ 1539 1540const char * 1541function_reader::finalize_string (char *stringbuf) 1542{ 1543 return ggc_strdup (stringbuf); 1544} 1545 1546/* Attempt to parse optional location information for insn INSN, as 1547 potentially written out by rtx_writer::print_rtx_operand_code_i. 1548 We look for a quoted string followed by a colon. */ 1549 1550void 1551function_reader::maybe_read_location (rtx_insn *insn) 1552{ 1553 file_location loc = get_current_location (); 1554 1555 /* Attempt to parse a quoted string. */ 1556 int ch = read_skip_spaces (); 1557 if (ch == '"') 1558 { 1559 char *filename = read_quoted_string (); 1560 require_char (':'); 1561 struct md_name line_num; 1562 read_name (&line_num); 1563 1564 int column = 0; 1565 int ch = read_char (); 1566 if (ch == ':') 1567 { 1568 struct md_name column_num; 1569 read_name (&column_num); 1570 column = atoi (column_num.string); 1571 } 1572 else 1573 unread_char (ch); 1574 add_fixup_source_location (loc, insn, filename, 1575 atoi (line_num.string), 1576 column); 1577 } 1578 else 1579 unread_char (ch); 1580} 1581 1582/* Postprocessing subroutine of function_reader::parse_function. 1583 Populate m_insns_by_uid. */ 1584 1585void 1586function_reader::handle_insn_uids () 1587{ 1588 /* Locate the currently assigned INSN_UID values, storing 1589 them in m_insns_by_uid. */ 1590 int max_uid = 0; 1591 for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn)) 1592 { 1593 if (m_insns_by_uid.get (INSN_UID (insn))) 1594 error ("duplicate insn UID: %i", INSN_UID (insn)); 1595 m_insns_by_uid.put (INSN_UID (insn), insn); 1596 if (INSN_UID (insn) > max_uid) 1597 max_uid = INSN_UID (insn); 1598 } 1599 1600 /* Ensure x_cur_insn_uid is 1 more than the biggest insn UID seen. 1601 This is normally updated by the various make_*insn_raw functions. */ 1602 crtl->emit.x_cur_insn_uid = max_uid + 1; 1603} 1604 1605/* Apply all of the recorded fixups. */ 1606 1607void 1608function_reader::apply_fixups () 1609{ 1610 int i; 1611 fixup *f; 1612 FOR_EACH_VEC_ELT (m_fixups, i, f) 1613 f->apply (this); 1614} 1615 1616/* Given a UID value, try to locate a pointer to the corresponding 1617 rtx_insn *, or NULL if it can't be found. */ 1618 1619rtx_insn ** 1620function_reader::get_insn_by_uid (int uid) 1621{ 1622 return m_insns_by_uid.get (uid); 1623} 1624 1625/* Run the RTL dump parser, parsing a dump located at PATH. 1626 Return true iff the file was successfully parsed. */ 1627 1628bool 1629read_rtl_function_body (const char *path) 1630{ 1631 initialize_rtl (); 1632 crtl->abi = &default_function_abi; 1633 init_emit (); 1634 init_varasm_status (); 1635 1636 function_reader reader; 1637 if (!reader.read_file (path)) 1638 return false; 1639 1640 return true; 1641} 1642 1643/* Run the RTL dump parser on the range of lines between START_LOC and 1644 END_LOC (including those lines). */ 1645 1646bool 1647read_rtl_function_body_from_file_range (location_t start_loc, 1648 location_t end_loc) 1649{ 1650 expanded_location exploc_start = expand_location (start_loc); 1651 expanded_location exploc_end = expand_location (end_loc); 1652 1653 if (exploc_start.file != exploc_end.file) 1654 { 1655 error_at (end_loc, "start/end of RTL fragment are in different files"); 1656 return false; 1657 } 1658 if (exploc_start.line >= exploc_end.line) 1659 { 1660 error_at (end_loc, 1661 "start of RTL fragment must be on an earlier line than end"); 1662 return false; 1663 } 1664 1665 initialize_rtl (); 1666 crtl->abi = &fndecl_abi (cfun->decl).base_abi (); 1667 init_emit (); 1668 init_varasm_status (); 1669 1670 function_reader reader; 1671 if (!reader.read_file_fragment (exploc_start.file, exploc_start.line, 1672 exploc_end.line - 1)) 1673 return false; 1674 1675 return true; 1676} 1677 1678#if CHECKING_P 1679 1680namespace selftest { 1681 1682/* Verify that parse_edge_flags works. */ 1683 1684static void 1685test_edge_flags () 1686{ 1687 /* parse_edge_flags modifies its input (due to strtok), so we must make 1688 a copy of the literals. */ 1689#define ASSERT_PARSE_EDGE_FLAGS(EXPECTED, STR) \ 1690 do { \ 1691 char *str = xstrdup (STR); \ 1692 ASSERT_EQ (EXPECTED, parse_edge_flags (str)); \ 1693 free (str); \ 1694 } while (0) 1695 1696 ASSERT_PARSE_EDGE_FLAGS (0, ""); 1697 ASSERT_PARSE_EDGE_FLAGS (EDGE_FALLTHRU, "FALLTHRU"); 1698 ASSERT_PARSE_EDGE_FLAGS (EDGE_ABNORMAL_CALL, "ABNORMAL_CALL"); 1699 ASSERT_PARSE_EDGE_FLAGS (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL, 1700 "ABNORMAL | ABNORMAL_CALL"); 1701 1702#undef ASSERT_PARSE_EDGE_FLAGS 1703} 1704 1705/* Verify that lookup_reg_by_dump_name works. */ 1706 1707static void 1708test_parsing_regnos () 1709{ 1710 ASSERT_EQ (-1, lookup_reg_by_dump_name ("this is not a register")); 1711 1712 /* Verify lookup of virtual registers. */ 1713 ASSERT_EQ (VIRTUAL_INCOMING_ARGS_REGNUM, 1714 lookup_reg_by_dump_name ("virtual-incoming-args")); 1715 ASSERT_EQ (VIRTUAL_STACK_VARS_REGNUM, 1716 lookup_reg_by_dump_name ("virtual-stack-vars")); 1717 ASSERT_EQ (VIRTUAL_STACK_DYNAMIC_REGNUM, 1718 lookup_reg_by_dump_name ("virtual-stack-dynamic")); 1719 ASSERT_EQ (VIRTUAL_OUTGOING_ARGS_REGNUM, 1720 lookup_reg_by_dump_name ("virtual-outgoing-args")); 1721 ASSERT_EQ (VIRTUAL_CFA_REGNUM, 1722 lookup_reg_by_dump_name ("virtual-cfa")); 1723 ASSERT_EQ (VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM, 1724 lookup_reg_by_dump_name ("virtual-preferred-stack-boundary")); 1725 1726 /* Verify lookup of non-virtual pseudos. */ 1727 ASSERT_EQ (LAST_VIRTUAL_REGISTER + 1, lookup_reg_by_dump_name ("<0>")); 1728 ASSERT_EQ (LAST_VIRTUAL_REGISTER + 2, lookup_reg_by_dump_name ("<1>")); 1729} 1730 1731/* Verify that edge E is as expected, with the src and dest basic blocks 1732 having indices EXPECTED_SRC_IDX and EXPECTED_DEST_IDX respectively, and 1733 the edge having flags equal to EXPECTED_FLAGS. 1734 Use LOC as the effective location when reporting failures. */ 1735 1736static void 1737assert_edge_at (const location &loc, edge e, int expected_src_idx, 1738 int expected_dest_idx, int expected_flags) 1739{ 1740 ASSERT_EQ_AT (loc, expected_src_idx, e->src->index); 1741 ASSERT_EQ_AT (loc, expected_dest_idx, e->dest->index); 1742 ASSERT_EQ_AT (loc, expected_flags, e->flags); 1743} 1744 1745/* Verify that edge EDGE is as expected, with the src and dest basic blocks 1746 having indices EXPECTED_SRC_IDX and EXPECTED_DEST_IDX respectively, and 1747 the edge having flags equal to EXPECTED_FLAGS. */ 1748 1749#define ASSERT_EDGE(EDGE, EXPECTED_SRC_IDX, EXPECTED_DEST_IDX, \ 1750 EXPECTED_FLAGS) \ 1751 assert_edge_at (SELFTEST_LOCATION, EDGE, EXPECTED_SRC_IDX, \ 1752 EXPECTED_DEST_IDX, EXPECTED_FLAGS) 1753 1754/* Verify that we can load RTL dumps. */ 1755 1756static void 1757test_loading_dump_fragment_1 () 1758{ 1759 // TODO: filter on target? 1760 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("asr_div1.rtl")); 1761 1762 /* Verify that the insns were loaded correctly. */ 1763 rtx_insn *insn_1 = get_insns (); 1764 ASSERT_TRUE (insn_1); 1765 ASSERT_EQ (1, INSN_UID (insn_1)); 1766 ASSERT_EQ (INSN, GET_CODE (insn_1)); 1767 ASSERT_EQ (SET, GET_CODE (PATTERN (insn_1))); 1768 ASSERT_EQ (NULL, PREV_INSN (insn_1)); 1769 1770 rtx_insn *insn_2 = NEXT_INSN (insn_1); 1771 ASSERT_TRUE (insn_2); 1772 ASSERT_EQ (2, INSN_UID (insn_2)); 1773 ASSERT_EQ (INSN, GET_CODE (insn_2)); 1774 ASSERT_EQ (insn_1, PREV_INSN (insn_2)); 1775 ASSERT_EQ (NULL, NEXT_INSN (insn_2)); 1776 1777 /* Verify that registers were loaded correctly. */ 1778 rtx insn_1_dest = SET_DEST (PATTERN (insn_1)); 1779 ASSERT_EQ (REG, GET_CODE (insn_1_dest)); 1780 ASSERT_EQ ((LAST_VIRTUAL_REGISTER + 1) + 2, REGNO (insn_1_dest)); 1781 rtx insn_1_src = SET_SRC (PATTERN (insn_1)); 1782 ASSERT_EQ (LSHIFTRT, GET_CODE (insn_1_src)); 1783 rtx reg = XEXP (insn_1_src, 0); 1784 ASSERT_EQ (REG, GET_CODE (reg)); 1785 ASSERT_EQ (LAST_VIRTUAL_REGISTER + 1, REGNO (reg)); 1786 1787 /* Verify that get_insn_by_uid works. */ 1788 ASSERT_EQ (insn_1, get_insn_by_uid (1)); 1789 ASSERT_EQ (insn_2, get_insn_by_uid (2)); 1790 1791 /* Verify that basic blocks were created. */ 1792 ASSERT_EQ (2, BLOCK_FOR_INSN (insn_1)->index); 1793 ASSERT_EQ (2, BLOCK_FOR_INSN (insn_2)->index); 1794 1795 /* Verify that the CFG was recreated. */ 1796 ASSERT_TRUE (cfun); 1797 verify_three_block_rtl_cfg (cfun); 1798 basic_block bb2 = BASIC_BLOCK_FOR_FN (cfun, 2); 1799 ASSERT_TRUE (bb2 != NULL); 1800 ASSERT_EQ (BB_RTL, bb2->flags & BB_RTL); 1801 ASSERT_EQ (2, bb2->index); 1802 ASSERT_EQ (insn_1, BB_HEAD (bb2)); 1803 ASSERT_EQ (insn_2, BB_END (bb2)); 1804} 1805 1806/* Verify loading another RTL dump. */ 1807 1808static void 1809test_loading_dump_fragment_2 () 1810{ 1811 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("simple-cse.rtl")); 1812 1813 rtx_insn *insn_1 = get_insn_by_uid (1); 1814 rtx_insn *insn_2 = get_insn_by_uid (2); 1815 rtx_insn *insn_3 = get_insn_by_uid (3); 1816 1817 rtx set1 = single_set (insn_1); 1818 ASSERT_NE (NULL, set1); 1819 rtx set2 = single_set (insn_2); 1820 ASSERT_NE (NULL, set2); 1821 rtx set3 = single_set (insn_3); 1822 ASSERT_NE (NULL, set3); 1823 1824 rtx src1 = SET_SRC (set1); 1825 ASSERT_EQ (PLUS, GET_CODE (src1)); 1826 1827 rtx src2 = SET_SRC (set2); 1828 ASSERT_EQ (PLUS, GET_CODE (src2)); 1829 1830 /* Both src1 and src2 refer to "(reg:SI %0)". 1831 Verify that we have pointer equality. */ 1832 rtx lhs1 = XEXP (src1, 0); 1833 rtx lhs2 = XEXP (src2, 0); 1834 ASSERT_EQ (lhs1, lhs2); 1835 1836 /* Verify that the CFG was recreated. */ 1837 ASSERT_TRUE (cfun); 1838 verify_three_block_rtl_cfg (cfun); 1839} 1840 1841/* Verify that CODE_LABEL insns are loaded correctly. */ 1842 1843static void 1844test_loading_labels () 1845{ 1846 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("example-labels.rtl")); 1847 1848 rtx_insn *insn_100 = get_insn_by_uid (100); 1849 ASSERT_EQ (CODE_LABEL, GET_CODE (insn_100)); 1850 ASSERT_EQ (100, INSN_UID (insn_100)); 1851 ASSERT_EQ (NULL, LABEL_NAME (insn_100)); 1852 ASSERT_EQ (0, LABEL_NUSES (insn_100)); 1853 ASSERT_EQ (30, CODE_LABEL_NUMBER (insn_100)); 1854 1855 rtx_insn *insn_200 = get_insn_by_uid (200); 1856 ASSERT_EQ (CODE_LABEL, GET_CODE (insn_200)); 1857 ASSERT_EQ (200, INSN_UID (insn_200)); 1858 ASSERT_STREQ ("some_label_name", LABEL_NAME (insn_200)); 1859 ASSERT_EQ (0, LABEL_NUSES (insn_200)); 1860 ASSERT_EQ (40, CODE_LABEL_NUMBER (insn_200)); 1861 1862 /* Ensure that the presence of CODE_LABEL_NUMBER == 40 1863 means that the next label num to be handed out will be 41. */ 1864 ASSERT_EQ (41, max_label_num ()); 1865 1866 /* Ensure that label names read from a dump are GC-managed 1867 and are found through the insn. */ 1868 ggc_collect (GGC_COLLECT_FORCE); 1869 ASSERT_TRUE (ggc_marked_p (insn_200)); 1870 ASSERT_TRUE (ggc_marked_p (LABEL_NAME (insn_200))); 1871} 1872 1873/* Verify that the loader copes with an insn with a mode. */ 1874 1875static void 1876test_loading_insn_with_mode () 1877{ 1878 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("insn-with-mode.rtl")); 1879 rtx_insn *insn = get_insns (); 1880 ASSERT_EQ (INSN, GET_CODE (insn)); 1881 1882 /* Verify that the "TI" mode was set from "insn:TI". */ 1883 ASSERT_EQ (TImode, GET_MODE (insn)); 1884} 1885 1886/* Verify that the loader copes with a jump_insn to a label_ref. */ 1887 1888static void 1889test_loading_jump_to_label_ref () 1890{ 1891 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("jump-to-label-ref.rtl")); 1892 1893 rtx_insn *jump_insn = get_insn_by_uid (1); 1894 ASSERT_EQ (JUMP_INSN, GET_CODE (jump_insn)); 1895 1896 rtx_insn *barrier = get_insn_by_uid (2); 1897 ASSERT_EQ (BARRIER, GET_CODE (barrier)); 1898 1899 rtx_insn *code_label = get_insn_by_uid (100); 1900 ASSERT_EQ (CODE_LABEL, GET_CODE (code_label)); 1901 1902 /* Verify the jump_insn. */ 1903 ASSERT_EQ (4, BLOCK_FOR_INSN (jump_insn)->index); 1904 ASSERT_EQ (SET, GET_CODE (PATTERN (jump_insn))); 1905 /* Ensure that the "(pc)" is using the global singleton. */ 1906 ASSERT_RTX_PTR_EQ (pc_rtx, SET_DEST (PATTERN (jump_insn))); 1907 rtx label_ref = SET_SRC (PATTERN (jump_insn)); 1908 ASSERT_EQ (LABEL_REF, GET_CODE (label_ref)); 1909 ASSERT_EQ (code_label, label_ref_label (label_ref)); 1910 ASSERT_EQ (code_label, JUMP_LABEL (jump_insn)); 1911 1912 /* Verify the code_label. */ 1913 ASSERT_EQ (5, BLOCK_FOR_INSN (code_label)->index); 1914 ASSERT_EQ (NULL, LABEL_NAME (code_label)); 1915 ASSERT_EQ (1, LABEL_NUSES (code_label)); 1916 1917 /* Verify the generated CFG. */ 1918 1919 /* Locate blocks. */ 1920 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (cfun); 1921 ASSERT_TRUE (entry != NULL); 1922 ASSERT_EQ (ENTRY_BLOCK, entry->index); 1923 1924 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (cfun); 1925 ASSERT_TRUE (exit != NULL); 1926 ASSERT_EQ (EXIT_BLOCK, exit->index); 1927 1928 basic_block bb4 = (*cfun->cfg->x_basic_block_info)[4]; 1929 basic_block bb5 = (*cfun->cfg->x_basic_block_info)[5]; 1930 ASSERT_EQ (4, bb4->index); 1931 ASSERT_EQ (5, bb5->index); 1932 1933 /* Entry block. */ 1934 ASSERT_EQ (NULL, entry->preds); 1935 ASSERT_EQ (1, entry->succs->length ()); 1936 ASSERT_EDGE ((*entry->succs)[0], 0, 4, EDGE_FALLTHRU); 1937 1938 /* bb4. */ 1939 ASSERT_EQ (1, bb4->preds->length ()); 1940 ASSERT_EDGE ((*bb4->preds)[0], 0, 4, EDGE_FALLTHRU); 1941 ASSERT_EQ (1, bb4->succs->length ()); 1942 ASSERT_EDGE ((*bb4->succs)[0], 4, 5, 0x0); 1943 1944 /* bb5. */ 1945 ASSERT_EQ (1, bb5->preds->length ()); 1946 ASSERT_EDGE ((*bb5->preds)[0], 4, 5, 0x0); 1947 ASSERT_EQ (1, bb5->succs->length ()); 1948 ASSERT_EDGE ((*bb5->succs)[0], 5, 1, EDGE_FALLTHRU); 1949 1950 /* Exit block. */ 1951 ASSERT_EQ (1, exit->preds->length ()); 1952 ASSERT_EDGE ((*exit->preds)[0], 5, 1, EDGE_FALLTHRU); 1953 ASSERT_EQ (NULL, exit->succs); 1954} 1955 1956/* Verify that the loader copes with a jump_insn to a label_ref 1957 marked "return". */ 1958 1959static void 1960test_loading_jump_to_return () 1961{ 1962 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("jump-to-return.rtl")); 1963 1964 rtx_insn *jump_insn = get_insn_by_uid (1); 1965 ASSERT_EQ (JUMP_INSN, GET_CODE (jump_insn)); 1966 ASSERT_RTX_PTR_EQ (ret_rtx, JUMP_LABEL (jump_insn)); 1967} 1968 1969/* Verify that the loader copes with a jump_insn to a label_ref 1970 marked "simple_return". */ 1971 1972static void 1973test_loading_jump_to_simple_return () 1974{ 1975 rtl_dump_test t (SELFTEST_LOCATION, 1976 locate_file ("jump-to-simple-return.rtl")); 1977 1978 rtx_insn *jump_insn = get_insn_by_uid (1); 1979 ASSERT_EQ (JUMP_INSN, GET_CODE (jump_insn)); 1980 ASSERT_RTX_PTR_EQ (simple_return_rtx, JUMP_LABEL (jump_insn)); 1981} 1982 1983/* Verify that the loader copes with a NOTE_INSN_BASIC_BLOCK. */ 1984 1985static void 1986test_loading_note_insn_basic_block () 1987{ 1988 rtl_dump_test t (SELFTEST_LOCATION, 1989 locate_file ("note_insn_basic_block.rtl")); 1990 1991 rtx_insn *note = get_insn_by_uid (1); 1992 ASSERT_EQ (NOTE, GET_CODE (note)); 1993 ASSERT_EQ (2, BLOCK_FOR_INSN (note)->index); 1994 1995 ASSERT_EQ (NOTE_INSN_BASIC_BLOCK, NOTE_KIND (note)); 1996 ASSERT_EQ (2, NOTE_BASIC_BLOCK (note)->index); 1997 ASSERT_EQ (BASIC_BLOCK_FOR_FN (cfun, 2), NOTE_BASIC_BLOCK (note)); 1998} 1999 2000/* Verify that the loader copes with a NOTE_INSN_DELETED. */ 2001 2002static void 2003test_loading_note_insn_deleted () 2004{ 2005 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("note-insn-deleted.rtl")); 2006 2007 rtx_insn *note = get_insn_by_uid (1); 2008 ASSERT_EQ (NOTE, GET_CODE (note)); 2009 ASSERT_EQ (NOTE_INSN_DELETED, NOTE_KIND (note)); 2010} 2011 2012/* Verify that the const_int values are consolidated, since 2013 pointer equality corresponds to value equality. 2014 TODO: do this for all in CASE_CONST_UNIQUE. */ 2015 2016static void 2017test_loading_const_int () 2018{ 2019 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("const-int.rtl")); 2020 2021 /* Verify that const_int values below MAX_SAVED_CONST_INT use 2022 the global values. */ 2023 ASSERT_EQ (const0_rtx, SET_SRC (PATTERN (get_insn_by_uid (1)))); 2024 ASSERT_EQ (const1_rtx, SET_SRC (PATTERN (get_insn_by_uid (2)))); 2025 ASSERT_EQ (constm1_rtx, SET_SRC (PATTERN (get_insn_by_uid (3)))); 2026 2027 /* Verify that other const_int values are consolidated. */ 2028 rtx int256 = gen_rtx_CONST_INT (SImode, 256); 2029 ASSERT_EQ (int256, SET_SRC (PATTERN (get_insn_by_uid (4)))); 2030} 2031 2032/* Verify that the loader copes with a SYMBOL_REF. */ 2033 2034static void 2035test_loading_symbol_ref () 2036{ 2037 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("symbol-ref.rtl")); 2038 2039 rtx_insn *insn = get_insns (); 2040 2041 rtx high = SET_SRC (PATTERN (insn)); 2042 ASSERT_EQ (HIGH, GET_CODE (high)); 2043 2044 rtx symbol_ref = XEXP (high, 0); 2045 ASSERT_EQ (SYMBOL_REF, GET_CODE (symbol_ref)); 2046 2047 /* Verify that "[flags 0xc0]" was parsed. */ 2048 ASSERT_EQ (0xc0, SYMBOL_REF_FLAGS (symbol_ref)); 2049 /* TODO: we don't yet load SYMBOL_REF_DECL. */ 2050} 2051 2052/* Verify that the loader can rebuild a CFG. */ 2053 2054static void 2055test_loading_cfg () 2056{ 2057 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("cfg-test.rtl")); 2058 2059 ASSERT_STREQ ("cfg_test", IDENTIFIER_POINTER (DECL_NAME (cfun->decl))); 2060 2061 ASSERT_TRUE (cfun); 2062 2063 ASSERT_TRUE (cfun->cfg != NULL); 2064 ASSERT_EQ (6, n_basic_blocks_for_fn (cfun)); 2065 ASSERT_EQ (6, n_edges_for_fn (cfun)); 2066 2067 /* The "fake" basic blocks. */ 2068 basic_block entry = ENTRY_BLOCK_PTR_FOR_FN (cfun); 2069 ASSERT_TRUE (entry != NULL); 2070 ASSERT_EQ (ENTRY_BLOCK, entry->index); 2071 2072 basic_block exit = EXIT_BLOCK_PTR_FOR_FN (cfun); 2073 ASSERT_TRUE (exit != NULL); 2074 ASSERT_EQ (EXIT_BLOCK, exit->index); 2075 2076 /* The "real" basic blocks. */ 2077 basic_block bb2 = (*cfun->cfg->x_basic_block_info)[2]; 2078 basic_block bb3 = (*cfun->cfg->x_basic_block_info)[3]; 2079 basic_block bb4 = (*cfun->cfg->x_basic_block_info)[4]; 2080 basic_block bb5 = (*cfun->cfg->x_basic_block_info)[5]; 2081 2082 ASSERT_EQ (2, bb2->index); 2083 ASSERT_EQ (3, bb3->index); 2084 ASSERT_EQ (4, bb4->index); 2085 ASSERT_EQ (5, bb5->index); 2086 2087 /* Verify connectivity. */ 2088 2089 /* Entry block. */ 2090 ASSERT_EQ (NULL, entry->preds); 2091 ASSERT_EQ (1, entry->succs->length ()); 2092 ASSERT_EDGE ((*entry->succs)[0], 0, 2, EDGE_FALLTHRU); 2093 2094 /* bb2. */ 2095 ASSERT_EQ (1, bb2->preds->length ()); 2096 ASSERT_EDGE ((*bb2->preds)[0], 0, 2, EDGE_FALLTHRU); 2097 ASSERT_EQ (2, bb2->succs->length ()); 2098 ASSERT_EDGE ((*bb2->succs)[0], 2, 3, EDGE_TRUE_VALUE); 2099 ASSERT_EDGE ((*bb2->succs)[1], 2, 4, EDGE_FALSE_VALUE); 2100 2101 /* bb3. */ 2102 ASSERT_EQ (1, bb3->preds->length ()); 2103 ASSERT_EDGE ((*bb3->preds)[0], 2, 3, EDGE_TRUE_VALUE); 2104 ASSERT_EQ (1, bb3->succs->length ()); 2105 ASSERT_EDGE ((*bb3->succs)[0], 3, 5, EDGE_FALLTHRU); 2106 2107 /* bb4. */ 2108 ASSERT_EQ (1, bb4->preds->length ()); 2109 ASSERT_EDGE ((*bb4->preds)[0], 2, 4, EDGE_FALSE_VALUE); 2110 ASSERT_EQ (1, bb4->succs->length ()); 2111 ASSERT_EDGE ((*bb4->succs)[0], 4, 5, EDGE_FALLTHRU); 2112 2113 /* bb5. */ 2114 ASSERT_EQ (2, bb5->preds->length ()); 2115 ASSERT_EDGE ((*bb5->preds)[0], 3, 5, EDGE_FALLTHRU); 2116 ASSERT_EDGE ((*bb5->preds)[1], 4, 5, EDGE_FALLTHRU); 2117 ASSERT_EQ (1, bb5->succs->length ()); 2118 ASSERT_EDGE ((*bb5->succs)[0], 5, 1, EDGE_FALLTHRU); 2119 2120 /* Exit block. */ 2121 ASSERT_EQ (1, exit->preds->length ()); 2122 ASSERT_EDGE ((*exit->preds)[0], 5, 1, EDGE_FALLTHRU); 2123 ASSERT_EQ (NULL, exit->succs); 2124} 2125 2126/* Verify that the loader copes with sparse block indices. 2127 This testcase loads a file with a "(block 42)". */ 2128 2129static void 2130test_loading_bb_index () 2131{ 2132 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("bb-index.rtl")); 2133 2134 ASSERT_STREQ ("test_bb_index", IDENTIFIER_POINTER (DECL_NAME (cfun->decl))); 2135 2136 ASSERT_TRUE (cfun); 2137 2138 ASSERT_TRUE (cfun->cfg != NULL); 2139 ASSERT_EQ (3, n_basic_blocks_for_fn (cfun)); 2140 ASSERT_EQ (43, basic_block_info_for_fn (cfun)->length ()); 2141 ASSERT_EQ (2, n_edges_for_fn (cfun)); 2142 2143 ASSERT_EQ (NULL, (*cfun->cfg->x_basic_block_info)[41]); 2144 basic_block bb42 = (*cfun->cfg->x_basic_block_info)[42]; 2145 ASSERT_NE (NULL, bb42); 2146 ASSERT_EQ (42, bb42->index); 2147} 2148 2149/* Verify that function_reader::handle_any_trailing_information correctly 2150 parses all the possible items emitted for a MEM. */ 2151 2152static void 2153test_loading_mem () 2154{ 2155 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("mem.rtl")); 2156 2157 ASSERT_STREQ ("test_mem", IDENTIFIER_POINTER (DECL_NAME (cfun->decl))); 2158 ASSERT_TRUE (cfun); 2159 2160 /* Verify parsing of "[42 i+17 S8 A128 AS5]". */ 2161 rtx_insn *insn_1 = get_insn_by_uid (1); 2162 rtx set1 = single_set (insn_1); 2163 rtx mem1 = SET_DEST (set1); 2164 ASSERT_EQ (42, MEM_ALIAS_SET (mem1)); 2165 /* "+17". */ 2166 ASSERT_TRUE (MEM_OFFSET_KNOWN_P (mem1)); 2167 ASSERT_KNOWN_EQ (17, MEM_OFFSET (mem1)); 2168 /* "S8". */ 2169 ASSERT_KNOWN_EQ (8, MEM_SIZE (mem1)); 2170 /* "A128. */ 2171 ASSERT_EQ (128, MEM_ALIGN (mem1)); 2172 /* "AS5. */ 2173 ASSERT_EQ (5, MEM_ADDR_SPACE (mem1)); 2174 2175 /* Verify parsing of "43 i+18 S9 AS6" 2176 (an address space without an alignment). */ 2177 rtx_insn *insn_2 = get_insn_by_uid (2); 2178 rtx set2 = single_set (insn_2); 2179 rtx mem2 = SET_DEST (set2); 2180 ASSERT_EQ (43, MEM_ALIAS_SET (mem2)); 2181 /* "+18". */ 2182 ASSERT_TRUE (MEM_OFFSET_KNOWN_P (mem2)); 2183 ASSERT_KNOWN_EQ (18, MEM_OFFSET (mem2)); 2184 /* "S9". */ 2185 ASSERT_KNOWN_EQ (9, MEM_SIZE (mem2)); 2186 /* "AS6. */ 2187 ASSERT_EQ (6, MEM_ADDR_SPACE (mem2)); 2188} 2189 2190/* Verify that "repeated xN" is read correctly. */ 2191 2192static void 2193test_loading_repeat () 2194{ 2195 rtl_dump_test t (SELFTEST_LOCATION, locate_file ("repeat.rtl")); 2196 2197 rtx_insn *insn_1 = get_insn_by_uid (1); 2198 ASSERT_EQ (PARALLEL, GET_CODE (PATTERN (insn_1))); 2199 ASSERT_EQ (64, XVECLEN (PATTERN (insn_1), 0)); 2200 for (int i = 0; i < 64; i++) 2201 ASSERT_EQ (const0_rtx, XVECEXP (PATTERN (insn_1), 0, i)); 2202} 2203 2204/* Run all of the selftests within this file. */ 2205 2206void 2207read_rtl_function_cc_tests () 2208{ 2209 test_edge_flags (); 2210 test_parsing_regnos (); 2211 test_loading_dump_fragment_1 (); 2212 test_loading_dump_fragment_2 (); 2213 test_loading_labels (); 2214 test_loading_insn_with_mode (); 2215 test_loading_jump_to_label_ref (); 2216 test_loading_jump_to_return (); 2217 test_loading_jump_to_simple_return (); 2218 test_loading_note_insn_basic_block (); 2219 test_loading_note_insn_deleted (); 2220 test_loading_const_int (); 2221 test_loading_symbol_ref (); 2222 test_loading_cfg (); 2223 test_loading_bb_index (); 2224 test_loading_mem (); 2225 test_loading_repeat (); 2226} 2227 2228} // namespace selftest 2229 2230#endif /* #if CHECKING_P */ 2231