|
131
|
1 /* Optimization information.
|
|
|
2 Copyright (C) 2018 Free Software Foundation, Inc.
|
|
|
3 Contributed by David Malcolm <dmalcolm@redhat.com>.
|
|
|
4
|
|
|
5 This file is part of GCC.
|
|
|
6
|
|
|
7 GCC is free software; you can redistribute it and/or modify it under
|
|
|
8 the terms of the GNU General Public License as published by the Free
|
|
|
9 Software Foundation; either version 3, or (at your option) any later
|
|
|
10 version.
|
|
|
11
|
|
|
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
15 for more details.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License
|
|
|
18 along with GCC; see the file COPYING3. If not see
|
|
|
19 <http://www.gnu.org/licenses/>. */
|
|
|
20
|
|
|
21 #ifndef GCC_OPTINFO_H
|
|
|
22 #define GCC_OPTINFO_H
|
|
|
23
|
|
|
24 /* An "optinfo" is a bundle of information describing part of an
|
|
|
25 optimization, which can be emitted to zero or more of several
|
|
|
26 destinations, such as:
|
|
|
27
|
|
|
28 * saved to a file as an "optimization record"
|
|
|
29
|
|
|
30 They are generated in response to calls to the "dump_*" API in
|
|
|
31 dumpfile.h; repeated calls to the "dump_*" API are consolidated
|
|
|
32 into a pending optinfo instance, with a "dump_*_loc" starting a new
|
|
|
33 optinfo instance.
|
|
|
34
|
|
|
35 The data sent to the dump calls are captured within the pending optinfo
|
|
|
36 instance as a sequence of optinfo_items. For example, given:
|
|
|
37
|
|
|
38 if (dump_enabled_p ())
|
|
|
39 {
|
|
|
40 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
|
|
|
41 "not vectorized: live stmt not supported: ");
|
|
|
42 dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0);
|
|
|
43 }
|
|
|
44
|
|
|
45 the "dump_printf_loc" call begins a new optinfo containing two items:
|
|
|
46 (1) a text item containing "not vectorized: live stmt not supported: "
|
|
|
47 (2) a gimple item for "stmt"
|
|
|
48
|
|
|
49 Dump destinations are thus able to access rich metadata about the
|
|
|
50 items when the optinfo is emitted to them, rather than just having plain
|
|
|
51 text. For example, when saving the above optinfo to a file as an
|
|
|
52 "optimization record", the record could capture the source location of
|
|
|
53 "stmt" above, rather than just its textual form.
|
|
|
54
|
|
|
55 The currently pending optinfo is emitted and deleted:
|
|
|
56 * each time a "dump_*_loc" call occurs (which starts the next optinfo), or
|
|
|
57 * when the dump files are changed (at the end of a pass)
|
|
|
58
|
|
|
59 Dumping to an optinfo instance is non-trivial (due to building optinfo_item
|
|
|
60 instances), so all usage should be guarded by
|
|
|
61
|
|
|
62 if (optinfo_enabled_p ())
|
|
|
63
|
|
|
64 which is off by default. */
|
|
|
65
|
|
|
66
|
|
|
67 /* Forward decls. */
|
|
|
68 struct opt_pass;
|
|
|
69 class optinfo_item;
|
|
|
70
|
|
|
71 /* Should optinfo instances be created?
|
|
|
72 All creation of optinfos should be guarded by this predicate.
|
|
|
73 Return true if any optinfo destinations are active. */
|
|
|
74
|
|
|
75 extern bool optinfo_enabled_p ();
|
|
|
76
|
|
|
77 /* Return true if any of the active optinfo destinations make use
|
|
|
78 of inlining information.
|
|
|
79 (if true, then the information is preserved). */
|
|
|
80
|
|
|
81 extern bool optinfo_wants_inlining_info_p ();
|
|
|
82
|
|
|
83 /* The various kinds of optinfo. */
|
|
|
84
|
|
|
85 enum optinfo_kind
|
|
|
86 {
|
|
|
87 OPTINFO_KIND_SUCCESS,
|
|
|
88 OPTINFO_KIND_FAILURE,
|
|
|
89 OPTINFO_KIND_NOTE,
|
|
|
90 OPTINFO_KIND_SCOPE
|
|
|
91 };
|
|
|
92
|
|
|
93 extern const char *optinfo_kind_to_string (enum optinfo_kind kind);
|
|
|
94
|
|
|
95 class dump_context;
|
|
|
96
|
|
|
97 /* A bundle of information describing part of an optimization. */
|
|
|
98
|
|
|
99 class optinfo
|
|
|
100 {
|
|
|
101 friend class dump_context;
|
|
|
102
|
|
|
103 public:
|
|
|
104 optinfo (const dump_location_t &loc,
|
|
|
105 enum optinfo_kind kind,
|
|
|
106 opt_pass *pass)
|
|
|
107 : m_loc (loc), m_kind (kind), m_pass (pass), m_items ()
|
|
|
108 {}
|
|
|
109 ~optinfo ();
|
|
|
110
|
|
|
111 const dump_location_t &
|
|
|
112 get_dump_location () const { return m_loc; }
|
|
|
113
|
|
|
114 const dump_user_location_t &
|
|
|
115 get_user_location () const { return m_loc.get_user_location (); }
|
|
|
116
|
|
|
117 const dump_impl_location_t &
|
|
|
118 get_impl_location () const { return m_loc.get_impl_location (); }
|
|
|
119
|
|
|
120 enum optinfo_kind get_kind () const { return m_kind; }
|
|
|
121 opt_pass *get_pass () const { return m_pass; }
|
|
|
122 unsigned int num_items () const { return m_items.length (); }
|
|
|
123 const optinfo_item *get_item (unsigned int i) const { return m_items[i]; }
|
|
|
124
|
|
|
125 location_t get_location_t () const { return m_loc.get_location_t (); }
|
|
|
126 profile_count get_count () const { return m_loc.get_count (); }
|
|
|
127
|
|
|
128 void add_item (optinfo_item *item);
|
|
|
129
|
|
|
130 void emit_for_opt_problem () const;
|
|
|
131
|
|
|
132 private:
|
|
|
133 void emit () const;
|
|
|
134
|
|
|
135 /* Pre-canned ways of manipulating the optinfo, for use by friend class
|
|
|
136 dump_context. */
|
|
|
137 void handle_dump_file_kind (dump_flags_t);
|
|
|
138
|
|
|
139 private:
|
|
|
140 dump_location_t m_loc;
|
|
|
141 enum optinfo_kind m_kind;
|
|
|
142 opt_pass *m_pass;
|
|
|
143 auto_vec <optinfo_item *> m_items;
|
|
|
144 };
|
|
|
145
|
|
|
146 /* An enum for discriminating between different kinds of optinfo_item. */
|
|
|
147
|
|
|
148 enum optinfo_item_kind
|
|
|
149 {
|
|
|
150 OPTINFO_ITEM_KIND_TEXT,
|
|
|
151 OPTINFO_ITEM_KIND_TREE,
|
|
|
152 OPTINFO_ITEM_KIND_GIMPLE,
|
|
|
153 OPTINFO_ITEM_KIND_SYMTAB_NODE
|
|
|
154 };
|
|
|
155
|
|
|
156 /* An item within an optinfo. */
|
|
|
157
|
|
|
158 class optinfo_item
|
|
|
159 {
|
|
|
160 public:
|
|
|
161 optinfo_item (enum optinfo_item_kind kind, location_t location,
|
|
|
162 char *text);
|
|
|
163 ~optinfo_item ();
|
|
|
164
|
|
|
165 enum optinfo_item_kind get_kind () const { return m_kind; }
|
|
|
166 location_t get_location () const { return m_location; }
|
|
|
167 const char *get_text () const { return m_text; }
|
|
|
168
|
|
|
169 private:
|
|
|
170 /* Metadata (e.g. for optimization records). */
|
|
|
171 enum optinfo_item_kind m_kind;
|
|
|
172 location_t m_location;
|
|
|
173
|
|
|
174 /* The textual form of the item, owned by the item. */
|
|
|
175 char *m_text;
|
|
|
176 };
|
|
|
177
|
|
|
178 #endif /* #ifndef GCC_OPTINFO_H */
|
