1 /* read-rtl-function.c - Reader for RTL function dumps
2 Copyright (C) 2016-2019 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
25 #include "diagnostic.h"
29 #include "stringpool.h"
33 #include "basic-block.h"
38 #include "tree-pass.h"
41 #include "read-rtl-function.h"
43 #include "selftest-rtl.h"
46 class function_reader
;
49 /* Edges are recorded when parsing the "insn-chain" directive,
50 and created at the end when all the blocks ought to exist.
51 This struct records an "edge-from" or "edge-to" directive seen
52 at LOC, which will be turned into an actual CFG edge once
53 the "insn-chain" is fully parsed. */
58 deferred_edge (file_location loc
, int src_bb_idx
, int dest_bb_idx
, int flags
)
59 : m_loc (loc
), m_src_bb_idx (src_bb_idx
), m_dest_bb_idx (dest_bb_idx
),
69 /* Subclass of rtx_reader for reading function dumps. */
71 class function_reader
: public rtx_reader
77 /* Overridden vfuncs of class md_reader. */
78 void handle_unknown_directive (file_location
, const char *) FINAL OVERRIDE
;
80 /* Overridden vfuncs of class rtx_reader. */
81 rtx
read_rtx_operand (rtx x
, int idx
) FINAL OVERRIDE
;
82 void handle_any_trailing_information (rtx x
) FINAL OVERRIDE
;
83 rtx
postprocess (rtx
) FINAL OVERRIDE
;
84 const char *finalize_string (char *stringbuf
) FINAL OVERRIDE
;
86 rtx_insn
**get_insn_by_uid (int uid
);
87 tree
parse_mem_expr (const char *desc
);
90 void parse_function ();
91 void create_function ();
93 void parse_insn_chain ();
96 void parse_edge (basic_block block
, bool from
);
97 rtx_insn
*parse_insn (file_location loc
, const char *name
);
98 void parse_cfg (file_location loc
);
99 void parse_crtl (file_location loc
);
100 void create_edges ();
102 int parse_enum_value (int num_values
, const char *const *strings
);
104 void read_rtx_operand_u (rtx x
, int idx
);
105 void read_rtx_operand_i_or_n (rtx x
, int idx
, char format_char
);
106 rtx
read_rtx_operand_r (rtx x
);
107 rtx
extra_parsing_for_operand_code_0 (rtx x
, int idx
);
109 void add_fixup_insn_uid (file_location loc
, rtx insn
, int operand_idx
,
112 void add_fixup_note_insn_basic_block (file_location loc
, rtx insn
,
113 int operand_idx
, int bb_idx
);
115 void add_fixup_source_location (file_location loc
, rtx_insn
*insn
,
116 const char *filename
, int lineno
);
118 void add_fixup_expr (file_location loc
, rtx x
,
121 rtx
consolidate_singletons (rtx x
);
123 void maybe_read_location (rtx_insn
*insn
);
125 void handle_insn_uids ();
126 void apply_fixups ();
129 struct uid_hash
: int_hash
<int, -1, -2> {};
130 hash_map
<uid_hash
, rtx_insn
*> m_insns_by_uid
;
131 auto_vec
<fixup
*> m_fixups
;
132 rtx_insn
*m_first_insn
;
133 auto_vec
<tree
> m_fake_scope
;
135 bool m_have_crtl_directive
;
136 basic_block m_bb_to_insert_after
;
137 auto_vec
<deferred_edge
> m_deferred_edges
;
138 int m_highest_bb_idx
;
141 /* Abstract base class for recording post-processing steps that must be
142 done after reading a .rtl file. */
147 /* Constructor for a fixup at LOC affecting X. */
148 fixup (file_location loc
, rtx x
)
149 : m_loc (loc
), m_rtx (x
)
153 virtual void apply (function_reader
*reader
) const = 0;
160 /* An abstract subclass of fixup for post-processing steps that
161 act on a specific operand of a specific instruction. */
163 class operand_fixup
: public fixup
166 /* Constructor for a fixup at LOC affecting INSN's operand
167 with index OPERAND_IDX. */
168 operand_fixup (file_location loc
, rtx insn
, int operand_idx
)
169 : fixup (loc
, insn
), m_operand_idx (operand_idx
)
176 /* A concrete subclass of operand_fixup: fixup an rtx_insn *
177 field based on an integer UID. */
179 class fixup_insn_uid
: public operand_fixup
182 /* Constructor for a fixup at LOC affecting INSN's operand
183 with index OPERAND_IDX. Record INSN_UID as the uid. */
184 fixup_insn_uid (file_location loc
, rtx insn
, int operand_idx
, int insn_uid
)
185 : operand_fixup (loc
, insn
, operand_idx
),
186 m_insn_uid (insn_uid
)
189 void apply (function_reader
*reader
) const;
195 /* A concrete subclass of operand_fixup: fix up a
196 NOTE_INSN_BASIC_BLOCK based on an integer block ID. */
198 class fixup_note_insn_basic_block
: public operand_fixup
201 fixup_note_insn_basic_block (file_location loc
, rtx insn
, int operand_idx
,
203 : operand_fixup (loc
, insn
, operand_idx
),
207 void apply (function_reader
*reader
) const;
213 /* A concrete subclass of fixup (not operand_fixup): fix up
214 the expr of an rtx (REG or MEM) based on a textual dump. */
216 class fixup_expr
: public fixup
219 fixup_expr (file_location loc
, rtx x
, const char *desc
)
221 m_desc (xstrdup (desc
))
224 ~fixup_expr () { free (m_desc
); }
226 void apply (function_reader
*reader
) const;
232 /* Return a textual description of the operand of INSN with
233 index OPERAND_IDX. */
236 get_operand_name (rtx insn
, int operand_idx
)
238 gcc_assert (is_a
<rtx_insn
*> (insn
));
250 /* Fixup an rtx_insn * field based on an integer UID, as read by READER. */
253 fixup_insn_uid::apply (function_reader
*reader
) const
255 rtx_insn
**insn_from_uid
= reader
->get_insn_by_uid (m_insn_uid
);
257 XEXP (m_rtx
, m_operand_idx
) = *insn_from_uid
;
260 const char *op_name
= get_operand_name (m_rtx
, m_operand_idx
);
263 "insn with UID %i not found for operand %i (`%s') of insn %i",
264 m_insn_uid
, m_operand_idx
, op_name
, INSN_UID (m_rtx
));
267 "insn with UID %i not found for operand %i of insn %i",
268 m_insn_uid
, m_operand_idx
, INSN_UID (m_rtx
));
272 /* Fix up a NOTE_INSN_BASIC_BLOCK based on an integer block ID. */
275 fixup_note_insn_basic_block::apply (function_reader
*) const
277 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, m_bb_idx
);
279 NOTE_BASIC_BLOCK (m_rtx
) = bb
;
282 /* Fix up the expr of an rtx (REG or MEM) based on a textual dump
286 fixup_expr::apply (function_reader
*reader
) const
288 tree expr
= reader
->parse_mem_expr (m_desc
);
289 switch (GET_CODE (m_rtx
))
292 set_reg_attrs_for_decl_rtl (expr
, m_rtx
);
295 set_mem_expr (m_rtx
, expr
);
302 /* Strip trailing whitespace from DESC. */
305 strip_trailing_whitespace (char *desc
)
307 char *terminator
= desc
+ strlen (desc
);
308 while (desc
< terminator
)
311 if (ISSPACE (*terminator
))
318 /* Return the numeric value n for GET_NOTE_INSN_NAME (n) for STRING,
319 or fail if STRING isn't recognized. */
322 parse_note_insn_name (const char *string
)
324 for (int i
= 0; i
< NOTE_INSN_MAX
; i
++)
325 if (strcmp (string
, GET_NOTE_INSN_NAME (i
)) == 0)
327 fatal_with_file_and_line ("unrecognized NOTE_INSN name: `%s'", string
);
330 /* Return the register number for NAME, or return -1 if it isn't
334 lookup_reg_by_dump_name (const char *name
)
336 for (int i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
338 && ! strcmp (name
, reg_names
[i
]))
341 /* Also lookup virtuals. */
342 if (!strcmp (name
, "virtual-incoming-args"))
343 return VIRTUAL_INCOMING_ARGS_REGNUM
;
344 if (!strcmp (name
, "virtual-stack-vars"))
345 return VIRTUAL_STACK_VARS_REGNUM
;
346 if (!strcmp (name
, "virtual-stack-dynamic"))
347 return VIRTUAL_STACK_DYNAMIC_REGNUM
;
348 if (!strcmp (name
, "virtual-outgoing-args"))
349 return VIRTUAL_OUTGOING_ARGS_REGNUM
;
350 if (!strcmp (name
, "virtual-cfa"))
351 return VIRTUAL_CFA_REGNUM
;
352 if (!strcmp (name
, "virtual-preferred-stack-boundary"))
353 return VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM
;
354 /* TODO: handle "virtual-reg-%d". */
356 /* In compact mode, pseudos are printed with '< and '>' wrapping the regno,
357 offseting it by (LAST_VIRTUAL_REGISTER + 1), so that the
358 first non-virtual pseudo is dumped as "<0>". */
359 if (name
[0] == '<' && name
[strlen (name
) - 1] == '>')
361 int dump_num
= atoi (name
+ 1);
362 return dump_num
+ LAST_VIRTUAL_REGISTER
+ 1;
369 /* class function_reader : public rtx_reader */
371 /* function_reader's constructor. */
373 function_reader::function_reader ()
377 m_have_crtl_directive (false),
378 m_bb_to_insert_after (NULL
),
379 m_highest_bb_idx (EXIT_BLOCK
)
383 /* function_reader's destructor. */
385 function_reader::~function_reader ()
389 FOR_EACH_VEC_ELT (m_fixups
, i
, f
)
395 /* Implementation of rtx_reader::handle_unknown_directive,
396 for parsing the remainder of a directive with name NAME
399 Require a top-level "function" directive, as emitted by
400 print_rtx_function, and parse it. */
403 function_reader::handle_unknown_directive (file_location start_loc
,
406 if (strcmp (name
, "function"))
407 fatal_at (start_loc
, "expected 'function'");
410 error ("%<__RTL%> function cannot be compiled with %<-flto%>");
415 /* Parse the output of print_rtx_function (or hand-written data in the
416 same format), having already parsed the "(function" heading, and
417 finishing immediately before the final ")".
419 The "param" and "crtl" clauses are optional. */
422 function_reader::parse_function ()
424 m_name
= xstrdup (read_string (0));
430 int c
= read_skip_spaces ();
438 file_location loc
= get_current_location ();
439 struct md_name directive
;
440 read_name (&directive
);
441 if (strcmp (directive
.string
, "param") == 0)
443 else if (strcmp (directive
.string
, "insn-chain") == 0)
445 else if (strcmp (directive
.string
, "crtl") == 0)
448 fatal_with_file_and_line ("unrecognized directive: %s",
456 /* Rebuild the JUMP_LABEL field of any JUMP_INSNs in the chain, and the
457 LABEL_NUSES of any CODE_LABELs.
459 This has to happen after apply_fixups, since only after then do
460 LABEL_REFs have their label_ref_label set up. */
461 rebuild_jump_labels (get_insns ());
463 crtl
->init_stack_alignment ();
466 /* Set up state for the function *before* fixups are applied.
468 Create "cfun" and a decl for the function.
469 By default, every function decl is hardcoded as
470 int test_1 (int i, int j, int k);
471 Set up various other state:
472 - the cfg and basic blocks (edges are created later, *after* fixups
474 - add the function to the callgraph. */
477 function_reader::create_function ()
479 /* We start in cfgrtl mode, rather than cfglayout mode. */
480 rtl_register_cfg_hooks ();
482 /* When run from selftests or "rtl1", cfun is NULL.
483 When run from "cc1" for a C function tagged with __RTL, cfun is the
487 tree fn_name
= get_identifier (m_name
? m_name
: "test_1");
488 tree int_type
= integer_type_node
;
489 tree return_type
= int_type
;
490 tree arg_types
[3] = {int_type
, int_type
, int_type
};
491 tree fn_type
= build_function_type_array (return_type
, 3, arg_types
);
492 tree fndecl
= build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, fn_name
, fn_type
);
493 tree resdecl
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
, NULL_TREE
,
495 DECL_ARTIFICIAL (resdecl
) = 1;
496 DECL_IGNORED_P (resdecl
) = 1;
497 DECL_RESULT (fndecl
) = resdecl
;
498 allocate_struct_function (fndecl
, false);
499 /* This sets cfun. */
500 current_function_decl
= fndecl
;
504 gcc_assert (current_function_decl
);
505 tree fndecl
= current_function_decl
;
507 /* Mark this function as being specified as __RTL. */
508 cfun
->curr_properties
|= PROP_rtl
;
510 /* cc1 normally inits DECL_INITIAL (fndecl) to be error_mark_node.
511 Create a dummy block for it. */
512 DECL_INITIAL (fndecl
) = make_node (BLOCK
);
514 cfun
->curr_properties
= (PROP_cfg
| PROP_rtl
);
516 /* Do we need this to force cgraphunit.c to output the function? */
517 DECL_EXTERNAL (fndecl
) = 0;
518 DECL_PRESERVE_P (fndecl
) = 1;
521 cgraph_node::finalize_function (fndecl
, false);
523 /* Create bare-bones cfg. This creates the entry and exit blocks. */
524 init_empty_tree_cfg_for_function (cfun
);
525 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
526 EXIT_BLOCK_PTR_FOR_FN (cfun
)->flags
|= BB_RTL
;
527 init_rtl_bb_info (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
528 init_rtl_bb_info (EXIT_BLOCK_PTR_FOR_FN (cfun
));
529 m_bb_to_insert_after
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
533 /* Look within the the params of FNDECL for a param named NAME.
534 Return NULL_TREE if one isn't found. */
537 find_param_by_name (tree fndecl
, const char *name
)
539 for (tree arg
= DECL_ARGUMENTS (fndecl
); arg
; arg
= TREE_CHAIN (arg
))
540 if (id_equal (DECL_NAME (arg
), name
))
545 /* Parse the content of a "param" directive, having already parsed the
546 "(param". Consume the trailing ')'. */
549 function_reader::parse_param ()
551 require_char_ws ('"');
552 file_location loc
= get_current_location ();
553 char *name
= read_quoted_string ();
555 /* Lookup param by name. */
556 tree t_param
= find_param_by_name (cfun
->decl
, name
);
558 fatal_at (loc
, "param not found: %s", name
);
560 /* Parse DECL_RTL. */
561 require_char_ws ('(');
562 require_word_ws ("DECL_RTL");
563 DECL_WRTL_CHECK (t_param
)->decl_with_rtl
.rtl
= parse_rtx ();
564 require_char_ws (')');
566 /* Parse DECL_RTL_INCOMING. */
567 require_char_ws ('(');
568 require_word_ws ("DECL_RTL_INCOMING");
569 DECL_INCOMING_RTL (t_param
) = parse_rtx ();
570 require_char_ws (')');
572 require_char_ws (')');
575 /* Parse zero or more child insn elements within an
576 "insn-chain" element. Consume the trailing ')'. */
579 function_reader::parse_insn_chain ()
583 int c
= read_skip_spaces ();
584 file_location loc
= get_current_location ();
589 struct md_name directive
;
590 read_name (&directive
);
591 if (strcmp (directive
.string
, "block") == 0)
594 parse_insn (loc
, directive
.string
);
597 fatal_at (loc
, "expected '(' or ')'");
603 /* Parse zero or more child directives (edges and insns) within a
604 "block" directive, having already parsed the "(block " heading.
605 Consume the trailing ')'. */
608 function_reader::parse_block ()
610 /* Parse the index value from the dump. This will be an integer;
611 we don't support "entry" or "exit" here (unlike for edges). */
614 int bb_idx
= atoi (name
.string
);
616 /* The term "index" has two meanings for basic blocks in a CFG:
617 (a) the "index" field within struct basic_block_def.
618 (b) the index of a basic_block within the cfg's x_basic_block_info
619 vector, as accessed via BASIC_BLOCK_FOR_FN.
621 These can get out-of-sync when basic blocks are optimized away.
622 They get back in sync by "compact_blocks".
623 We reconstruct cfun->cfg->x_basic_block_info->m_vecdata with NULL
624 values in it for any missing basic blocks, so that (a) == (b) for
625 all of the blocks we create. The doubly-linked list of basic
626 blocks (next_bb/prev_bb) skips over these "holes". */
628 if (m_highest_bb_idx
< bb_idx
)
629 m_highest_bb_idx
= bb_idx
;
631 size_t new_size
= m_highest_bb_idx
+ 1;
632 if (basic_block_info_for_fn (cfun
)->length () < new_size
)
633 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
), new_size
);
635 last_basic_block_for_fn (cfun
) = new_size
;
637 /* Create the basic block.
639 We can't call create_basic_block and use the regular RTL block-creation
640 hooks, since this creates NOTE_INSN_BASIC_BLOCK instances. We don't
641 want to do that; we want to use the notes we were provided with. */
642 basic_block bb
= alloc_block ();
643 init_rtl_bb_info (bb
);
645 bb
->flags
= BB_NEW
| BB_RTL
;
646 link_block (bb
, m_bb_to_insert_after
);
647 m_bb_to_insert_after
= bb
;
649 n_basic_blocks_for_fn (cfun
)++;
650 SET_BASIC_BLOCK_FOR_FN (cfun
, bb_idx
, bb
);
651 BB_SET_PARTITION (bb
, BB_UNPARTITIONED
);
653 /* Handle insns, edge-from and edge-to directives. */
656 int c
= read_skip_spaces ();
657 file_location loc
= get_current_location ();
662 struct md_name directive
;
663 read_name (&directive
);
664 if (strcmp (directive
.string
, "edge-from") == 0)
665 parse_edge (bb
, true);
666 else if (strcmp (directive
.string
, "edge-to") == 0)
667 parse_edge (bb
, false);
670 rtx_insn
*insn
= parse_insn (loc
, directive
.string
);
671 set_block_for_insn (insn
, bb
);
678 fatal_at (loc
, "expected '(' or ')'");
682 /* Subroutine of function_reader::parse_edge.
683 Parse a basic block index, handling "entry" and "exit". */
686 function_reader::parse_bb_idx ()
690 if (strcmp (name
.string
, "entry") == 0)
692 if (strcmp (name
.string
, "exit") == 0)
694 return atoi (name
.string
);
697 /* Subroutine of parse_edge_flags.
698 Parse TOK, a token such as "FALLTHRU", converting to the flag value.
699 Issue an error if the token is unrecognized. */
702 parse_edge_flag_token (const char *tok
)
704 #define DEF_EDGE_FLAG(NAME,IDX) \
706 if (strcmp (tok, #NAME) == 0) \
707 return EDGE_##NAME; \
709 #include "cfg-flags.def"
711 error ("unrecognized edge flag: %qs", tok
);
715 /* Subroutine of function_reader::parse_edge.
716 Parse STR and convert to a flag value (or issue an error).
717 The parser uses strtok and hence modifiers STR in-place. */
720 parse_edge_flags (char *str
)
724 char *tok
= strtok (str
, "| ");
727 result
|= parse_edge_flag_token (tok
);
728 tok
= strtok (NULL
, "| ");
734 /* Parse an "edge-from" or "edge-to" directive within the "block"
735 directive for BLOCK, having already parsed the "(edge" heading.
736 Consume the final ")". Record the edge within m_deferred_edges.
737 FROM is true for an "edge-from" directive, false for an "edge-to"
741 function_reader::parse_edge (basic_block block
, bool from
)
744 int this_bb_idx
= block
->index
;
745 file_location loc
= get_current_location ();
746 int other_bb_idx
= parse_bb_idx ();
748 /* "(edge-from 2)" means src = 2, dest = this_bb_idx, whereas
749 "(edge-to 3)" means src = this_bb_idx, dest = 3. */
750 int src_idx
= from
? other_bb_idx
: this_bb_idx
;
751 int dest_idx
= from
? this_bb_idx
: other_bb_idx
;
753 /* Optional "(flags)". */
755 int c
= read_skip_spaces ();
758 require_word_ws ("flags");
759 require_char_ws ('"');
760 char *str
= read_quoted_string ();
761 flags
= parse_edge_flags (str
);
762 require_char_ws (')');
767 require_char_ws (')');
769 /* This BB already exists, but the other BB might not yet.
770 For now, save the edges, and create them at the end of insn-chain
772 /* For now, only process the (edge-from) to this BB, and (edge-to)
773 that go to the exit block.
774 FIXME: we don't yet verify that the edge-from and edge-to directives
776 if (from
|| dest_idx
== EXIT_BLOCK
)
777 m_deferred_edges
.safe_push (deferred_edge (loc
, src_idx
, dest_idx
, flags
));
780 /* Parse an rtx instruction, having parsed the opening and parenthesis, and
781 name NAME, seen at START_LOC, by calling read_rtx_code, calling
782 set_first_insn and set_last_insn as appropriate, and
783 adding the insn to the insn chain.
784 Consume the trailing ')'. */
787 function_reader::parse_insn (file_location start_loc
, const char *name
)
789 rtx x
= read_rtx_code (name
);
791 fatal_at (start_loc
, "expected insn type; got '%s'", name
);
792 rtx_insn
*insn
= dyn_cast
<rtx_insn
*> (x
);
794 fatal_at (start_loc
, "expected insn type; got '%s'", name
);
796 /* Consume the trailing ')'. */
797 require_char_ws (')');
799 rtx_insn
*last_insn
= get_last_insn ();
801 /* Add "insn" to the insn chain. */
804 gcc_assert (NEXT_INSN (last_insn
) == NULL
);
805 SET_NEXT_INSN (last_insn
) = insn
;
807 SET_PREV_INSN (insn
) = last_insn
;
809 /* Add it to the sequence. */
810 set_last_insn (insn
);
814 set_first_insn (insn
);
817 if (rtx_code_label
*label
= dyn_cast
<rtx_code_label
*> (insn
))
818 maybe_set_max_label_num (label
);
823 /* Postprocessing subroutine for parse_insn_chain: all the basic blocks
824 should have been created by now; create the edges that were seen. */
827 function_reader::create_edges ()
831 FOR_EACH_VEC_ELT (m_deferred_edges
, i
, de
)
833 /* The BBs should already have been created by parse_block. */
834 basic_block src
= BASIC_BLOCK_FOR_FN (cfun
, de
->m_src_bb_idx
);
836 fatal_at (de
->m_loc
, "error: block index %i not found",
838 basic_block dst
= BASIC_BLOCK_FOR_FN (cfun
, de
->m_dest_bb_idx
);
840 fatal_at (de
->m_loc
, "error: block with index %i not found",
842 unchecked_make_edge (src
, dst
, de
->m_flags
);
846 /* Parse a "crtl" directive, having already parsed the "(crtl" heading
848 Consume the final ")". */
851 function_reader::parse_crtl (file_location loc
)
853 if (m_have_crtl_directive
)
854 error_at (loc
, "more than one 'crtl' directive");
855 m_have_crtl_directive
= true;
858 require_char_ws ('(');
859 require_word_ws ("return_rtx");
860 crtl
->return_rtx
= parse_rtx ();
861 require_char_ws (')');
863 require_char_ws (')');
866 /* Parse operand IDX of X, returning X, or an equivalent rtx
867 expression (for consolidating singletons).
868 This is an overridden implementation of rtx_reader::read_rtx_operand for
869 function_reader, handling various extra data printed by print_rtx,
870 and sometimes calling the base class implementation. */
873 function_reader::read_rtx_operand (rtx x
, int idx
)
875 RTX_CODE code
= GET_CODE (x
);
876 const char *format_ptr
= GET_RTX_FORMAT (code
);
877 const char format_char
= format_ptr
[idx
];
880 /* Override the regular parser for some format codes. */
884 if (idx
== 7 && CALL_P (x
))
886 m_in_call_function_usage
= true;
887 return rtx_reader::read_rtx_operand (x
, idx
);
888 m_in_call_function_usage
= false;
891 return rtx_reader::read_rtx_operand (x
, idx
);
895 read_rtx_operand_u (x
, idx
);
896 /* Don't run regular parser for 'u'. */
901 read_rtx_operand_i_or_n (x
, idx
, format_char
);
902 /* Don't run regular parser for these codes. */
906 gcc_assert (is_compact ());
907 /* Compact mode doesn't store BBs. */
908 /* Don't run regular parser. */
912 /* Don't run regular parser for 'r'. */
913 return read_rtx_operand_r (x
);
919 /* Call base class implementation. */
920 x
= rtx_reader::read_rtx_operand (x
, idx
);
922 /* Handle any additional parsing needed to handle what the dump
927 x
= extra_parsing_for_operand_code_0 (x
, idx
);
933 /* Strip away the redundant hex dump of the value. */
934 require_char_ws ('[');
936 require_char_ws (']');
947 /* Parse operand IDX of X, of code 'u', when reading function dumps.
949 The RTL file recorded the ID of an insn (or 0 for NULL); we
950 must store this as a pointer, but the insn might not have
951 been loaded yet. Store the ID away for now, via a fixup. */
954 function_reader::read_rtx_operand_u (rtx x
, int idx
)
956 /* In compact mode, the PREV/NEXT insn uids are not dumped, so skip
957 the "uu" when reading. */
958 if (is_compact () && GET_CODE (x
) != LABEL_REF
)
962 file_location loc
= read_name (&name
);
963 int insn_id
= atoi (name
.string
);
965 add_fixup_insn_uid (loc
, x
, idx
, insn_id
);
968 /* Read a name, looking for a match against a string found in array
969 STRINGS of size NUM_VALUES.
970 Return the index of the the matched string, or emit an error. */
973 function_reader::parse_enum_value (int num_values
, const char *const *strings
)
977 for (int i
= 0; i
< num_values
; i
++)
979 if (strcmp (name
.string
, strings
[i
]) == 0)
982 error ("unrecognized enum value: %qs", name
.string
);
986 /* Parse operand IDX of X, of code 'i' or 'n' (as specified by FORMAT_CHAR).
987 Special-cased handling of these, for reading function dumps. */
990 function_reader::read_rtx_operand_i_or_n (rtx x
, int idx
,
993 /* Handle some of the extra information that print_rtx
994 can write out for these cases. */
995 /* print_rtx only writes out operand 5 for notes
996 for NOTE_KIND values NOTE_INSN_DELETED_LABEL
997 and NOTE_INSN_DELETED_DEBUG_LABEL. */
998 if (idx
== 5 && NOTE_P (x
))
1001 if (idx
== 4 && INSN_P (x
))
1003 maybe_read_location (as_a
<rtx_insn
*> (x
));
1007 /* INSN_CODEs aren't printed in compact mode, so don't attempt to
1011 && &INSN_CODE (x
) == &XINT (x
, idx
))
1017 /* Handle UNSPEC and UNSPEC_VOLATILE's operand 1. */
1018 #if !defined(GENERATOR_FILE) && NUM_UNSPECV_VALUES > 0
1020 && GET_CODE (x
) == UNSPEC_VOLATILE
)
1023 = parse_enum_value (NUM_UNSPECV_VALUES
, unspecv_strings
);
1027 #if !defined(GENERATOR_FILE) && NUM_UNSPEC_VALUES > 0
1029 && (GET_CODE (x
) == UNSPEC
1030 || GET_CODE (x
) == UNSPEC_VOLATILE
))
1033 = parse_enum_value (NUM_UNSPEC_VALUES
, unspec_strings
);
1038 struct md_name name
;
1041 if (format_char
== 'n')
1042 value
= parse_note_insn_name (name
.string
);
1044 value
= atoi (name
.string
);
1045 XINT (x
, idx
) = value
;
1048 /* Parse the 'r' operand of X, returning X, or an equivalent rtx
1049 expression (for consolidating singletons).
1050 Special-cased handling of code 'r' for reading function dumps. */
1053 function_reader::read_rtx_operand_r (rtx x
)
1055 struct md_name name
;
1056 file_location loc
= read_name (&name
);
1057 int regno
= lookup_reg_by_dump_name (name
.string
);
1059 fatal_at (loc
, "unrecognized register: '%s'", name
.string
);
1061 set_regno_raw (x
, regno
, 1);
1063 /* Consolidate singletons. */
1064 x
= consolidate_singletons (x
);
1066 ORIGINAL_REGNO (x
) = regno
;
1068 /* Parse extra stuff at end of 'r'.
1069 We may have zero, one, or two sections marked by square
1071 int ch
= read_skip_spaces ();
1072 bool expect_original_regno
= false;
1075 file_location loc
= get_current_location ();
1076 char *desc
= read_until ("]", true);
1077 strip_trailing_whitespace (desc
);
1078 const char *desc_start
= desc
;
1079 /* If ORIGINAL_REGNO (rtx) != regno, we will have:
1080 "orig:%i", ORIGINAL_REGNO (rtx).
1081 Consume it, we don't set ORIGINAL_REGNO, since we can
1082 get that from the 2nd copy later. */
1083 if (strncmp (desc
, "orig:", 5) == 0)
1085 expect_original_regno
= true;
1087 /* Skip to any whitespace following the integer. */
1088 const char *space
= strchr (desc_start
, ' ');
1090 desc_start
= space
+ 1;
1092 /* Any remaining text may be the REG_EXPR. Alternatively we have
1093 no REG_ATTRS, and instead we have ORIGINAL_REGNO. */
1094 if (ISDIGIT (*desc_start
))
1096 /* Assume we have ORIGINAL_REGNO. */
1097 ORIGINAL_REGNO (x
) = atoi (desc_start
);
1101 /* Assume we have REG_EXPR. */
1102 add_fixup_expr (loc
, x
, desc_start
);
1108 if (expect_original_regno
)
1110 require_char_ws ('[');
1111 char *desc
= read_until ("]", true);
1112 ORIGINAL_REGNO (x
) = atoi (desc
);
1119 /* Additional parsing for format code '0' in dumps, handling a variety
1120 of special-cases in print_rtx, when parsing operand IDX of X.
1121 Return X, or possibly a reallocated copy of X. */
1124 function_reader::extra_parsing_for_operand_code_0 (rtx x
, int idx
)
1126 RTX_CODE code
= GET_CODE (x
);
1128 struct md_name name
;
1130 if (idx
== 1 && code
== SYMBOL_REF
)
1132 /* Possibly wrote " [flags %#x]", SYMBOL_REF_FLAGS (in_rtx). */
1133 c
= read_skip_spaces ();
1136 file_location loc
= read_name (&name
);
1137 if (strcmp (name
.string
, "flags"))
1138 error_at (loc
, "was expecting `%s'", "flags");
1140 SYMBOL_REF_FLAGS (x
) = strtol (name
.string
, NULL
, 16);
1142 /* The standard RTX_CODE_SIZE (SYMBOL_REF) used when allocating
1143 x doesn't have space for the block_symbol information, so
1144 we must reallocate it if this flag is set. */
1145 if (SYMBOL_REF_HAS_BLOCK_INFO_P (x
))
1147 /* Emulate the allocation normally done by
1148 varasm.c:create_block_symbol. */
1149 unsigned int size
= RTX_HDR_SIZE
+ sizeof (struct block_symbol
);
1150 rtx new_x
= (rtx
) ggc_internal_alloc (size
);
1152 /* Copy data over from the smaller SYMBOL_REF. */
1153 memcpy (new_x
, x
, RTX_CODE_SIZE (SYMBOL_REF
));
1156 /* We can't reconstruct SYMBOL_REF_BLOCK; set it to NULL. */
1157 SYMBOL_REF_BLOCK (x
) = NULL
;
1159 /* Zero the offset. */
1160 SYMBOL_REF_BLOCK_OFFSET (x
) = 0;
1168 /* If X had a non-NULL SYMBOL_REF_DECL,
1169 rtx_writer::print_rtx_operand_code_0 would have dumped it
1170 using print_node_brief.
1171 Skip the content for now. */
1172 c
= read_skip_spaces ();
1177 char ch
= read_char ();
1185 else if (idx
== 3 && code
== NOTE
)
1187 /* Note-specific data appears for operand 3, which annoyingly
1188 is before the enum specifying which kind of note we have
1190 c
= read_skip_spaces ();
1193 /* Possibly data for a NOTE_INSN_BASIC_BLOCK, of the form:
1195 file_location bb_loc
= read_name (&name
);
1196 if (strcmp (name
.string
, "bb"))
1197 error_at (bb_loc
, "was expecting `%s'", "bb");
1199 int bb_idx
= atoi (name
.string
);
1200 add_fixup_note_insn_basic_block (bb_loc
, x
, idx
,
1202 require_char_ws (']');
1211 /* Implementation of rtx_reader::handle_any_trailing_information.
1212 Handle the various additional information that print-rtl.c can
1213 write after the regular fields, when parsing X. */
1216 function_reader::handle_any_trailing_information (rtx x
)
1218 struct md_name name
;
1220 switch (GET_CODE (x
))
1225 require_char_ws ('[');
1227 set_mem_alias_set (x
, atoi (name
.string
));
1228 /* We have either a MEM_EXPR, or a space. */
1229 if (peek_char () != ' ')
1231 file_location loc
= get_current_location ();
1232 char *desc
= read_until (" +", false);
1233 add_fixup_expr (loc
, consolidate_singletons (x
), desc
);
1239 /* We may optionally have '+' for MEM_OFFSET_KNOWN_P. */
1240 ch
= read_skip_spaces ();
1244 set_mem_offset (x
, atoi (name
.string
));
1249 /* Handle optional " S" for MEM_SIZE. */
1250 ch
= read_skip_spaces ();
1254 set_mem_size (x
, atoi (name
.string
));
1259 /* Handle optional " A" for MEM_ALIGN. */
1260 ch
= read_skip_spaces ();
1261 if (ch
== 'A' && peek_char () != 'S')
1264 set_mem_align (x
, atoi (name
.string
));
1269 /* Handle optional " AS" for MEM_ADDR_SPACE. */
1270 ch
= read_skip_spaces ();
1271 if (ch
== 'A' && peek_char () == 'S')
1275 set_mem_addr_space (x
, atoi (name
.string
));
1285 /* Assume that LABEL_NUSES was not dumped. */
1286 /* TODO: parse LABEL_KIND. */
1287 /* For now, skip until closing ')'. */
1290 char ch
= read_char ();
1305 /* Parse a tree dump for a MEM_EXPR in DESC and turn it back into a tree.
1306 We handle "<retval>" and param names within cfun, but for anything else
1307 we "cheat" by building a global VAR_DECL of type "int" with that name
1308 (returning the same global for a name if we see the same name more
1312 function_reader::parse_mem_expr (const char *desc
)
1314 tree fndecl
= cfun
->decl
;
1316 if (strcmp (desc
, "<retval>") == 0)
1317 return DECL_RESULT (fndecl
);
1319 tree param
= find_param_by_name (fndecl
, desc
);
1323 /* Search within decls we already created.
1324 FIXME: use a hash rather than linear search. */
1327 FOR_EACH_VEC_ELT (m_fake_scope
, i
, t
)
1328 if (id_equal (DECL_NAME (t
), desc
))
1331 /* Not found? Create it.
1332 This allows mimicking of real data but avoids having to specify
1333 e.g. names of locals, params etc.
1334 Though this way we don't know if we have a PARM_DECL vs a VAR_DECL,
1335 and we don't know the types. Fake it by making everything be
1336 a VAR_DECL of "int" type. */
1337 t
= build_decl (UNKNOWN_LOCATION
, VAR_DECL
,
1338 get_identifier (desc
),
1340 m_fake_scope
.safe_push (t
);
1344 /* Record that at LOC we saw an insn uid INSN_UID for the operand with index
1345 OPERAND_IDX within INSN, so that the pointer value can be fixed up in
1346 later post-processing. */
1349 function_reader::add_fixup_insn_uid (file_location loc
, rtx insn
, int operand_idx
,
1352 m_fixups
.safe_push (new fixup_insn_uid (loc
, insn
, operand_idx
, insn_uid
));
1355 /* Record that at LOC we saw an basic block index BB_IDX for the operand with index
1356 OPERAND_IDX within INSN, so that the pointer value can be fixed up in
1357 later post-processing. */
1360 function_reader::add_fixup_note_insn_basic_block (file_location loc
, rtx insn
,
1361 int operand_idx
, int bb_idx
)
1363 m_fixups
.safe_push (new fixup_note_insn_basic_block (loc
, insn
, operand_idx
,
1367 /* Placeholder hook for recording source location information seen in a dump.
1368 This is empty for now. */
1371 function_reader::add_fixup_source_location (file_location
, rtx_insn
*,
1376 /* Record that at LOC we saw textual description DESC of the MEM_EXPR or REG_EXPR
1377 of INSN, so that the fields can be fixed up in later post-processing. */
1380 function_reader::add_fixup_expr (file_location loc
, rtx insn
,
1384 /* Fail early if the RTL reader erroneously hands us an int. */
1385 gcc_assert (!ISDIGIT (desc
[0]));
1387 m_fixups
.safe_push (new fixup_expr (loc
, insn
, desc
));
1390 /* Helper function for consolidate_reg. Return the global rtx for
1391 the register with regno REGNO. */
1394 lookup_global_register (int regno
)
1396 /* We can't use a switch here, as some of the REGNUMs might not be constants
1397 for some targets. */
1398 if (regno
== STACK_POINTER_REGNUM
)
1399 return stack_pointer_rtx
;
1400 else if (regno
== FRAME_POINTER_REGNUM
)
1401 return frame_pointer_rtx
;
1402 else if (regno
== HARD_FRAME_POINTER_REGNUM
)
1403 return hard_frame_pointer_rtx
;
1404 else if (regno
== ARG_POINTER_REGNUM
)
1405 return arg_pointer_rtx
;
1406 else if (regno
== VIRTUAL_INCOMING_ARGS_REGNUM
)
1407 return virtual_incoming_args_rtx
;
1408 else if (regno
== VIRTUAL_STACK_VARS_REGNUM
)
1409 return virtual_stack_vars_rtx
;
1410 else if (regno
== VIRTUAL_STACK_DYNAMIC_REGNUM
)
1411 return virtual_stack_dynamic_rtx
;
1412 else if (regno
== VIRTUAL_OUTGOING_ARGS_REGNUM
)
1413 return virtual_outgoing_args_rtx
;
1414 else if (regno
== VIRTUAL_CFA_REGNUM
)
1415 return virtual_cfa_rtx
;
1416 else if (regno
== VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM
)
1417 return virtual_preferred_stack_boundary_rtx
;
1418 #ifdef return_ADDRESS_POINTER_REGNUM
1419 else if (regno
== RETURN_ADDRESS_POINTER_REGNUM
)
1420 return return_address_pointer_rtx
;
1426 /* Ensure that the backend can cope with a REG with regno REGNO.
1427 Normally REG instances are created by gen_reg_rtx which updates
1428 regno_reg_rtx, growing it as necessary.
1429 The REG instances created from the dumpfile weren't created this
1430 way, so we need to manually update regno_reg_rtx. */
1433 ensure_regno (int regno
)
1435 if (reg_rtx_no
< regno
+ 1)
1436 reg_rtx_no
= regno
+ 1;
1438 crtl
->emit
.ensure_regno_capacity ();
1439 gcc_assert (regno
< crtl
->emit
.regno_pointer_align_length
);
1442 /* Helper function for consolidate_singletons, for handling REG instances.
1443 Given REG instance X of some regno, return the singleton rtx for that
1444 regno, if it exists, or X. */
1447 consolidate_reg (rtx x
)
1449 gcc_assert (GET_CODE (x
) == REG
);
1451 unsigned int regno
= REGNO (x
);
1453 ensure_regno (regno
);
1455 /* Some register numbers have their rtx created in init_emit_regs
1456 e.g. stack_pointer_rtx for STACK_POINTER_REGNUM.
1457 Consolidate on this. */
1458 rtx global_reg
= lookup_global_register (regno
);
1462 /* Populate regno_reg_rtx if necessary. */
1463 if (regno_reg_rtx
[regno
] == NULL
)
1464 regno_reg_rtx
[regno
] = x
;
1466 gcc_assert (GET_CODE (regno_reg_rtx
[regno
]) == REG
);
1467 gcc_assert (REGNO (regno_reg_rtx
[regno
]) == regno
);
1468 if (GET_MODE (x
) == GET_MODE (regno_reg_rtx
[regno
]))
1469 return regno_reg_rtx
[regno
];
1474 /* When reading RTL function dumps, we must consolidate some
1475 rtx so that we use singletons where singletons are expected
1476 (e.g. we don't want multiple "(const_int 0 [0])" rtx, since
1477 these are tested via pointer equality against const0_rtx.
1479 Return the equivalent singleton rtx for X, if any, otherwise X. */
1482 function_reader::consolidate_singletons (rtx x
)
1487 switch (GET_CODE (x
))
1489 case PC
: return pc_rtx
;
1490 case RETURN
: return ret_rtx
;
1491 case SIMPLE_RETURN
: return simple_return_rtx
;
1492 case CC0
: return cc0_rtx
;
1495 return consolidate_reg (x
);
1498 return gen_rtx_CONST_INT (GET_MODE (x
), INTVAL (x
));
1507 /* Parse an rtx directive, including both the opening/closing parentheses,
1511 function_reader::parse_rtx ()
1513 require_char_ws ('(');
1514 struct md_name directive
;
1515 read_name (&directive
);
1517 = consolidate_singletons (read_rtx_code (directive
.string
));
1518 require_char_ws (')');
1523 /* Implementation of rtx_reader::postprocess for reading function dumps.
1524 Return the equivalent singleton rtx for X, if any, otherwise X. */
1527 function_reader::postprocess (rtx x
)
1529 return consolidate_singletons (x
);
1532 /* Implementation of rtx_reader::finalize_string for reading function dumps.
1533 Make a GC-managed copy of STRINGBUF. */
1536 function_reader::finalize_string (char *stringbuf
)
1538 return ggc_strdup (stringbuf
);
1541 /* Attempt to parse optional location information for insn INSN, as
1542 potentially written out by rtx_writer::print_rtx_operand_code_i.
1543 We look for a quoted string followed by a colon. */
1546 function_reader::maybe_read_location (rtx_insn
*insn
)
1548 file_location loc
= get_current_location ();
1550 /* Attempt to parse a quoted string. */
1551 int ch
= read_skip_spaces ();
1554 char *filename
= read_quoted_string ();
1556 struct md_name line_num
;
1557 read_name (&line_num
);
1558 add_fixup_source_location (loc
, insn
, filename
, atoi (line_num
.string
));
1564 /* Postprocessing subroutine of function_reader::parse_function.
1565 Populate m_insns_by_uid. */
1568 function_reader::handle_insn_uids ()
1570 /* Locate the currently assigned INSN_UID values, storing
1571 them in m_insns_by_uid. */
1573 for (rtx_insn
*insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
1575 if (m_insns_by_uid
.get (INSN_UID (insn
)))
1576 error ("duplicate insn UID: %i", INSN_UID (insn
));
1577 m_insns_by_uid
.put (INSN_UID (insn
), insn
);
1578 if (INSN_UID (insn
) > max_uid
)
1579 max_uid
= INSN_UID (insn
);
1582 /* Ensure x_cur_insn_uid is 1 more than the biggest insn UID seen.
1583 This is normally updated by the various make_*insn_raw functions. */
1584 crtl
->emit
.x_cur_insn_uid
= max_uid
+ 1;
1587 /* Apply all of the recorded fixups. */
1590 function_reader::apply_fixups ()
1594 FOR_EACH_VEC_ELT (m_fixups
, i
, f
)
1598 /* Given a UID value, try to locate a pointer to the corresponding
1599 rtx_insn *, or NULL if if can't be found. */
1602 function_reader::get_insn_by_uid (int uid
)
1604 return m_insns_by_uid
.get (uid
);
1607 /* Run the RTL dump parser, parsing a dump located at PATH.
1608 Return true iff the file was successfully parsed. */
1611 read_rtl_function_body (const char *path
)
1615 init_varasm_status ();
1617 function_reader reader
;
1618 if (!reader
.read_file (path
))
1624 /* Run the RTL dump parser on the range of lines between START_LOC and
1625 END_LOC (including those lines). */
1628 read_rtl_function_body_from_file_range (location_t start_loc
,
1631 expanded_location exploc_start
= expand_location (start_loc
);
1632 expanded_location exploc_end
= expand_location (end_loc
);
1634 if (exploc_start
.file
!= exploc_end
.file
)
1636 error_at (end_loc
, "start/end of RTL fragment are in different files");
1639 if (exploc_start
.line
>= exploc_end
.line
)
1642 "start of RTL fragment must be on an earlier line than end");
1648 init_varasm_status ();
1650 function_reader reader
;
1651 if (!reader
.read_file_fragment (exploc_start
.file
, exploc_start
.line
,
1652 exploc_end
.line
- 1))
1660 namespace selftest
{
1662 /* Verify that parse_edge_flags works. */
1667 /* parse_edge_flags modifies its input (due to strtok), so we must make
1668 a copy of the literals. */
1669 #define ASSERT_PARSE_EDGE_FLAGS(EXPECTED, STR) \
1671 char *str = xstrdup (STR); \
1672 ASSERT_EQ (EXPECTED, parse_edge_flags (str)); \
1676 ASSERT_PARSE_EDGE_FLAGS (0, "");
1677 ASSERT_PARSE_EDGE_FLAGS (EDGE_FALLTHRU
, "FALLTHRU");
1678 ASSERT_PARSE_EDGE_FLAGS (EDGE_ABNORMAL_CALL
, "ABNORMAL_CALL");
1679 ASSERT_PARSE_EDGE_FLAGS (EDGE_ABNORMAL
| EDGE_ABNORMAL_CALL
,
1680 "ABNORMAL | ABNORMAL_CALL");
1682 #undef ASSERT_PARSE_EDGE_FLAGS
1685 /* Verify that lookup_reg_by_dump_name works. */
1688 test_parsing_regnos ()
1690 ASSERT_EQ (-1, lookup_reg_by_dump_name ("this is not a register"));
1692 /* Verify lookup of virtual registers. */
1693 ASSERT_EQ (VIRTUAL_INCOMING_ARGS_REGNUM
,
1694 lookup_reg_by_dump_name ("virtual-incoming-args"));
1695 ASSERT_EQ (VIRTUAL_STACK_VARS_REGNUM
,
1696 lookup_reg_by_dump_name ("virtual-stack-vars"));
1697 ASSERT_EQ (VIRTUAL_STACK_DYNAMIC_REGNUM
,
1698 lookup_reg_by_dump_name ("virtual-stack-dynamic"));
1699 ASSERT_EQ (VIRTUAL_OUTGOING_ARGS_REGNUM
,
1700 lookup_reg_by_dump_name ("virtual-outgoing-args"));
1701 ASSERT_EQ (VIRTUAL_CFA_REGNUM
,
1702 lookup_reg_by_dump_name ("virtual-cfa"));
1703 ASSERT_EQ (VIRTUAL_PREFERRED_STACK_BOUNDARY_REGNUM
,
1704 lookup_reg_by_dump_name ("virtual-preferred-stack-boundary"));
1706 /* Verify lookup of non-virtual pseudos. */
1707 ASSERT_EQ (LAST_VIRTUAL_REGISTER
+ 1, lookup_reg_by_dump_name ("<0>"));
1708 ASSERT_EQ (LAST_VIRTUAL_REGISTER
+ 2, lookup_reg_by_dump_name ("<1>"));
1711 /* Verify that edge E is as expected, with the src and dest basic blocks
1712 having indices EXPECTED_SRC_IDX and EXPECTED_DEST_IDX respectively, and
1713 the edge having flags equal to EXPECTED_FLAGS.
1714 Use LOC as the effective location when reporting failures. */
1717 assert_edge_at (const location
&loc
, edge e
, int expected_src_idx
,
1718 int expected_dest_idx
, int expected_flags
)
1720 ASSERT_EQ_AT (loc
, expected_src_idx
, e
->src
->index
);
1721 ASSERT_EQ_AT (loc
, expected_dest_idx
, e
->dest
->index
);
1722 ASSERT_EQ_AT (loc
, expected_flags
, e
->flags
);
1725 /* Verify that edge EDGE is as expected, with the src and dest basic blocks
1726 having indices EXPECTED_SRC_IDX and EXPECTED_DEST_IDX respectively, and
1727 the edge having flags equal to EXPECTED_FLAGS. */
1729 #define ASSERT_EDGE(EDGE, EXPECTED_SRC_IDX, EXPECTED_DEST_IDX, \
1731 assert_edge_at (SELFTEST_LOCATION, EDGE, EXPECTED_SRC_IDX, \
1732 EXPECTED_DEST_IDX, EXPECTED_FLAGS)
1734 /* Verify that we can load RTL dumps. */
1737 test_loading_dump_fragment_1 ()
1739 // TODO: filter on target?
1740 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("asr_div1.rtl"));
1742 /* Verify that the insns were loaded correctly. */
1743 rtx_insn
*insn_1
= get_insns ();
1744 ASSERT_TRUE (insn_1
);
1745 ASSERT_EQ (1, INSN_UID (insn_1
));
1746 ASSERT_EQ (INSN
, GET_CODE (insn_1
));
1747 ASSERT_EQ (SET
, GET_CODE (PATTERN (insn_1
)));
1748 ASSERT_EQ (NULL
, PREV_INSN (insn_1
));
1750 rtx_insn
*insn_2
= NEXT_INSN (insn_1
);
1751 ASSERT_TRUE (insn_2
);
1752 ASSERT_EQ (2, INSN_UID (insn_2
));
1753 ASSERT_EQ (INSN
, GET_CODE (insn_2
));
1754 ASSERT_EQ (insn_1
, PREV_INSN (insn_2
));
1755 ASSERT_EQ (NULL
, NEXT_INSN (insn_2
));
1757 /* Verify that registers were loaded correctly. */
1758 rtx insn_1_dest
= SET_DEST (PATTERN (insn_1
));
1759 ASSERT_EQ (REG
, GET_CODE (insn_1_dest
));
1760 ASSERT_EQ ((LAST_VIRTUAL_REGISTER
+ 1) + 2, REGNO (insn_1_dest
));
1761 rtx insn_1_src
= SET_SRC (PATTERN (insn_1
));
1762 ASSERT_EQ (LSHIFTRT
, GET_CODE (insn_1_src
));
1763 rtx reg
= XEXP (insn_1_src
, 0);
1764 ASSERT_EQ (REG
, GET_CODE (reg
));
1765 ASSERT_EQ (LAST_VIRTUAL_REGISTER
+ 1, REGNO (reg
));
1767 /* Verify that get_insn_by_uid works. */
1768 ASSERT_EQ (insn_1
, get_insn_by_uid (1));
1769 ASSERT_EQ (insn_2
, get_insn_by_uid (2));
1771 /* Verify that basic blocks were created. */
1772 ASSERT_EQ (2, BLOCK_FOR_INSN (insn_1
)->index
);
1773 ASSERT_EQ (2, BLOCK_FOR_INSN (insn_2
)->index
);
1775 /* Verify that the CFG was recreated. */
1777 verify_three_block_rtl_cfg (cfun
);
1778 basic_block bb2
= BASIC_BLOCK_FOR_FN (cfun
, 2);
1779 ASSERT_TRUE (bb2
!= NULL
);
1780 ASSERT_EQ (BB_RTL
, bb2
->flags
& BB_RTL
);
1781 ASSERT_EQ (2, bb2
->index
);
1782 ASSERT_EQ (insn_1
, BB_HEAD (bb2
));
1783 ASSERT_EQ (insn_2
, BB_END (bb2
));
1786 /* Verify loading another RTL dump. */
1789 test_loading_dump_fragment_2 ()
1791 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("simple-cse.rtl"));
1793 rtx_insn
*insn_1
= get_insn_by_uid (1);
1794 rtx_insn
*insn_2
= get_insn_by_uid (2);
1795 rtx_insn
*insn_3
= get_insn_by_uid (3);
1797 rtx set1
= single_set (insn_1
);
1798 ASSERT_NE (NULL
, set1
);
1799 rtx set2
= single_set (insn_2
);
1800 ASSERT_NE (NULL
, set2
);
1801 rtx set3
= single_set (insn_3
);
1802 ASSERT_NE (NULL
, set3
);
1804 rtx src1
= SET_SRC (set1
);
1805 ASSERT_EQ (PLUS
, GET_CODE (src1
));
1807 rtx src2
= SET_SRC (set2
);
1808 ASSERT_EQ (PLUS
, GET_CODE (src2
));
1810 /* Both src1 and src2 refer to "(reg:SI %0)".
1811 Verify that we have pointer equality. */
1812 rtx lhs1
= XEXP (src1
, 0);
1813 rtx lhs2
= XEXP (src2
, 0);
1814 ASSERT_EQ (lhs1
, lhs2
);
1816 /* Verify that the CFG was recreated. */
1818 verify_three_block_rtl_cfg (cfun
);
1821 /* Verify that CODE_LABEL insns are loaded correctly. */
1824 test_loading_labels ()
1826 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("example-labels.rtl"));
1828 rtx_insn
*insn_100
= get_insn_by_uid (100);
1829 ASSERT_EQ (CODE_LABEL
, GET_CODE (insn_100
));
1830 ASSERT_EQ (100, INSN_UID (insn_100
));
1831 ASSERT_EQ (NULL
, LABEL_NAME (insn_100
));
1832 ASSERT_EQ (0, LABEL_NUSES (insn_100
));
1833 ASSERT_EQ (30, CODE_LABEL_NUMBER (insn_100
));
1835 rtx_insn
*insn_200
= get_insn_by_uid (200);
1836 ASSERT_EQ (CODE_LABEL
, GET_CODE (insn_200
));
1837 ASSERT_EQ (200, INSN_UID (insn_200
));
1838 ASSERT_STREQ ("some_label_name", LABEL_NAME (insn_200
));
1839 ASSERT_EQ (0, LABEL_NUSES (insn_200
));
1840 ASSERT_EQ (40, CODE_LABEL_NUMBER (insn_200
));
1842 /* Ensure that the presence of CODE_LABEL_NUMBER == 40
1843 means that the next label num to be handed out will be 41. */
1844 ASSERT_EQ (41, max_label_num ());
1846 /* Ensure that label names read from a dump are GC-managed
1847 and are found through the insn. */
1848 forcibly_ggc_collect ();
1849 ASSERT_TRUE (ggc_marked_p (insn_200
));
1850 ASSERT_TRUE (ggc_marked_p (LABEL_NAME (insn_200
)));
1853 /* Verify that the loader copes with an insn with a mode. */
1856 test_loading_insn_with_mode ()
1858 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("insn-with-mode.rtl"));
1859 rtx_insn
*insn
= get_insns ();
1860 ASSERT_EQ (INSN
, GET_CODE (insn
));
1862 /* Verify that the "TI" mode was set from "insn:TI". */
1863 ASSERT_EQ (TImode
, GET_MODE (insn
));
1866 /* Verify that the loader copes with a jump_insn to a label_ref. */
1869 test_loading_jump_to_label_ref ()
1871 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("jump-to-label-ref.rtl"));
1873 rtx_insn
*jump_insn
= get_insn_by_uid (1);
1874 ASSERT_EQ (JUMP_INSN
, GET_CODE (jump_insn
));
1876 rtx_insn
*barrier
= get_insn_by_uid (2);
1877 ASSERT_EQ (BARRIER
, GET_CODE (barrier
));
1879 rtx_insn
*code_label
= get_insn_by_uid (100);
1880 ASSERT_EQ (CODE_LABEL
, GET_CODE (code_label
));
1882 /* Verify the jump_insn. */
1883 ASSERT_EQ (4, BLOCK_FOR_INSN (jump_insn
)->index
);
1884 ASSERT_EQ (SET
, GET_CODE (PATTERN (jump_insn
)));
1885 /* Ensure that the "(pc)" is using the global singleton. */
1886 ASSERT_RTX_PTR_EQ (pc_rtx
, SET_DEST (PATTERN (jump_insn
)));
1887 rtx label_ref
= SET_SRC (PATTERN (jump_insn
));
1888 ASSERT_EQ (LABEL_REF
, GET_CODE (label_ref
));
1889 ASSERT_EQ (code_label
, label_ref_label (label_ref
));
1890 ASSERT_EQ (code_label
, JUMP_LABEL (jump_insn
));
1892 /* Verify the code_label. */
1893 ASSERT_EQ (5, BLOCK_FOR_INSN (code_label
)->index
);
1894 ASSERT_EQ (NULL
, LABEL_NAME (code_label
));
1895 ASSERT_EQ (1, LABEL_NUSES (code_label
));
1897 /* Verify the generated CFG. */
1899 /* Locate blocks. */
1900 basic_block entry
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
1901 ASSERT_TRUE (entry
!= NULL
);
1902 ASSERT_EQ (ENTRY_BLOCK
, entry
->index
);
1904 basic_block exit
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
1905 ASSERT_TRUE (exit
!= NULL
);
1906 ASSERT_EQ (EXIT_BLOCK
, exit
->index
);
1908 basic_block bb4
= (*cfun
->cfg
->x_basic_block_info
)[4];
1909 basic_block bb5
= (*cfun
->cfg
->x_basic_block_info
)[5];
1910 ASSERT_EQ (4, bb4
->index
);
1911 ASSERT_EQ (5, bb5
->index
);
1914 ASSERT_EQ (NULL
, entry
->preds
);
1915 ASSERT_EQ (1, entry
->succs
->length ());
1916 ASSERT_EDGE ((*entry
->succs
)[0], 0, 4, EDGE_FALLTHRU
);
1919 ASSERT_EQ (1, bb4
->preds
->length ());
1920 ASSERT_EDGE ((*bb4
->preds
)[0], 0, 4, EDGE_FALLTHRU
);
1921 ASSERT_EQ (1, bb4
->succs
->length ());
1922 ASSERT_EDGE ((*bb4
->succs
)[0], 4, 5, 0x0);
1925 ASSERT_EQ (1, bb5
->preds
->length ());
1926 ASSERT_EDGE ((*bb5
->preds
)[0], 4, 5, 0x0);
1927 ASSERT_EQ (1, bb5
->succs
->length ());
1928 ASSERT_EDGE ((*bb5
->succs
)[0], 5, 1, EDGE_FALLTHRU
);
1931 ASSERT_EQ (1, exit
->preds
->length ());
1932 ASSERT_EDGE ((*exit
->preds
)[0], 5, 1, EDGE_FALLTHRU
);
1933 ASSERT_EQ (NULL
, exit
->succs
);
1936 /* Verify that the loader copes with a jump_insn to a label_ref
1940 test_loading_jump_to_return ()
1942 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("jump-to-return.rtl"));
1944 rtx_insn
*jump_insn
= get_insn_by_uid (1);
1945 ASSERT_EQ (JUMP_INSN
, GET_CODE (jump_insn
));
1946 ASSERT_RTX_PTR_EQ (ret_rtx
, JUMP_LABEL (jump_insn
));
1949 /* Verify that the loader copes with a jump_insn to a label_ref
1950 marked "simple_return". */
1953 test_loading_jump_to_simple_return ()
1955 rtl_dump_test
t (SELFTEST_LOCATION
,
1956 locate_file ("jump-to-simple-return.rtl"));
1958 rtx_insn
*jump_insn
= get_insn_by_uid (1);
1959 ASSERT_EQ (JUMP_INSN
, GET_CODE (jump_insn
));
1960 ASSERT_RTX_PTR_EQ (simple_return_rtx
, JUMP_LABEL (jump_insn
));
1963 /* Verify that the loader copes with a NOTE_INSN_BASIC_BLOCK. */
1966 test_loading_note_insn_basic_block ()
1968 rtl_dump_test
t (SELFTEST_LOCATION
,
1969 locate_file ("note_insn_basic_block.rtl"));
1971 rtx_insn
*note
= get_insn_by_uid (1);
1972 ASSERT_EQ (NOTE
, GET_CODE (note
));
1973 ASSERT_EQ (2, BLOCK_FOR_INSN (note
)->index
);
1975 ASSERT_EQ (NOTE_INSN_BASIC_BLOCK
, NOTE_KIND (note
));
1976 ASSERT_EQ (2, NOTE_BASIC_BLOCK (note
)->index
);
1977 ASSERT_EQ (BASIC_BLOCK_FOR_FN (cfun
, 2), NOTE_BASIC_BLOCK (note
));
1980 /* Verify that the loader copes with a NOTE_INSN_DELETED. */
1983 test_loading_note_insn_deleted ()
1985 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("note-insn-deleted.rtl"));
1987 rtx_insn
*note
= get_insn_by_uid (1);
1988 ASSERT_EQ (NOTE
, GET_CODE (note
));
1989 ASSERT_EQ (NOTE_INSN_DELETED
, NOTE_KIND (note
));
1992 /* Verify that the const_int values are consolidated, since
1993 pointer equality corresponds to value equality.
1994 TODO: do this for all in CASE_CONST_UNIQUE. */
1997 test_loading_const_int ()
1999 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("const-int.rtl"));
2001 /* Verify that const_int values below MAX_SAVED_CONST_INT use
2002 the global values. */
2003 ASSERT_EQ (const0_rtx
, SET_SRC (PATTERN (get_insn_by_uid (1))));
2004 ASSERT_EQ (const1_rtx
, SET_SRC (PATTERN (get_insn_by_uid (2))));
2005 ASSERT_EQ (constm1_rtx
, SET_SRC (PATTERN (get_insn_by_uid (3))));
2007 /* Verify that other const_int values are consolidated. */
2008 rtx int256
= gen_rtx_CONST_INT (SImode
, 256);
2009 ASSERT_EQ (int256
, SET_SRC (PATTERN (get_insn_by_uid (4))));
2012 /* Verify that the loader copes with a SYMBOL_REF. */
2015 test_loading_symbol_ref ()
2017 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("symbol-ref.rtl"));
2019 rtx_insn
*insn
= get_insns ();
2021 rtx high
= SET_SRC (PATTERN (insn
));
2022 ASSERT_EQ (HIGH
, GET_CODE (high
));
2024 rtx symbol_ref
= XEXP (high
, 0);
2025 ASSERT_EQ (SYMBOL_REF
, GET_CODE (symbol_ref
));
2027 /* Verify that "[flags 0xc0]" was parsed. */
2028 ASSERT_EQ (0xc0, SYMBOL_REF_FLAGS (symbol_ref
));
2029 /* TODO: we don't yet load SYMBOL_REF_DECL. */
2032 /* Verify that the loader can rebuild a CFG. */
2037 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("cfg-test.rtl"));
2039 ASSERT_STREQ ("cfg_test", IDENTIFIER_POINTER (DECL_NAME (cfun
->decl
)));
2043 ASSERT_TRUE (cfun
->cfg
!= NULL
);
2044 ASSERT_EQ (6, n_basic_blocks_for_fn (cfun
));
2045 ASSERT_EQ (6, n_edges_for_fn (cfun
));
2047 /* The "fake" basic blocks. */
2048 basic_block entry
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
2049 ASSERT_TRUE (entry
!= NULL
);
2050 ASSERT_EQ (ENTRY_BLOCK
, entry
->index
);
2052 basic_block exit
= EXIT_BLOCK_PTR_FOR_FN (cfun
);
2053 ASSERT_TRUE (exit
!= NULL
);
2054 ASSERT_EQ (EXIT_BLOCK
, exit
->index
);
2056 /* The "real" basic blocks. */
2057 basic_block bb2
= (*cfun
->cfg
->x_basic_block_info
)[2];
2058 basic_block bb3
= (*cfun
->cfg
->x_basic_block_info
)[3];
2059 basic_block bb4
= (*cfun
->cfg
->x_basic_block_info
)[4];
2060 basic_block bb5
= (*cfun
->cfg
->x_basic_block_info
)[5];
2062 ASSERT_EQ (2, bb2
->index
);
2063 ASSERT_EQ (3, bb3
->index
);
2064 ASSERT_EQ (4, bb4
->index
);
2065 ASSERT_EQ (5, bb5
->index
);
2067 /* Verify connectivity. */
2070 ASSERT_EQ (NULL
, entry
->preds
);
2071 ASSERT_EQ (1, entry
->succs
->length ());
2072 ASSERT_EDGE ((*entry
->succs
)[0], 0, 2, EDGE_FALLTHRU
);
2075 ASSERT_EQ (1, bb2
->preds
->length ());
2076 ASSERT_EDGE ((*bb2
->preds
)[0], 0, 2, EDGE_FALLTHRU
);
2077 ASSERT_EQ (2, bb2
->succs
->length ());
2078 ASSERT_EDGE ((*bb2
->succs
)[0], 2, 3, EDGE_TRUE_VALUE
);
2079 ASSERT_EDGE ((*bb2
->succs
)[1], 2, 4, EDGE_FALSE_VALUE
);
2082 ASSERT_EQ (1, bb3
->preds
->length ());
2083 ASSERT_EDGE ((*bb3
->preds
)[0], 2, 3, EDGE_TRUE_VALUE
);
2084 ASSERT_EQ (1, bb3
->succs
->length ());
2085 ASSERT_EDGE ((*bb3
->succs
)[0], 3, 5, EDGE_FALLTHRU
);
2088 ASSERT_EQ (1, bb4
->preds
->length ());
2089 ASSERT_EDGE ((*bb4
->preds
)[0], 2, 4, EDGE_FALSE_VALUE
);
2090 ASSERT_EQ (1, bb4
->succs
->length ());
2091 ASSERT_EDGE ((*bb4
->succs
)[0], 4, 5, EDGE_FALLTHRU
);
2094 ASSERT_EQ (2, bb5
->preds
->length ());
2095 ASSERT_EDGE ((*bb5
->preds
)[0], 3, 5, EDGE_FALLTHRU
);
2096 ASSERT_EDGE ((*bb5
->preds
)[1], 4, 5, EDGE_FALLTHRU
);
2097 ASSERT_EQ (1, bb5
->succs
->length ());
2098 ASSERT_EDGE ((*bb5
->succs
)[0], 5, 1, EDGE_FALLTHRU
);
2101 ASSERT_EQ (1, exit
->preds
->length ());
2102 ASSERT_EDGE ((*exit
->preds
)[0], 5, 1, EDGE_FALLTHRU
);
2103 ASSERT_EQ (NULL
, exit
->succs
);
2106 /* Verify that the loader copes with sparse block indices.
2107 This testcase loads a file with a "(block 42)". */
2110 test_loading_bb_index ()
2112 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("bb-index.rtl"));
2114 ASSERT_STREQ ("test_bb_index", IDENTIFIER_POINTER (DECL_NAME (cfun
->decl
)));
2118 ASSERT_TRUE (cfun
->cfg
!= NULL
);
2119 ASSERT_EQ (3, n_basic_blocks_for_fn (cfun
));
2120 ASSERT_EQ (43, basic_block_info_for_fn (cfun
)->length ());
2121 ASSERT_EQ (2, n_edges_for_fn (cfun
));
2123 ASSERT_EQ (NULL
, (*cfun
->cfg
->x_basic_block_info
)[41]);
2124 basic_block bb42
= (*cfun
->cfg
->x_basic_block_info
)[42];
2125 ASSERT_NE (NULL
, bb42
);
2126 ASSERT_EQ (42, bb42
->index
);
2129 /* Verify that function_reader::handle_any_trailing_information correctly
2130 parses all the possible items emitted for a MEM. */
2135 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("mem.rtl"));
2137 ASSERT_STREQ ("test_mem", IDENTIFIER_POINTER (DECL_NAME (cfun
->decl
)));
2140 /* Verify parsing of "[42 i+17 S8 A128 AS5]". */
2141 rtx_insn
*insn_1
= get_insn_by_uid (1);
2142 rtx set1
= single_set (insn_1
);
2143 rtx mem1
= SET_DEST (set1
);
2144 ASSERT_EQ (42, MEM_ALIAS_SET (mem1
));
2146 ASSERT_TRUE (MEM_OFFSET_KNOWN_P (mem1
));
2147 ASSERT_KNOWN_EQ (17, MEM_OFFSET (mem1
));
2149 ASSERT_KNOWN_EQ (8, MEM_SIZE (mem1
));
2151 ASSERT_EQ (128, MEM_ALIGN (mem1
));
2153 ASSERT_EQ (5, MEM_ADDR_SPACE (mem1
));
2155 /* Verify parsing of "43 i+18 S9 AS6"
2156 (an address space without an alignment). */
2157 rtx_insn
*insn_2
= get_insn_by_uid (2);
2158 rtx set2
= single_set (insn_2
);
2159 rtx mem2
= SET_DEST (set2
);
2160 ASSERT_EQ (43, MEM_ALIAS_SET (mem2
));
2162 ASSERT_TRUE (MEM_OFFSET_KNOWN_P (mem2
));
2163 ASSERT_KNOWN_EQ (18, MEM_OFFSET (mem2
));
2165 ASSERT_KNOWN_EQ (9, MEM_SIZE (mem2
));
2167 ASSERT_EQ (6, MEM_ADDR_SPACE (mem2
));
2170 /* Verify that "repeated xN" is read correctly. */
2173 test_loading_repeat ()
2175 rtl_dump_test
t (SELFTEST_LOCATION
, locate_file ("repeat.rtl"));
2177 rtx_insn
*insn_1
= get_insn_by_uid (1);
2178 ASSERT_EQ (PARALLEL
, GET_CODE (PATTERN (insn_1
)));
2179 ASSERT_EQ (64, XVECLEN (PATTERN (insn_1
), 0));
2180 for (int i
= 0; i
< 64; i
++)
2181 ASSERT_EQ (const0_rtx
, XVECEXP (PATTERN (insn_1
), 0, i
));
2184 /* Run all of the selftests within this file. */
2187 read_rtl_function_c_tests ()
2190 test_parsing_regnos ();
2191 test_loading_dump_fragment_1 ();
2192 test_loading_dump_fragment_2 ();
2193 test_loading_labels ();
2194 test_loading_insn_with_mode ();
2195 test_loading_jump_to_label_ref ();
2196 test_loading_jump_to_return ();
2197 test_loading_jump_to_simple_return ();
2198 test_loading_note_insn_basic_block ();
2199 test_loading_note_insn_deleted ();
2200 test_loading_const_int ();
2201 test_loading_symbol_ref ();
2202 test_loading_cfg ();
2203 test_loading_bb_index ();
2204 test_loading_mem ();
2205 test_loading_repeat ();
2208 } // namespace selftest
2210 #endif /* #if CHECKING_P */