|
111
|
1 /* Definitions for the shared dumpfile.
|
|
131
|
2 Copyright (C) 2004-2018 Free Software Foundation, Inc.
|
|
111
|
3
|
|
|
4 This file is part of GCC.
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify
|
|
|
7 it under the terms of the GNU General Public License as published by
|
|
|
8 the Free Software Foundation; either version 3, or (at your option)
|
|
|
9 any later version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful,
|
|
|
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
14 GNU General Public License 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
|
|
|
21 #ifndef GCC_DUMPFILE_H
|
|
|
22 #define GCC_DUMPFILE_H 1
|
|
|
23
|
|
131
|
24 #include "profile-count.h"
|
|
|
25
|
|
|
26 /* An attribute for annotating formatting printing functions that use
|
|
|
27 the dumpfile/optinfo formatting codes. These are the pretty_printer
|
|
|
28 format codes (see pretty-print.c), with additional codes for middle-end
|
|
|
29 specific entities (see dumpfile.c). */
|
|
|
30
|
|
|
31 #if GCC_VERSION >= 9000
|
|
|
32 #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) \
|
|
|
33 __attribute__ ((__format__ (__gcc_dump_printf__, m ,n))) \
|
|
|
34 ATTRIBUTE_NONNULL(m)
|
|
|
35 #else
|
|
|
36 #define ATTRIBUTE_GCC_DUMP_PRINTF(m, n) ATTRIBUTE_NONNULL(m)
|
|
|
37 #endif
|
|
111
|
38
|
|
|
39 /* Different tree dump places. When you add new tree dump places,
|
|
|
40 extend the DUMP_FILES array in dumpfile.c. */
|
|
|
41 enum tree_dump_index
|
|
|
42 {
|
|
|
43 TDI_none, /* No dump */
|
|
|
44 TDI_cgraph, /* dump function call graph. */
|
|
|
45 TDI_inheritance, /* dump type inheritance graph. */
|
|
|
46 TDI_clones, /* dump IPA cloning decisions. */
|
|
|
47 TDI_original, /* dump each function before optimizing it */
|
|
|
48 TDI_gimple, /* dump each function after gimplifying it */
|
|
|
49 TDI_nested, /* dump each function after unnesting it */
|
|
131
|
50 TDI_lto_stream_out, /* dump information about lto streaming */
|
|
111
|
51
|
|
|
52 TDI_lang_all, /* enable all the language dumps. */
|
|
|
53 TDI_tree_all, /* enable all the GENERIC/GIMPLE dumps. */
|
|
|
54 TDI_rtl_all, /* enable all the RTL dumps. */
|
|
|
55 TDI_ipa_all, /* enable all the IPA dumps. */
|
|
|
56
|
|
|
57 TDI_end
|
|
|
58 };
|
|
|
59
|
|
|
60 /* Enum used to distinguish dump files to types. */
|
|
|
61
|
|
|
62 enum dump_kind
|
|
|
63 {
|
|
|
64 DK_none,
|
|
|
65 DK_lang,
|
|
|
66 DK_tree,
|
|
|
67 DK_rtl,
|
|
|
68 DK_ipa
|
|
|
69 };
|
|
|
70
|
|
|
71 /* Bit masks to control dumping. Not all values are applicable to all
|
|
|
72 dumps. Add new ones at the end. When you define new values, extend
|
|
|
73 the DUMP_OPTIONS array in dumpfile.c. The TDF_* flags coexist with
|
|
|
74 MSG_* flags (for -fopt-info) and the bit values must be chosen to
|
|
|
75 allow that. */
|
|
131
|
76 enum dump_flag
|
|
|
77 {
|
|
|
78 /* Value of TDF_NONE is used just for bits filtered by TDF_KIND_MASK. */
|
|
|
79 TDF_NONE = 0,
|
|
|
80
|
|
|
81 /* Dump node addresses. */
|
|
|
82 TDF_ADDRESS = (1 << 0),
|
|
|
83
|
|
|
84 /* Don't go wild following links. */
|
|
|
85 TDF_SLIM = (1 << 1),
|
|
|
86
|
|
|
87 /* Don't unparse the function. */
|
|
|
88 TDF_RAW = (1 << 2),
|
|
|
89
|
|
|
90 /* Show more detailed info about each pass. */
|
|
|
91 TDF_DETAILS = (1 << 3),
|
|
|
92
|
|
|
93 /* Dump various statistics about each pass. */
|
|
|
94 TDF_STATS = (1 << 4),
|
|
|
95
|
|
|
96 /* Display basic block boundaries. */
|
|
|
97 TDF_BLOCKS = (1 << 5),
|
|
|
98
|
|
|
99 /* Display virtual operands. */
|
|
|
100 TDF_VOPS = (1 << 6),
|
|
|
101
|
|
|
102 /* Display statement line numbers. */
|
|
|
103 TDF_LINENO = (1 << 7),
|
|
|
104
|
|
|
105 /* Display decl UIDs. */
|
|
|
106 TDF_UID = (1 << 8),
|
|
|
107
|
|
|
108 /* Address of stmt. */
|
|
|
109 TDF_STMTADDR = (1 << 9),
|
|
|
110
|
|
|
111 /* A graph dump is being emitted. */
|
|
|
112 TDF_GRAPH = (1 << 10),
|
|
111
|
113
|
|
131
|
114 /* Display memory symbols in expr.
|
|
|
115 Implies TDF_VOPS. */
|
|
|
116 TDF_MEMSYMS = (1 << 11),
|
|
|
117
|
|
|
118 /* A flag to only print the RHS of a gimple stmt. */
|
|
|
119 TDF_RHS_ONLY = (1 << 12),
|
|
|
120
|
|
|
121 /* Display asm names of decls. */
|
|
|
122 TDF_ASMNAME = (1 << 13),
|
|
|
123
|
|
|
124 /* Display EH region number holding this gimple statement. */
|
|
|
125 TDF_EH = (1 << 14),
|
|
|
126
|
|
|
127 /* Omit UIDs from dumps. */
|
|
|
128 TDF_NOUID = (1 << 15),
|
|
|
129
|
|
|
130 /* Display alias information. */
|
|
|
131 TDF_ALIAS = (1 << 16),
|
|
111
|
132
|
|
131
|
133 /* Enumerate locals by uid. */
|
|
|
134 TDF_ENUMERATE_LOCALS = (1 << 17),
|
|
|
135
|
|
|
136 /* Dump cselib details. */
|
|
|
137 TDF_CSELIB = (1 << 18),
|
|
|
138
|
|
|
139 /* Dump SCEV details. */
|
|
|
140 TDF_SCEV = (1 << 19),
|
|
|
141
|
|
|
142 /* Dump in GIMPLE FE syntax */
|
|
|
143 TDF_GIMPLE = (1 << 20),
|
|
|
144
|
|
|
145 /* Dump folding details. */
|
|
|
146 TDF_FOLDING = (1 << 21),
|
|
|
147
|
|
|
148 /* MSG_* flags for expressing the kinds of message to
|
|
|
149 be emitted by -fopt-info. */
|
|
|
150
|
|
|
151 /* -fopt-info optimized sources. */
|
|
|
152 MSG_OPTIMIZED_LOCATIONS = (1 << 22),
|
|
111
|
153
|
|
131
|
154 /* Missed opportunities. */
|
|
|
155 MSG_MISSED_OPTIMIZATION = (1 << 23),
|
|
|
156
|
|
|
157 /* General optimization info. */
|
|
|
158 MSG_NOTE = (1 << 24),
|
|
|
159
|
|
|
160 /* Mask for selecting MSG_-kind flags. */
|
|
|
161 MSG_ALL_KINDS = (MSG_OPTIMIZED_LOCATIONS
|
|
|
162 | MSG_MISSED_OPTIMIZATION
|
|
|
163 | MSG_NOTE),
|
|
|
164
|
|
|
165 /* MSG_PRIORITY_* flags for expressing the priority levels of message
|
|
|
166 to be emitted by -fopt-info, and filtering on them.
|
|
|
167 By default, messages at the top-level dump scope are "user-facing",
|
|
|
168 whereas those that are in nested scopes are implicitly "internals".
|
|
|
169 This behavior can be overridden for a given dump message by explicitly
|
|
|
170 specifying one of the MSG_PRIORITY_* flags.
|
|
|
171
|
|
|
172 By default, dump files show both kinds of message, whereas -fopt-info
|
|
|
173 only shows "user-facing" messages, and requires the "-internals"
|
|
|
174 sub-option of -fopt-info to show the internal messages. */
|
|
|
175
|
|
|
176 /* Implicitly supplied for messages at the top-level dump scope. */
|
|
|
177 MSG_PRIORITY_USER_FACING = (1 << 25),
|
|
|
178
|
|
|
179 /* Implicitly supplied for messages within nested dump scopes. */
|
|
|
180 MSG_PRIORITY_INTERNALS = (1 << 26),
|
|
|
181
|
|
|
182 /* Supplied when an opt_problem generated in a nested scope is re-emitted
|
|
|
183 at the top-level. We want to default to showing these in -fopt-info
|
|
|
184 output, but to *not* show them in dump files, as the message would be
|
|
|
185 shown twice, messing up "scan-tree-dump-times" in DejaGnu tests. */
|
|
|
186 MSG_PRIORITY_REEMITTED = (1 << 27),
|
|
|
187
|
|
|
188 /* Mask for selecting MSG_PRIORITY_* flags. */
|
|
|
189 MSG_ALL_PRIORITIES = (MSG_PRIORITY_USER_FACING
|
|
|
190 | MSG_PRIORITY_INTERNALS
|
|
|
191 | MSG_PRIORITY_REEMITTED),
|
|
111
|
192
|
|
131
|
193 /* Dumping for -fcompare-debug. */
|
|
|
194 TDF_COMPARE_DEBUG = (1 << 28),
|
|
111
|
195
|
|
131
|
196 /* All values. */
|
|
|
197 TDF_ALL_VALUES = (1 << 29) - 1
|
|
|
198 };
|
|
|
199
|
|
|
200 /* Dump flags type. */
|
|
|
201
|
|
|
202 typedef enum dump_flag dump_flags_t;
|
|
|
203
|
|
|
204 static inline dump_flags_t
|
|
|
205 operator| (dump_flags_t lhs, dump_flags_t rhs)
|
|
|
206 {
|
|
|
207 return (dump_flags_t)((int)lhs | (int)rhs);
|
|
|
208 }
|
|
|
209
|
|
|
210 static inline dump_flags_t
|
|
|
211 operator& (dump_flags_t lhs, dump_flags_t rhs)
|
|
|
212 {
|
|
|
213 return (dump_flags_t)((int)lhs & (int)rhs);
|
|
|
214 }
|
|
111
|
215
|
|
131
|
216 static inline dump_flags_t
|
|
|
217 operator~ (dump_flags_t flags)
|
|
|
218 {
|
|
|
219 return (dump_flags_t)~((int)flags);
|
|
|
220 }
|
|
|
221
|
|
|
222 static inline dump_flags_t &
|
|
|
223 operator|= (dump_flags_t &lhs, dump_flags_t rhs)
|
|
|
224 {
|
|
|
225 lhs = (dump_flags_t)((int)lhs | (int)rhs);
|
|
|
226 return lhs;
|
|
|
227 }
|
|
|
228
|
|
|
229 static inline dump_flags_t &
|
|
|
230 operator&= (dump_flags_t &lhs, dump_flags_t rhs)
|
|
|
231 {
|
|
|
232 lhs = (dump_flags_t)((int)lhs & (int)rhs);
|
|
|
233 return lhs;
|
|
|
234 }
|
|
111
|
235
|
|
|
236 /* Flags to control high-level -fopt-info dumps. Usually these flags
|
|
|
237 define a group of passes. An optimization pass can be part of
|
|
|
238 multiple groups. */
|
|
131
|
239
|
|
|
240 enum optgroup_flag
|
|
|
241 {
|
|
|
242 OPTGROUP_NONE = 0,
|
|
|
243
|
|
|
244 /* IPA optimization passes */
|
|
|
245 OPTGROUP_IPA = (1 << 1),
|
|
|
246
|
|
|
247 /* Loop optimization passes */
|
|
|
248 OPTGROUP_LOOP = (1 << 2),
|
|
|
249
|
|
|
250 /* Inlining passes */
|
|
|
251 OPTGROUP_INLINE = (1 << 3),
|
|
|
252
|
|
|
253 /* OMP (Offloading and Multi Processing) transformations */
|
|
|
254 OPTGROUP_OMP = (1 << 4),
|
|
|
255
|
|
|
256 /* Vectorization passes */
|
|
|
257 OPTGROUP_VEC = (1 << 5),
|
|
111
|
258
|
|
131
|
259 /* All other passes */
|
|
|
260 OPTGROUP_OTHER = (1 << 6),
|
|
|
261
|
|
|
262 OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
|
|
|
263 | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
|
|
|
264 };
|
|
|
265
|
|
|
266 typedef enum optgroup_flag optgroup_flags_t;
|
|
111
|
267
|
|
131
|
268 static inline optgroup_flags_t
|
|
|
269 operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
|
|
|
270 {
|
|
|
271 return (optgroup_flags_t)((int)lhs | (int)rhs);
|
|
|
272 }
|
|
|
273
|
|
|
274 static inline optgroup_flags_t &
|
|
|
275 operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
|
|
|
276 {
|
|
|
277 lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
|
|
|
278 return lhs;
|
|
|
279 }
|
|
111
|
280
|
|
|
281 /* Define a tree dump switch. */
|
|
|
282 struct dump_file_info
|
|
|
283 {
|
|
|
284 /* Suffix to give output file. */
|
|
|
285 const char *suffix;
|
|
|
286 /* Command line dump switch. */
|
|
|
287 const char *swtch;
|
|
|
288 /* Command line glob. */
|
|
|
289 const char *glob;
|
|
|
290 /* Filename for the pass-specific stream. */
|
|
|
291 const char *pfilename;
|
|
|
292 /* Filename for the -fopt-info stream. */
|
|
|
293 const char *alt_filename;
|
|
|
294 /* Pass-specific dump stream. */
|
|
|
295 FILE *pstream;
|
|
|
296 /* -fopt-info stream. */
|
|
|
297 FILE *alt_stream;
|
|
|
298 /* Dump kind. */
|
|
|
299 dump_kind dkind;
|
|
|
300 /* Dump flags. */
|
|
|
301 dump_flags_t pflags;
|
|
|
302 /* A pass flags for -fopt-info. */
|
|
131
|
303 dump_flags_t alt_flags;
|
|
111
|
304 /* Flags for -fopt-info given by a user. */
|
|
131
|
305 optgroup_flags_t optgroup_flags;
|
|
111
|
306 /* State of pass-specific stream. */
|
|
|
307 int pstate;
|
|
|
308 /* State of the -fopt-info stream. */
|
|
|
309 int alt_state;
|
|
|
310 /* Dump file number. */
|
|
|
311 int num;
|
|
|
312 /* Fields "suffix", "swtch", "glob" can be const strings,
|
|
|
313 or can be dynamically allocated, needing free. */
|
|
|
314 bool owns_strings;
|
|
|
315 /* When a given dump file is being initialized, this flag is set to true
|
|
|
316 if the corresponding TDF_graph dump file has also been initialized. */
|
|
|
317 bool graph_dump_initialized;
|
|
|
318 };
|
|
|
319
|
|
131
|
320 /* A class for describing where in the user's source that a dump message
|
|
|
321 relates to, with various constructors for convenience.
|
|
|
322 In particular, this lets us associate dump messages
|
|
|
323 with hotness information (e.g. from PGO), allowing them to
|
|
|
324 be prioritized by code hotness. */
|
|
|
325
|
|
|
326 class dump_user_location_t
|
|
|
327 {
|
|
|
328 public:
|
|
|
329 /* Default constructor, analogous to UNKNOWN_LOCATION. */
|
|
|
330 dump_user_location_t () : m_count (), m_loc (UNKNOWN_LOCATION) {}
|
|
|
331
|
|
|
332 /* Construct from a gimple statement (using its location and hotness). */
|
|
|
333 dump_user_location_t (const gimple *stmt);
|
|
|
334
|
|
|
335 /* Construct from an RTL instruction (using its location and hotness). */
|
|
|
336 dump_user_location_t (const rtx_insn *insn);
|
|
|
337
|
|
|
338 /* Construct from a location_t. This one is deprecated (since it doesn't
|
|
|
339 capture hotness information); it thus needs to be spelled out. */
|
|
|
340 static dump_user_location_t
|
|
|
341 from_location_t (location_t loc)
|
|
|
342 {
|
|
|
343 return dump_user_location_t (profile_count (), loc);
|
|
|
344 }
|
|
|
345
|
|
|
346 /* Construct from a function declaration. This one requires spelling out
|
|
|
347 to avoid accidentally constructing from other kinds of tree. */
|
|
|
348 static dump_user_location_t
|
|
|
349 from_function_decl (tree fndecl);
|
|
|
350
|
|
|
351 profile_count get_count () const { return m_count; }
|
|
|
352 location_t get_location_t () const { return m_loc; }
|
|
|
353
|
|
|
354 private:
|
|
|
355 /* Private ctor from count and location, for use by from_location_t. */
|
|
|
356 dump_user_location_t (profile_count count, location_t loc)
|
|
|
357 : m_count (count), m_loc (loc)
|
|
|
358 {}
|
|
|
359
|
|
|
360 profile_count m_count;
|
|
|
361 location_t m_loc;
|
|
|
362 };
|
|
|
363
|
|
|
364 /* A class for identifying where in the compiler's own source
|
|
|
365 (or a plugin) that a dump message is being emitted from. */
|
|
|
366
|
|
|
367 struct dump_impl_location_t
|
|
|
368 {
|
|
|
369 dump_impl_location_t (
|
|
|
370 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
|
|
371 const char *file = __builtin_FILE (),
|
|
|
372 int line = __builtin_LINE (),
|
|
|
373 const char *function = __builtin_FUNCTION ()
|
|
|
374 #else
|
|
|
375 const char *file = __FILE__,
|
|
|
376 int line = __LINE__,
|
|
|
377 const char *function = NULL
|
|
|
378 #endif
|
|
|
379 )
|
|
|
380 : m_file (file), m_line (line), m_function (function)
|
|
|
381 {}
|
|
|
382
|
|
|
383 const char *m_file;
|
|
|
384 int m_line;
|
|
|
385 const char *m_function;
|
|
|
386 };
|
|
|
387
|
|
|
388 /* A bundle of information for describing the location of a dump message:
|
|
|
389 (a) the source location and hotness within the user's code, together with
|
|
|
390 (b) the source location within the compiler/plugin.
|
|
|
391
|
|
|
392 The constructors use default parameters so that (b) gets sets up
|
|
|
393 automatically.
|
|
|
394
|
|
|
395 The upshot is that you can pass in e.g. a gimple * to dump_printf_loc,
|
|
|
396 and the dump call will automatically record where in GCC's source
|
|
|
397 code the dump was emitted from. */
|
|
|
398
|
|
|
399 class dump_location_t
|
|
|
400 {
|
|
|
401 public:
|
|
|
402 /* Default constructor, analogous to UNKNOWN_LOCATION. */
|
|
|
403 dump_location_t (const dump_impl_location_t &impl_location
|
|
|
404 = dump_impl_location_t ())
|
|
|
405 : m_user_location (dump_user_location_t ()),
|
|
|
406 m_impl_location (impl_location)
|
|
|
407 {
|
|
|
408 }
|
|
|
409
|
|
|
410 /* Construct from a gimple statement (using its location and hotness). */
|
|
|
411 dump_location_t (const gimple *stmt,
|
|
|
412 const dump_impl_location_t &impl_location
|
|
|
413 = dump_impl_location_t ())
|
|
|
414 : m_user_location (dump_user_location_t (stmt)),
|
|
|
415 m_impl_location (impl_location)
|
|
|
416 {
|
|
|
417 }
|
|
|
418
|
|
|
419 /* Construct from an RTL instruction (using its location and hotness). */
|
|
|
420 dump_location_t (const rtx_insn *insn,
|
|
|
421 const dump_impl_location_t &impl_location
|
|
|
422 = dump_impl_location_t ())
|
|
|
423 : m_user_location (dump_user_location_t (insn)),
|
|
|
424 m_impl_location (impl_location)
|
|
|
425 {
|
|
|
426 }
|
|
|
427
|
|
|
428 /* Construct from a dump_user_location_t. */
|
|
|
429 dump_location_t (const dump_user_location_t &user_location,
|
|
|
430 const dump_impl_location_t &impl_location
|
|
|
431 = dump_impl_location_t ())
|
|
|
432 : m_user_location (user_location),
|
|
|
433 m_impl_location (impl_location)
|
|
|
434 {
|
|
|
435 }
|
|
|
436
|
|
|
437 /* Construct from a location_t. This one is deprecated (since it doesn't
|
|
|
438 capture hotness information), and thus requires spelling out. */
|
|
|
439 static dump_location_t
|
|
|
440 from_location_t (location_t loc,
|
|
|
441 const dump_impl_location_t &impl_location
|
|
|
442 = dump_impl_location_t ())
|
|
|
443 {
|
|
|
444 return dump_location_t (dump_user_location_t::from_location_t (loc),
|
|
|
445 impl_location);
|
|
|
446 }
|
|
|
447
|
|
|
448 const dump_user_location_t &
|
|
|
449 get_user_location () const { return m_user_location; }
|
|
|
450
|
|
|
451 const dump_impl_location_t &
|
|
|
452 get_impl_location () const { return m_impl_location; }
|
|
|
453
|
|
|
454 location_t get_location_t () const
|
|
|
455 {
|
|
|
456 return m_user_location.get_location_t ();
|
|
|
457 }
|
|
|
458
|
|
|
459 profile_count get_count () const { return m_user_location.get_count (); }
|
|
|
460
|
|
|
461 private:
|
|
|
462 dump_user_location_t m_user_location;
|
|
|
463 dump_impl_location_t m_impl_location;
|
|
|
464 };
|
|
|
465
|
|
111
|
466 /* In dumpfile.c */
|
|
131
|
467 extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
|
|
111
|
468 extern void dump_end (int, FILE *);
|
|
|
469 extern int opt_info_switch_p (const char *);
|
|
|
470 extern const char *dump_flag_name (int);
|
|
131
|
471 extern const kv_pair<optgroup_flags_t> optgroup_options[];
|
|
|
472
|
|
|
473 /* Global variables used to communicate with passes. */
|
|
|
474 extern FILE *dump_file;
|
|
|
475 extern dump_flags_t dump_flags;
|
|
|
476 extern const char *dump_file_name;
|
|
|
477
|
|
|
478 extern bool dumps_are_enabled;
|
|
|
479
|
|
|
480 extern void set_dump_file (FILE *new_dump_file);
|
|
|
481
|
|
|
482 /* Return true if any of the dumps is enabled, false otherwise. */
|
|
|
483 static inline bool
|
|
|
484 dump_enabled_p (void)
|
|
|
485 {
|
|
|
486 return dumps_are_enabled;
|
|
|
487 }
|
|
|
488
|
|
|
489 /* The following API calls (which *don't* take a "FILE *")
|
|
|
490 write the output to zero or more locations.
|
|
|
491
|
|
|
492 Some destinations are written to immediately as dump_* calls
|
|
|
493 are made; for others, the output is consolidated into an "optinfo"
|
|
|
494 instance (with its own metadata), and only emitted once the optinfo
|
|
|
495 is complete.
|
|
|
496
|
|
|
497 The destinations are:
|
|
|
498
|
|
|
499 (a) the "immediate" destinations:
|
|
|
500 (a.1) the active dump_file, if any
|
|
|
501 (a.2) the -fopt-info destination, if any
|
|
|
502 (b) the "optinfo" destinations, if any:
|
|
|
503 (b.1) as optimization records
|
|
|
504
|
|
|
505 dump_* (MSG_*) --> dumpfile.c --> items --> (a.1) dump_file
|
|
|
506 | `-> (a.2) alt_dump_file
|
|
|
507 |
|
|
|
508 `--> (b) optinfo
|
|
|
509 `---> optinfo destinations
|
|
|
510 (b.1) optimization records
|
|
|
511
|
|
|
512 For optinfos, the dump_*_loc mark the beginning of an optinfo
|
|
|
513 instance: all subsequent dump_* calls are consolidated into
|
|
|
514 that optinfo, until the next dump_*_loc call (or a change in
|
|
|
515 dump scope, or a call to dumpfile_ensure_any_optinfo_are_flushed).
|
|
|
516
|
|
|
517 A group of dump_* calls should be guarded by:
|
|
|
518
|
|
|
519 if (dump_enabled_p ())
|
|
|
520
|
|
|
521 to minimize the work done for the common case where dumps
|
|
|
522 are disabled. */
|
|
|
523
|
|
|
524 extern void dump_printf (dump_flags_t, const char *, ...)
|
|
|
525 ATTRIBUTE_GCC_DUMP_PRINTF (2, 3);
|
|
|
526
|
|
|
527 extern void dump_printf_loc (dump_flags_t, const dump_location_t &,
|
|
|
528 const char *, ...)
|
|
|
529 ATTRIBUTE_GCC_DUMP_PRINTF (3, 0);
|
|
111
|
530 extern void dump_function (int phase, tree fn);
|
|
131
|
531 extern void dump_basic_block (dump_flags_t, basic_block, int);
|
|
|
532 extern void dump_generic_expr_loc (dump_flags_t, const dump_location_t &,
|
|
|
533 dump_flags_t, tree);
|
|
111
|
534 extern void dump_generic_expr (dump_flags_t, dump_flags_t, tree);
|
|
131
|
535 extern void dump_gimple_stmt_loc (dump_flags_t, const dump_location_t &,
|
|
|
536 dump_flags_t, gimple *, int);
|
|
111
|
537 extern void dump_gimple_stmt (dump_flags_t, dump_flags_t, gimple *, int);
|
|
131
|
538 extern void dump_gimple_expr_loc (dump_flags_t, const dump_location_t &,
|
|
|
539 dump_flags_t, gimple *, int);
|
|
|
540 extern void dump_gimple_expr (dump_flags_t, dump_flags_t, gimple *, int);
|
|
|
541 extern void dump_symtab_node (dump_flags_t, symtab_node *);
|
|
|
542
|
|
|
543 template<unsigned int N, typename C>
|
|
|
544 void dump_dec (dump_flags_t, const poly_int<N, C> &);
|
|
|
545 extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
|
|
|
546 extern void dump_hex (dump_flags_t, const poly_wide_int &);
|
|
|
547
|
|
|
548 extern void dumpfile_ensure_any_optinfo_are_flushed ();
|
|
|
549
|
|
|
550 /* Managing nested scopes, so that dumps can express the call chain
|
|
|
551 leading to a dump message. */
|
|
|
552
|
|
|
553 extern unsigned int get_dump_scope_depth ();
|
|
|
554 extern void dump_begin_scope (const char *name, const dump_location_t &loc);
|
|
|
555 extern void dump_end_scope ();
|
|
|
556
|
|
|
557 /* Implementation detail of the AUTO_DUMP_SCOPE macro below.
|
|
|
558
|
|
|
559 A RAII-style class intended to make it easy to emit dump
|
|
|
560 information about entering and exiting a collection of nested
|
|
|
561 function calls. */
|
|
|
562
|
|
|
563 class auto_dump_scope
|
|
|
564 {
|
|
|
565 public:
|
|
|
566 auto_dump_scope (const char *name, dump_location_t loc)
|
|
|
567 {
|
|
|
568 if (dump_enabled_p ())
|
|
|
569 dump_begin_scope (name, loc);
|
|
|
570 }
|
|
|
571 ~auto_dump_scope ()
|
|
|
572 {
|
|
|
573 if (dump_enabled_p ())
|
|
|
574 dump_end_scope ();
|
|
|
575 }
|
|
|
576 };
|
|
|
577
|
|
|
578 /* A macro for calling:
|
|
|
579 dump_begin_scope (NAME, LOC);
|
|
|
580 via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc,
|
|
|
581 and then calling
|
|
|
582 dump_end_scope ();
|
|
|
583 once the object goes out of scope, thus capturing the nesting of
|
|
|
584 the scopes.
|
|
|
585
|
|
|
586 These scopes affect dump messages within them: dump messages at the
|
|
|
587 top level implicitly default to MSG_PRIORITY_USER_FACING, whereas those
|
|
|
588 in a nested scope implicitly default to MSG_PRIORITY_INTERNALS. */
|
|
|
589
|
|
|
590 #define AUTO_DUMP_SCOPE(NAME, LOC) \
|
|
|
591 auto_dump_scope scope (NAME, LOC)
|
|
|
592
|
|
|
593 extern void dump_function (int phase, tree fn);
|
|
111
|
594 extern void print_combine_total_stats (void);
|
|
|
595 extern bool enable_rtl_dump_file (void);
|
|
|
596
|
|
|
597 /* In tree-dump.c */
|
|
|
598 extern void dump_node (const_tree, dump_flags_t, FILE *);
|
|
|
599
|
|
|
600 /* In combine.c */
|
|
|
601 extern void dump_combine_total_stats (FILE *);
|
|
|
602 /* In cfghooks.c */
|
|
|
603 extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
|
|
|
604
|
|
131
|
605 struct opt_pass;
|
|
111
|
606
|
|
|
607 namespace gcc {
|
|
|
608
|
|
131
|
609 /* A class for managing all of the various dump files used by the
|
|
|
610 optimization passes. */
|
|
|
611
|
|
111
|
612 class dump_manager
|
|
|
613 {
|
|
|
614 public:
|
|
|
615
|
|
|
616 dump_manager ();
|
|
|
617 ~dump_manager ();
|
|
|
618
|
|
|
619 /* Register a dumpfile.
|
|
|
620
|
|
|
621 TAKE_OWNERSHIP determines whether callee takes ownership of strings
|
|
|
622 SUFFIX, SWTCH, and GLOB. */
|
|
|
623 unsigned int
|
|
|
624 dump_register (const char *suffix, const char *swtch, const char *glob,
|
|
131
|
625 dump_kind dkind, optgroup_flags_t optgroup_flags,
|
|
|
626 bool take_ownership);
|
|
111
|
627
|
|
|
628 /* Allow languages and middle-end to register their dumps before the
|
|
|
629 optimization passes. */
|
|
|
630 void
|
|
|
631 register_dumps ();
|
|
|
632
|
|
|
633 /* Return the dump_file_info for the given phase. */
|
|
|
634 struct dump_file_info *
|
|
|
635 get_dump_file_info (int phase) const;
|
|
|
636
|
|
|
637 struct dump_file_info *
|
|
|
638 get_dump_file_info_by_switch (const char *swtch) const;
|
|
|
639
|
|
|
640 /* Return the name of the dump file for the given phase.
|
|
|
641 If the dump is not enabled, returns NULL. */
|
|
|
642 char *
|
|
131
|
643 get_dump_file_name (int phase, int part = -1) const;
|
|
111
|
644
|
|
|
645 char *
|
|
131
|
646 get_dump_file_name (struct dump_file_info *dfi, int part = -1) const;
|
|
111
|
647
|
|
|
648 int
|
|
|
649 dump_switch_p (const char *arg);
|
|
|
650
|
|
|
651 /* Start a dump for PHASE. Store user-supplied dump flags in
|
|
|
652 *FLAG_PTR. Return the number of streams opened. Set globals
|
|
|
653 DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
|
|
|
654 set dump_flags appropriately for both pass dump stream and
|
|
|
655 -fopt-info stream. */
|
|
|
656 int
|
|
|
657 dump_start (int phase, dump_flags_t *flag_ptr);
|
|
|
658
|
|
|
659 /* Finish a tree dump for PHASE and close associated dump streams. Also
|
|
|
660 reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS. */
|
|
|
661 void
|
|
|
662 dump_finish (int phase);
|
|
|
663
|
|
|
664 FILE *
|
|
131
|
665 dump_begin (int phase, dump_flags_t *flag_ptr, int part);
|
|
111
|
666
|
|
|
667 /* Returns nonzero if tree dump PHASE has been initialized. */
|
|
|
668 int
|
|
|
669 dump_initialized_p (int phase) const;
|
|
|
670
|
|
|
671 /* Returns the switch name of PHASE. */
|
|
|
672 const char *
|
|
|
673 dump_flag_name (int phase) const;
|
|
|
674
|
|
131
|
675 void register_pass (opt_pass *pass);
|
|
|
676
|
|
111
|
677 private:
|
|
|
678
|
|
|
679 int
|
|
|
680 dump_phase_enabled_p (int phase) const;
|
|
|
681
|
|
|
682 int
|
|
|
683 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob);
|
|
|
684
|
|
|
685 int
|
|
|
686 dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
|
|
|
687
|
|
|
688 int
|
|
131
|
689 opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
|
|
111
|
690 const char *filename);
|
|
|
691
|
|
131
|
692 bool update_dfi_for_opt_info (dump_file_info *dfi) const;
|
|
|
693
|
|
111
|
694 private:
|
|
|
695
|
|
|
696 /* Dynamically registered dump files and switches. */
|
|
|
697 int m_next_dump;
|
|
|
698 struct dump_file_info *m_extra_dump_files;
|
|
|
699 size_t m_extra_dump_files_in_use;
|
|
|
700 size_t m_extra_dump_files_alloced;
|
|
|
701
|
|
131
|
702 /* Stored values from -fopt-info, for handling passes created after
|
|
|
703 option-parsing (by backends and by plugins). */
|
|
|
704 optgroup_flags_t m_optgroup_flags;
|
|
|
705 dump_flags_t m_optinfo_flags;
|
|
|
706 char *m_optinfo_filename;
|
|
|
707
|
|
111
|
708 /* Grant access to dump_enable_all. */
|
|
|
709 friend bool ::enable_rtl_dump_file (void);
|
|
|
710
|
|
|
711 /* Grant access to opt_info_enable_passes. */
|
|
|
712 friend int ::opt_info_switch_p (const char *arg);
|
|
|
713
|
|
|
714 }; // class dump_manager
|
|
|
715
|
|
|
716 } // namespace gcc
|
|
|
717
|
|
|
718 #endif /* GCC_DUMPFILE_H */
|
