1 | /* Print RTL functions for GCC. |
2 | Copyright (C) 2016-2023 Free Software Foundation, Inc. |
3 | |
4 | This file is part of GCC. |
5 | |
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 |
9 | version. |
10 | |
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 |
14 | for more details. |
15 | |
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/>. */ |
19 | |
20 | #include "config.h" |
21 | #include "system.h" |
22 | #include "coretypes.h" |
23 | #include "tm.h" |
24 | #include "rtl.h" |
25 | #include "alias.h" |
26 | #include "tree.h" |
27 | #include "flags.h" |
28 | #include "predict.h" |
29 | #include "function.h" |
30 | #include "basic-block.h" |
31 | #include "print-rtl.h" |
32 | #include "langhooks.h" |
33 | #include "memmodel.h" |
34 | #include "emit-rtl.h" |
35 | #include "varasm.h" |
36 | |
37 | /* Print an "(edge-from)" or "(edge-to)" directive describing E |
38 | to OUTFILE. */ |
39 | |
40 | static void |
41 | print_edge (FILE *outfile, edge e, bool from) |
42 | { |
43 | fprintf (stream: outfile, format: " (%s " , from ? "edge-from" : "edge-to" ); |
44 | basic_block bb = from ? e->src : e->dest; |
45 | gcc_assert (bb); |
46 | switch (bb->index) |
47 | { |
48 | case ENTRY_BLOCK: |
49 | fprintf (stream: outfile, format: "entry" ); |
50 | break; |
51 | case EXIT_BLOCK: |
52 | fprintf (stream: outfile, format: "exit" ); |
53 | break; |
54 | default: |
55 | fprintf (stream: outfile, format: "%i" , bb->index); |
56 | break; |
57 | } |
58 | |
59 | /* Express edge flags as a string with " | " separator. |
60 | e.g. (flags "FALLTHRU | DFS_BACK"). */ |
61 | if (e->flags) |
62 | { |
63 | fprintf (stream: outfile, format: " (flags \"" ); |
64 | bool seen_flag = false; |
65 | #define DEF_EDGE_FLAG(NAME,IDX) \ |
66 | do { \ |
67 | if (e->flags & EDGE_##NAME) \ |
68 | { \ |
69 | if (seen_flag) \ |
70 | fprintf (outfile, " | "); \ |
71 | fprintf (outfile, "%s", (#NAME)); \ |
72 | seen_flag = true; \ |
73 | } \ |
74 | } while (0); |
75 | #include "cfg-flags.def" |
76 | #undef DEF_EDGE_FLAG |
77 | |
78 | fprintf (stream: outfile, format: "\")" ); |
79 | } |
80 | |
81 | fprintf (stream: outfile, format: ")\n" ); |
82 | } |
83 | |
84 | /* If BB is non-NULL, print the start of a "(block)" directive for it |
85 | to OUTFILE, otherwise do nothing. */ |
86 | |
87 | static void |
88 | begin_any_block (FILE *outfile, basic_block bb) |
89 | { |
90 | if (!bb) |
91 | return; |
92 | |
93 | edge e; |
94 | edge_iterator ei; |
95 | |
96 | fprintf (stream: outfile, format: " (block %i\n" , bb->index); |
97 | FOR_EACH_EDGE (e, ei, bb->preds) |
98 | print_edge (outfile, e, from: true); |
99 | } |
100 | |
101 | /* If BB is non-NULL, print the end of a "(block)" directive for it |
102 | to OUTFILE, otherwise do nothing. */ |
103 | |
104 | static void |
105 | end_any_block (FILE *outfile, basic_block bb) |
106 | { |
107 | if (!bb) |
108 | return; |
109 | |
110 | edge e; |
111 | edge_iterator ei; |
112 | |
113 | FOR_EACH_EDGE (e, ei, bb->succs) |
114 | print_edge (outfile, e, from: false); |
115 | fprintf (stream: outfile, format: " ) ;; block %i\n" , bb->index); |
116 | } |
117 | |
118 | /* Determine if INSN is of a kind that can have a basic block. */ |
119 | |
120 | static bool |
121 | can_have_basic_block_p (const rtx_insn *insn) |
122 | { |
123 | rtx_code code = GET_CODE (insn); |
124 | if (code == BARRIER) |
125 | return false; |
126 | gcc_assert (GET_RTX_FORMAT (code)[2] == 'B'); |
127 | return true; |
128 | } |
129 | |
130 | /* Subroutine of print_param. Write the name of ARG, if any, to OUTFILE. */ |
131 | |
132 | static void |
133 | print_any_param_name (FILE *outfile, tree arg) |
134 | { |
135 | if (DECL_NAME (arg)) |
136 | fprintf (stream: outfile, format: " \"%s\"" , IDENTIFIER_POINTER (DECL_NAME (arg))); |
137 | } |
138 | |
139 | /* Print a "(param)" directive for ARG to OUTFILE. */ |
140 | |
141 | static void |
142 | print_param (FILE *outfile, rtx_writer &w, tree arg) |
143 | { |
144 | fprintf (stream: outfile, format: " (param" ); |
145 | print_any_param_name (outfile, arg); |
146 | fprintf (stream: outfile, format: "\n" ); |
147 | |
148 | /* Print the value of DECL_RTL (without lazy-evaluation). */ |
149 | fprintf (stream: outfile, format: " (DECL_RTL " ); |
150 | w.print_rtx (DECL_RTL_IF_SET (arg)); |
151 | w.finish_directive (); |
152 | |
153 | /* Print DECL_INCOMING_RTL. */ |
154 | fprintf (stream: outfile, format: " (DECL_RTL_INCOMING " ); |
155 | w.print_rtx (DECL_INCOMING_RTL (arg)); |
156 | fprintf (stream: outfile, format: ")" ); |
157 | |
158 | w.finish_directive (); |
159 | } |
160 | |
161 | /* Write FN to OUTFILE in a form suitable for parsing, with indentation |
162 | and comments to make the structure easy for a human to grok. Track |
163 | the basic blocks of insns in the chain, wrapping those that are within |
164 | blocks within "(block)" directives. |
165 | |
166 | If COMPACT, then instructions are printed in a compact form: |
167 | - INSN_UIDs are omitted, except for jumps and CODE_LABELs, |
168 | - INSN_CODEs are omitted, |
169 | - register numbers are omitted for hard and virtual regs, and |
170 | non-virtual pseudos are offset relative to the first such reg, and |
171 | printed with a '%' sigil e.g. "%0" for (LAST_VIRTUAL_REGISTER + 1), |
172 | - insn names are prefixed with "c" (e.g. "cinsn", "cnote", etc) |
173 | |
174 | Example output (with COMPACT==true): |
175 | |
176 | (function "times_two" |
177 | (param "i" |
178 | (DECL_RTL (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars) |
179 | (const_int -4)) [1 i+0 S4 A32])) |
180 | (DECL_RTL_INCOMING (reg:SI di [ i ]))) |
181 | (insn-chain |
182 | (cnote 1 NOTE_INSN_DELETED) |
183 | (block 2 |
184 | (edge-from entry (flags "FALLTHRU")) |
185 | (cnote 4 [bb 2] NOTE_INSN_BASIC_BLOCK) |
186 | (cinsn 2 (set (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars) |
187 | (const_int -4)) [1 i+0 S4 A32]) |
188 | (reg:SI di [ i ])) "t.c":2) |
189 | (cnote 3 NOTE_INSN_FUNCTION_BEG) |
190 | (cinsn 6 (set (reg:SI <2>) |
191 | (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars) |
192 | (const_int -4)) [1 i+0 S4 A32])) "t.c":3) |
193 | (cinsn 7 (parallel [ |
194 | (set (reg:SI <0> [ _2 ]) |
195 | (ashift:SI (reg:SI <2>) |
196 | (const_int 1))) |
197 | (clobber (reg:CC flags)) |
198 | ]) "t.c":3 |
199 | (expr_list:REG_EQUAL (ashift:SI (mem/c:SI (plus:DI (reg/f:DI virtual-stack-vars) |
200 | (const_int -4)) [1 i+0 S4 A32]) |
201 | (const_int 1)))) |
202 | (cinsn 10 (set (reg:SI <1> [ <retval> ]) |
203 | (reg:SI <0> [ _2 ])) "t.c":3) |
204 | (cinsn 14 (set (reg/i:SI ax) |
205 | (reg:SI <1> [ <retval> ])) "t.c":4) |
206 | (cinsn 15 (use (reg/i:SI ax)) "t.c":4) |
207 | (edge-to exit (flags "FALLTHRU")) |
208 | ) ;; block 2 |
209 | ) ;; insn-chain |
210 | (crtl |
211 | (return_rtx |
212 | (reg/i:SI ax) |
213 | ) ;; return_rtx |
214 | ) ;; crtl |
215 | ) ;; function "times_two" |
216 | */ |
217 | |
218 | DEBUG_FUNCTION void |
219 | print_rtx_function (FILE *outfile, function *fn, bool compact) |
220 | { |
221 | rtx_reuse_manager r; |
222 | rtx_writer w (outfile, 0, false, compact, &r); |
223 | |
224 | /* Support "reuse_rtx" in the dump. */ |
225 | for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
226 | r.preprocess (x: insn); |
227 | |
228 | tree fdecl = fn->decl; |
229 | |
230 | const char *dname = lang_hooks.decl_printable_name (fdecl, 1); |
231 | |
232 | fprintf (stream: outfile, format: "(function \"%s\"\n" , dname); |
233 | |
234 | /* Params. */ |
235 | for (tree arg = DECL_ARGUMENTS (fdecl); arg; arg = DECL_CHAIN (arg)) |
236 | print_param (outfile, w, arg); |
237 | |
238 | /* The instruction chain. */ |
239 | fprintf (stream: outfile, format: " (insn-chain\n" ); |
240 | basic_block curr_bb = NULL; |
241 | for (rtx_insn *insn = get_insns (); insn; insn = NEXT_INSN (insn)) |
242 | { |
243 | basic_block insn_bb; |
244 | if (can_have_basic_block_p (insn)) |
245 | insn_bb = BLOCK_FOR_INSN (insn); |
246 | else |
247 | insn_bb = NULL; |
248 | if (curr_bb != insn_bb) |
249 | { |
250 | end_any_block (outfile, bb: curr_bb); |
251 | curr_bb = insn_bb; |
252 | begin_any_block (outfile, bb: curr_bb); |
253 | } |
254 | w.print_rtl_single_with_indent (x: insn, ind: curr_bb ? 6 : 4); |
255 | } |
256 | end_any_block (outfile, bb: curr_bb); |
257 | fprintf (stream: outfile, format: " ) ;; insn-chain\n" ); |
258 | |
259 | /* Additional RTL state. */ |
260 | fprintf (stream: outfile, format: " (crtl\n" ); |
261 | fprintf (stream: outfile, format: " (return_rtx \n" ); |
262 | w.print_rtl_single_with_indent (crtl->return_rtx, ind: 6); |
263 | fprintf (stream: outfile, format: " ) ;; return_rtx\n" ); |
264 | fprintf (stream: outfile, format: " ) ;; crtl\n" ); |
265 | |
266 | fprintf (stream: outfile, format: ") ;; function \"%s\"\n" , dname); |
267 | } |
268 | |