|
111
|
1 /* Definitions for the shared dumpfile.
|
|
145
|
2 Copyright (C) 2004-2020 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
|
|
145
|
196 /* For error. */
|
|
|
197 TDF_ERROR = (1 << 26),
|
|
|
198
|
|
131
|
199 /* All values. */
|
|
|
200 TDF_ALL_VALUES = (1 << 29) - 1
|
|
|
201 };
|
|
|
202
|
|
|
203 /* Dump flags type. */
|
|
|
204
|
|
|
205 typedef enum dump_flag dump_flags_t;
|
|
|
206
|
|
|
207 static inline dump_flags_t
|
|
|
208 operator| (dump_flags_t lhs, dump_flags_t rhs)
|
|
|
209 {
|
|
|
210 return (dump_flags_t)((int)lhs | (int)rhs);
|
|
|
211 }
|
|
|
212
|
|
|
213 static inline dump_flags_t
|
|
|
214 operator& (dump_flags_t lhs, dump_flags_t rhs)
|
|
|
215 {
|
|
|
216 return (dump_flags_t)((int)lhs & (int)rhs);
|
|
|
217 }
|
|
111
|
218
|
|
131
|
219 static inline dump_flags_t
|
|
|
220 operator~ (dump_flags_t flags)
|
|
|
221 {
|
|
|
222 return (dump_flags_t)~((int)flags);
|
|
|
223 }
|
|
|
224
|
|
|
225 static inline dump_flags_t &
|
|
|
226 operator|= (dump_flags_t &lhs, dump_flags_t rhs)
|
|
|
227 {
|
|
|
228 lhs = (dump_flags_t)((int)lhs | (int)rhs);
|
|
|
229 return lhs;
|
|
|
230 }
|
|
|
231
|
|
|
232 static inline dump_flags_t &
|
|
|
233 operator&= (dump_flags_t &lhs, dump_flags_t rhs)
|
|
|
234 {
|
|
|
235 lhs = (dump_flags_t)((int)lhs & (int)rhs);
|
|
|
236 return lhs;
|
|
|
237 }
|
|
111
|
238
|
|
|
239 /* Flags to control high-level -fopt-info dumps. Usually these flags
|
|
|
240 define a group of passes. An optimization pass can be part of
|
|
|
241 multiple groups. */
|
|
131
|
242
|
|
|
243 enum optgroup_flag
|
|
|
244 {
|
|
|
245 OPTGROUP_NONE = 0,
|
|
|
246
|
|
|
247 /* IPA optimization passes */
|
|
|
248 OPTGROUP_IPA = (1 << 1),
|
|
|
249
|
|
|
250 /* Loop optimization passes */
|
|
|
251 OPTGROUP_LOOP = (1 << 2),
|
|
|
252
|
|
|
253 /* Inlining passes */
|
|
|
254 OPTGROUP_INLINE = (1 << 3),
|
|
|
255
|
|
|
256 /* OMP (Offloading and Multi Processing) transformations */
|
|
|
257 OPTGROUP_OMP = (1 << 4),
|
|
|
258
|
|
|
259 /* Vectorization passes */
|
|
|
260 OPTGROUP_VEC = (1 << 5),
|
|
111
|
261
|
|
131
|
262 /* All other passes */
|
|
|
263 OPTGROUP_OTHER = (1 << 6),
|
|
|
264
|
|
|
265 OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
|
|
|
266 | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
|
|
|
267 };
|
|
|
268
|
|
|
269 typedef enum optgroup_flag optgroup_flags_t;
|
|
111
|
270
|
|
131
|
271 static inline optgroup_flags_t
|
|
|
272 operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
|
|
|
273 {
|
|
|
274 return (optgroup_flags_t)((int)lhs | (int)rhs);
|
|
|
275 }
|
|
|
276
|
|
|
277 static inline optgroup_flags_t &
|
|
|
278 operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
|
|
|
279 {
|
|
|
280 lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
|
|
|
281 return lhs;
|
|
|
282 }
|
|
111
|
283
|
|
|
284 /* Define a tree dump switch. */
|
|
|
285 struct dump_file_info
|
|
|
286 {
|
|
|
287 /* Suffix to give output file. */
|
|
|
288 const char *suffix;
|
|
|
289 /* Command line dump switch. */
|
|
|
290 const char *swtch;
|
|
|
291 /* Command line glob. */
|
|
|
292 const char *glob;
|
|
|
293 /* Filename for the pass-specific stream. */
|
|
|
294 const char *pfilename;
|
|
|
295 /* Filename for the -fopt-info stream. */
|
|
|
296 const char *alt_filename;
|
|
|
297 /* Pass-specific dump stream. */
|
|
|
298 FILE *pstream;
|
|
|
299 /* -fopt-info stream. */
|
|
|
300 FILE *alt_stream;
|
|
|
301 /* Dump kind. */
|
|
|
302 dump_kind dkind;
|
|
|
303 /* Dump flags. */
|
|
|
304 dump_flags_t pflags;
|
|
|
305 /* A pass flags for -fopt-info. */
|
|
131
|
306 dump_flags_t alt_flags;
|
|
111
|
307 /* Flags for -fopt-info given by a user. */
|
|
131
|
308 optgroup_flags_t optgroup_flags;
|
|
111
|
309 /* State of pass-specific stream. */
|
|
|
310 int pstate;
|
|
|
311 /* State of the -fopt-info stream. */
|
|
|
312 int alt_state;
|
|
|
313 /* Dump file number. */
|
|
|
314 int num;
|
|
|
315 /* Fields "suffix", "swtch", "glob" can be const strings,
|
|
|
316 or can be dynamically allocated, needing free. */
|
|
|
317 bool owns_strings;
|
|
|
318 /* When a given dump file is being initialized, this flag is set to true
|
|
|
319 if the corresponding TDF_graph dump file has also been initialized. */
|
|
|
320 bool graph_dump_initialized;
|
|
|
321 };
|
|
|
322
|
|
131
|
323 /* A class for describing where in the user's source that a dump message
|
|
|
324 relates to, with various constructors for convenience.
|
|
|
325 In particular, this lets us associate dump messages
|
|
|
326 with hotness information (e.g. from PGO), allowing them to
|
|
|
327 be prioritized by code hotness. */
|
|
|
328
|
|
|
329 class dump_user_location_t
|
|
|
330 {
|
|
|
331 public:
|
|
|
332 /* Default constructor, analogous to UNKNOWN_LOCATION. */
|
|
|
333 dump_user_location_t () : m_count (), m_loc (UNKNOWN_LOCATION) {}
|
|
|
334
|
|
|
335 /* Construct from a gimple statement (using its location and hotness). */
|
|
|
336 dump_user_location_t (const gimple *stmt);
|
|
|
337
|
|
|
338 /* Construct from an RTL instruction (using its location and hotness). */
|
|
|
339 dump_user_location_t (const rtx_insn *insn);
|
|
|
340
|
|
|
341 /* Construct from a location_t. This one is deprecated (since it doesn't
|
|
|
342 capture hotness information); it thus needs to be spelled out. */
|
|
|
343 static dump_user_location_t
|
|
|
344 from_location_t (location_t loc)
|
|
|
345 {
|
|
|
346 return dump_user_location_t (profile_count (), loc);
|
|
|
347 }
|
|
|
348
|
|
|
349 /* Construct from a function declaration. This one requires spelling out
|
|
|
350 to avoid accidentally constructing from other kinds of tree. */
|
|
|
351 static dump_user_location_t
|
|
|
352 from_function_decl (tree fndecl);
|
|
|
353
|
|
|
354 profile_count get_count () const { return m_count; }
|
|
|
355 location_t get_location_t () const { return m_loc; }
|
|
|
356
|
|
|
357 private:
|
|
|
358 /* Private ctor from count and location, for use by from_location_t. */
|
|
|
359 dump_user_location_t (profile_count count, location_t loc)
|
|
|
360 : m_count (count), m_loc (loc)
|
|
|
361 {}
|
|
|
362
|
|
|
363 profile_count m_count;
|
|
|
364 location_t m_loc;
|
|
|
365 };
|
|
|
366
|
|
|
367 /* A class for identifying where in the compiler's own source
|
|
|
368 (or a plugin) that a dump message is being emitted from. */
|
|
|
369
|
|
145
|
370 class dump_impl_location_t
|
|
131
|
371 {
|
|
145
|
372 public:
|
|
131
|
373 dump_impl_location_t (
|
|
|
374 #if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
|
|
|
375 const char *file = __builtin_FILE (),
|
|
|
376 int line = __builtin_LINE (),
|
|
|
377 const char *function = __builtin_FUNCTION ()
|
|
|
378 #else
|
|
|
379 const char *file = __FILE__,
|
|
|
380 int line = __LINE__,
|
|
|
381 const char *function = NULL
|
|
|
382 #endif
|
|
|
383 )
|
|
|
384 : m_file (file), m_line (line), m_function (function)
|
|
|
385 {}
|
|
|
386
|
|
|
387 const char *m_file;
|
|
|
388 int m_line;
|
|
|
389 const char *m_function;
|
|
|
390 };
|
|
|
391
|
|
145
|
392 /* A bundle of metadata for describing a dump message:
|
|
|
393 (a) the dump_flags
|
|
|
394 (b) the source location within the compiler/plugin.
|
|
|
395
|
|
|
396 The constructors use default parameters so that (b) gets sets up
|
|
|
397 automatically.
|
|
|
398
|
|
|
399 Hence you can pass in e.g. MSG_NOTE, and the dump call
|
|
|
400 will automatically record where in GCC's source code the
|
|
|
401 dump was emitted from. */
|
|
|
402
|
|
|
403 class dump_metadata_t
|
|
|
404 {
|
|
|
405 public:
|
|
|
406 dump_metadata_t (dump_flags_t dump_flags,
|
|
|
407 const dump_impl_location_t &impl_location
|
|
|
408 = dump_impl_location_t ())
|
|
|
409 : m_dump_flags (dump_flags),
|
|
|
410 m_impl_location (impl_location)
|
|
|
411 {
|
|
|
412 }
|
|
|
413
|
|
|
414 dump_flags_t get_dump_flags () const { return m_dump_flags; }
|
|
|
415
|
|
|
416 const dump_impl_location_t &
|
|
|
417 get_impl_location () const { return m_impl_location; }
|
|
|
418
|
|
|
419 private:
|
|
|
420 dump_flags_t m_dump_flags;
|
|
|
421 dump_impl_location_t m_impl_location;
|
|
|
422 };
|
|
|
423
|
|
131
|
424 /* A bundle of information for describing the location of a dump message:
|
|
|
425 (a) the source location and hotness within the user's code, together with
|
|
|
426 (b) the source location within the compiler/plugin.
|
|
|
427
|
|
|
428 The constructors use default parameters so that (b) gets sets up
|
|
|
429 automatically.
|
|
|
430
|
|
|
431 The upshot is that you can pass in e.g. a gimple * to dump_printf_loc,
|
|
|
432 and the dump call will automatically record where in GCC's source
|
|
|
433 code the dump was emitted from. */
|
|
|
434
|
|
|
435 class dump_location_t
|
|
|
436 {
|
|
|
437 public:
|
|
|
438 /* Default constructor, analogous to UNKNOWN_LOCATION. */
|
|
|
439 dump_location_t (const dump_impl_location_t &impl_location
|
|
|
440 = dump_impl_location_t ())
|
|
|
441 : m_user_location (dump_user_location_t ()),
|
|
|
442 m_impl_location (impl_location)
|
|
|
443 {
|
|
|
444 }
|
|
|
445
|
|
|
446 /* Construct from a gimple statement (using its location and hotness). */
|
|
|
447 dump_location_t (const gimple *stmt,
|
|
|
448 const dump_impl_location_t &impl_location
|
|
|
449 = dump_impl_location_t ())
|
|
|
450 : m_user_location (dump_user_location_t (stmt)),
|
|
|
451 m_impl_location (impl_location)
|
|
|
452 {
|
|
|
453 }
|
|
|
454
|
|
|
455 /* Construct from an RTL instruction (using its location and hotness). */
|
|
|
456 dump_location_t (const rtx_insn *insn,
|
|
|
457 const dump_impl_location_t &impl_location
|
|
|
458 = dump_impl_location_t ())
|
|
|
459 : m_user_location (dump_user_location_t (insn)),
|
|
|
460 m_impl_location (impl_location)
|
|
|
461 {
|
|
|
462 }
|
|
|
463
|
|
|
464 /* Construct from a dump_user_location_t. */
|
|
|
465 dump_location_t (const dump_user_location_t &user_location,
|
|
|
466 const dump_impl_location_t &impl_location
|
|
|
467 = dump_impl_location_t ())
|
|
|
468 : m_user_location (user_location),
|
|
|
469 m_impl_location (impl_location)
|
|
|
470 {
|
|
|
471 }
|
|
|
472
|
|
|
473 /* Construct from a location_t. This one is deprecated (since it doesn't
|
|
|
474 capture hotness information), and thus requires spelling out. */
|
|
|
475 static dump_location_t
|
|
|
476 from_location_t (location_t loc,
|
|
|
477 const dump_impl_location_t &impl_location
|
|
|
478 = dump_impl_location_t ())
|
|
|
479 {
|
|
|
480 return dump_location_t (dump_user_location_t::from_location_t (loc),
|
|
|
481 impl_location);
|
|
|
482 }
|
|
|
483
|
|
|
484 const dump_user_location_t &
|
|
|
485 get_user_location () const { return m_user_location; }
|
|
|
486
|
|
|
487 const dump_impl_location_t &
|
|
|
488 get_impl_location () const { return m_impl_location; }
|
|
|
489
|
|
|
490 location_t get_location_t () const
|
|
|
491 {
|
|
|
492 return m_user_location.get_location_t ();
|
|
|
493 }
|
|
|
494
|
|
|
495 profile_count get_count () const { return m_user_location.get_count (); }
|
|
|
496
|
|
|
497 private:
|
|
|
498 dump_user_location_t m_user_location;
|
|
|
499 dump_impl_location_t m_impl_location;
|
|
|
500 };
|
|
|
501
|
|
111
|
502 /* In dumpfile.c */
|
|
131
|
503 extern FILE *dump_begin (int, dump_flags_t *, int part=-1);
|
|
111
|
504 extern void dump_end (int, FILE *);
|
|
|
505 extern int opt_info_switch_p (const char *);
|
|
|
506 extern const char *dump_flag_name (int);
|
|
131
|
507 extern const kv_pair<optgroup_flags_t> optgroup_options[];
|
|
145
|
508 extern dump_flags_t
|
|
|
509 parse_dump_option (const char *, const char **);
|
|
131
|
510
|
|
|
511 /* Global variables used to communicate with passes. */
|
|
|
512 extern FILE *dump_file;
|
|
|
513 extern dump_flags_t dump_flags;
|
|
|
514 extern const char *dump_file_name;
|
|
|
515
|
|
|
516 extern bool dumps_are_enabled;
|
|
|
517
|
|
|
518 extern void set_dump_file (FILE *new_dump_file);
|
|
|
519
|
|
|
520 /* Return true if any of the dumps is enabled, false otherwise. */
|
|
|
521 static inline bool
|
|
|
522 dump_enabled_p (void)
|
|
|
523 {
|
|
|
524 return dumps_are_enabled;
|
|
|
525 }
|
|
|
526
|
|
|
527 /* The following API calls (which *don't* take a "FILE *")
|
|
|
528 write the output to zero or more locations.
|
|
|
529
|
|
|
530 Some destinations are written to immediately as dump_* calls
|
|
|
531 are made; for others, the output is consolidated into an "optinfo"
|
|
|
532 instance (with its own metadata), and only emitted once the optinfo
|
|
|
533 is complete.
|
|
|
534
|
|
|
535 The destinations are:
|
|
|
536
|
|
|
537 (a) the "immediate" destinations:
|
|
|
538 (a.1) the active dump_file, if any
|
|
|
539 (a.2) the -fopt-info destination, if any
|
|
|
540 (b) the "optinfo" destinations, if any:
|
|
|
541 (b.1) as optimization records
|
|
|
542
|
|
|
543 dump_* (MSG_*) --> dumpfile.c --> items --> (a.1) dump_file
|
|
|
544 | `-> (a.2) alt_dump_file
|
|
|
545 |
|
|
|
546 `--> (b) optinfo
|
|
|
547 `---> optinfo destinations
|
|
|
548 (b.1) optimization records
|
|
|
549
|
|
|
550 For optinfos, the dump_*_loc mark the beginning of an optinfo
|
|
|
551 instance: all subsequent dump_* calls are consolidated into
|
|
|
552 that optinfo, until the next dump_*_loc call (or a change in
|
|
|
553 dump scope, or a call to dumpfile_ensure_any_optinfo_are_flushed).
|
|
|
554
|
|
|
555 A group of dump_* calls should be guarded by:
|
|
|
556
|
|
|
557 if (dump_enabled_p ())
|
|
|
558
|
|
|
559 to minimize the work done for the common case where dumps
|
|
|
560 are disabled. */
|
|
|
561
|
|
145
|
562 extern void dump_printf (const dump_metadata_t &, const char *, ...)
|
|
131
|
563 ATTRIBUTE_GCC_DUMP_PRINTF (2, 3);
|
|
|
564
|
|
145
|
565 extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &,
|
|
131
|
566 const char *, ...)
|
|
|
567 ATTRIBUTE_GCC_DUMP_PRINTF (3, 0);
|
|
111
|
568 extern void dump_function (int phase, tree fn);
|
|
131
|
569 extern void dump_basic_block (dump_flags_t, basic_block, int);
|
|
145
|
570 extern void dump_generic_expr_loc (const dump_metadata_t &,
|
|
|
571 const dump_user_location_t &,
|
|
131
|
572 dump_flags_t, tree);
|
|
145
|
573 extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree);
|
|
|
574 extern void dump_gimple_stmt_loc (const dump_metadata_t &,
|
|
|
575 const dump_user_location_t &,
|
|
131
|
576 dump_flags_t, gimple *, int);
|
|
145
|
577 extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int);
|
|
|
578 extern void dump_gimple_expr_loc (const dump_metadata_t &,
|
|
|
579 const dump_user_location_t &,
|
|
131
|
580 dump_flags_t, gimple *, int);
|
|
145
|
581 extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int);
|
|
|
582 extern void dump_symtab_node (const dump_metadata_t &, symtab_node *);
|
|
131
|
583
|
|
|
584 template<unsigned int N, typename C>
|
|
145
|
585 void dump_dec (const dump_metadata_t &, const poly_int<N, C> &);
|
|
131
|
586 extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
|
|
|
587 extern void dump_hex (dump_flags_t, const poly_wide_int &);
|
|
|
588
|
|
|
589 extern void dumpfile_ensure_any_optinfo_are_flushed ();
|
|
|
590
|
|
|
591 /* Managing nested scopes, so that dumps can express the call chain
|
|
|
592 leading to a dump message. */
|
|
|
593
|
|
|
594 extern unsigned int get_dump_scope_depth ();
|
|
145
|
595 extern void dump_begin_scope (const char *name,
|
|
|
596 const dump_user_location_t &user_location,
|
|
|
597 const dump_impl_location_t &impl_location);
|
|
131
|
598 extern void dump_end_scope ();
|
|
|
599
|
|
|
600 /* Implementation detail of the AUTO_DUMP_SCOPE macro below.
|
|
|
601
|
|
|
602 A RAII-style class intended to make it easy to emit dump
|
|
|
603 information about entering and exiting a collection of nested
|
|
|
604 function calls. */
|
|
|
605
|
|
|
606 class auto_dump_scope
|
|
|
607 {
|
|
|
608 public:
|
|
145
|
609 auto_dump_scope (const char *name,
|
|
|
610 const dump_user_location_t &user_location,
|
|
|
611 const dump_impl_location_t &impl_location
|
|
|
612 = dump_impl_location_t ())
|
|
131
|
613 {
|
|
|
614 if (dump_enabled_p ())
|
|
145
|
615 dump_begin_scope (name, user_location, impl_location);
|
|
131
|
616 }
|
|
|
617 ~auto_dump_scope ()
|
|
|
618 {
|
|
|
619 if (dump_enabled_p ())
|
|
|
620 dump_end_scope ();
|
|
|
621 }
|
|
|
622 };
|
|
|
623
|
|
|
624 /* A macro for calling:
|
|
145
|
625 dump_begin_scope (NAME, USER_LOC);
|
|
131
|
626 via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc,
|
|
|
627 and then calling
|
|
|
628 dump_end_scope ();
|
|
|
629 once the object goes out of scope, thus capturing the nesting of
|
|
|
630 the scopes.
|
|
|
631
|
|
|
632 These scopes affect dump messages within them: dump messages at the
|
|
|
633 top level implicitly default to MSG_PRIORITY_USER_FACING, whereas those
|
|
|
634 in a nested scope implicitly default to MSG_PRIORITY_INTERNALS. */
|
|
|
635
|
|
145
|
636 #define AUTO_DUMP_SCOPE(NAME, USER_LOC) \
|
|
|
637 auto_dump_scope scope (NAME, USER_LOC)
|
|
131
|
638
|
|
|
639 extern void dump_function (int phase, tree fn);
|
|
111
|
640 extern void print_combine_total_stats (void);
|
|
|
641 extern bool enable_rtl_dump_file (void);
|
|
|
642
|
|
|
643 /* In tree-dump.c */
|
|
|
644 extern void dump_node (const_tree, dump_flags_t, FILE *);
|
|
|
645
|
|
|
646 /* In combine.c */
|
|
|
647 extern void dump_combine_total_stats (FILE *);
|
|
|
648 /* In cfghooks.c */
|
|
|
649 extern void dump_bb (FILE *, basic_block, int, dump_flags_t);
|
|
|
650
|
|
145
|
651 class opt_pass;
|
|
111
|
652
|
|
|
653 namespace gcc {
|
|
|
654
|
|
131
|
655 /* A class for managing all of the various dump files used by the
|
|
|
656 optimization passes. */
|
|
|
657
|
|
111
|
658 class dump_manager
|
|
|
659 {
|
|
|
660 public:
|
|
|
661
|
|
|
662 dump_manager ();
|
|
|
663 ~dump_manager ();
|
|
|
664
|
|
|
665 /* Register a dumpfile.
|
|
|
666
|
|
|
667 TAKE_OWNERSHIP determines whether callee takes ownership of strings
|
|
|
668 SUFFIX, SWTCH, and GLOB. */
|
|
|
669 unsigned int
|
|
|
670 dump_register (const char *suffix, const char *swtch, const char *glob,
|
|
131
|
671 dump_kind dkind, optgroup_flags_t optgroup_flags,
|
|
|
672 bool take_ownership);
|
|
111
|
673
|
|
|
674 /* Allow languages and middle-end to register their dumps before the
|
|
|
675 optimization passes. */
|
|
|
676 void
|
|
|
677 register_dumps ();
|
|
|
678
|
|
|
679 /* Return the dump_file_info for the given phase. */
|
|
|
680 struct dump_file_info *
|
|
|
681 get_dump_file_info (int phase) const;
|
|
|
682
|
|
|
683 struct dump_file_info *
|
|
|
684 get_dump_file_info_by_switch (const char *swtch) const;
|
|
|
685
|
|
|
686 /* Return the name of the dump file for the given phase.
|
|
|
687 If the dump is not enabled, returns NULL. */
|
|
|
688 char *
|
|
131
|
689 get_dump_file_name (int phase, int part = -1) const;
|
|
111
|
690
|
|
|
691 char *
|
|
131
|
692 get_dump_file_name (struct dump_file_info *dfi, int part = -1) const;
|
|
111
|
693
|
|
|
694 int
|
|
|
695 dump_switch_p (const char *arg);
|
|
|
696
|
|
|
697 /* Start a dump for PHASE. Store user-supplied dump flags in
|
|
|
698 *FLAG_PTR. Return the number of streams opened. Set globals
|
|
|
699 DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and
|
|
|
700 set dump_flags appropriately for both pass dump stream and
|
|
|
701 -fopt-info stream. */
|
|
|
702 int
|
|
|
703 dump_start (int phase, dump_flags_t *flag_ptr);
|
|
|
704
|
|
|
705 /* Finish a tree dump for PHASE and close associated dump streams. Also
|
|
|
706 reset the globals DUMP_FILE, ALT_DUMP_FILE, and DUMP_FLAGS. */
|
|
|
707 void
|
|
|
708 dump_finish (int phase);
|
|
|
709
|
|
|
710 FILE *
|
|
131
|
711 dump_begin (int phase, dump_flags_t *flag_ptr, int part);
|
|
111
|
712
|
|
|
713 /* Returns nonzero if tree dump PHASE has been initialized. */
|
|
|
714 int
|
|
|
715 dump_initialized_p (int phase) const;
|
|
|
716
|
|
|
717 /* Returns the switch name of PHASE. */
|
|
|
718 const char *
|
|
|
719 dump_flag_name (int phase) const;
|
|
|
720
|
|
131
|
721 void register_pass (opt_pass *pass);
|
|
|
722
|
|
111
|
723 private:
|
|
|
724
|
|
|
725 int
|
|
|
726 dump_phase_enabled_p (int phase) const;
|
|
|
727
|
|
|
728 int
|
|
|
729 dump_switch_p_1 (const char *arg, struct dump_file_info *dfi, bool doglob);
|
|
|
730
|
|
|
731 int
|
|
|
732 dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
|
|
|
733
|
|
|
734 int
|
|
131
|
735 opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
|
|
111
|
736 const char *filename);
|
|
|
737
|
|
131
|
738 bool update_dfi_for_opt_info (dump_file_info *dfi) const;
|
|
|
739
|
|
111
|
740 private:
|
|
|
741
|
|
|
742 /* Dynamically registered dump files and switches. */
|
|
|
743 int m_next_dump;
|
|
|
744 struct dump_file_info *m_extra_dump_files;
|
|
|
745 size_t m_extra_dump_files_in_use;
|
|
|
746 size_t m_extra_dump_files_alloced;
|
|
|
747
|
|
131
|
748 /* Stored values from -fopt-info, for handling passes created after
|
|
|
749 option-parsing (by backends and by plugins). */
|
|
|
750 optgroup_flags_t m_optgroup_flags;
|
|
|
751 dump_flags_t m_optinfo_flags;
|
|
|
752 char *m_optinfo_filename;
|
|
|
753
|
|
111
|
754 /* Grant access to dump_enable_all. */
|
|
|
755 friend bool ::enable_rtl_dump_file (void);
|
|
|
756
|
|
|
757 /* Grant access to opt_info_enable_passes. */
|
|
|
758 friend int ::opt_info_switch_p (const char *arg);
|
|
|
759
|
|
|
760 }; // class dump_manager
|
|
|
761
|
|
|
762 } // namespace gcc
|
|
|
763
|
|
|
764 #endif /* GCC_DUMPFILE_H */
|
