1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32#include "gcc-common.h"
33
34
35#define TYPE_USERSPACE(TYPE) TYPE_LANG_FLAG_5(TYPE)
36
37__visible int plugin_is_GPL_compatible;
38
39static struct plugin_info structleak_plugin_info = {
40 .version = "201607271510vanilla",
41 .help = "disable\tdo not activate plugin\n"
42 "verbose\tprint all initialized variables\n",
43};
44
45static bool verbose;
46static bool byref_all;
47
48static tree handle_user_attribute(tree *node, tree name, tree args, int flags, bool *no_add_attrs)
49{
50 *no_add_attrs = true;
51
52
53 if (TREE_CODE(*node) != FIELD_DECL)
54 return NULL_TREE;
55
56 *no_add_attrs = false;
57 return NULL_TREE;
58}
59
60static struct attribute_spec user_attr = { };
61
62static void register_attributes(void *event_data, void *data)
63{
64 user_attr.name = "user";
65 user_attr.handler = handle_user_attribute;
66#if BUILDING_GCC_VERSION >= 4007
67 user_attr.affects_type_identity = true;
68#endif
69
70 register_attribute(&user_attr);
71}
72
73static tree get_field_type(tree field)
74{
75 return strip_array_types(TREE_TYPE(field));
76}
77
78static bool is_userspace_type(tree type)
79{
80 tree field;
81
82 for (field = TYPE_FIELDS(type); field; field = TREE_CHAIN(field)) {
83 tree fieldtype = get_field_type(field);
84 enum tree_code code = TREE_CODE(fieldtype);
85
86 if (code == RECORD_TYPE || code == UNION_TYPE)
87 if (is_userspace_type(fieldtype))
88 return true;
89
90 if (lookup_attribute("user", DECL_ATTRIBUTES(field)))
91 return true;
92 }
93 return false;
94}
95
96static void finish_type(void *event_data, void *data)
97{
98 tree type = (tree)event_data;
99
100 if (type == NULL_TREE || type == error_mark_node)
101 return;
102
103#if BUILDING_GCC_VERSION >= 5000
104 if (TREE_CODE(type) == ENUMERAL_TYPE)
105 return;
106#endif
107
108 if (TYPE_USERSPACE(type))
109 return;
110
111 if (is_userspace_type(type))
112 TYPE_USERSPACE(type) = 1;
113}
114
115static void initialize(tree var)
116{
117 basic_block bb;
118 gimple_stmt_iterator gsi;
119 tree initializer;
120 gimple init_stmt;
121
122
123 bb = single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun));
124
125
126 for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
127 gimple stmt = gsi_stmt(gsi);
128 tree rhs1;
129
130
131 if (!gimple_assign_single_p(stmt))
132 continue;
133 rhs1 = gimple_assign_rhs1(stmt);
134#if BUILDING_GCC_VERSION >= 4007
135
136 if (TREE_CLOBBER_P(rhs1))
137 continue;
138#endif
139
140 if (gimple_get_lhs(stmt) != var)
141 continue;
142
143 if (TREE_CODE(rhs1) == CONSTRUCTOR)
144 return;
145 }
146
147
148 if (verbose)
149 inform(DECL_SOURCE_LOCATION(var),
150 "%s variable will be forcibly initialized",
151 (byref_all && TREE_ADDRESSABLE(var)) ? "byref"
152 : "userspace");
153
154
155 initializer = build_constructor(TREE_TYPE(var), NULL);
156
157
158 init_stmt = gimple_build_assign(var, initializer);
159 gsi = gsi_after_labels(single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
160 gsi_insert_before(&gsi, init_stmt, GSI_NEW_STMT);
161 update_stmt(init_stmt);
162}
163
164static unsigned int structleak_execute(void)
165{
166 basic_block bb;
167 unsigned int ret = 0;
168 tree var;
169 unsigned int i;
170
171
172 gcc_assert(single_succ_p(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
173 bb = single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun));
174 if (!single_pred_p(bb)) {
175 split_edge(single_succ_edge(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
176 gcc_assert(single_succ_p(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
177 }
178
179
180 FOR_EACH_LOCAL_DECL(cfun, i, var) {
181 tree type = TREE_TYPE(var);
182
183 gcc_assert(DECL_P(var));
184 if (!auto_var_in_fn_p(var, current_function_decl))
185 continue;
186
187
188 if (TREE_CODE(type) != RECORD_TYPE && TREE_CODE(type) != UNION_TYPE)
189 continue;
190
191
192 if (TYPE_USERSPACE(type) ||
193 (byref_all && TREE_ADDRESSABLE(var)))
194 initialize(var);
195 }
196
197 return ret;
198}
199
200#define PASS_NAME structleak
201#define NO_GATE
202#define PROPERTIES_REQUIRED PROP_cfg
203#define TODO_FLAGS_FINISH TODO_verify_il | TODO_verify_ssa | TODO_verify_stmts | TODO_dump_func | TODO_remove_unused_locals | TODO_update_ssa | TODO_ggc_collect | TODO_verify_flow
204#include "gcc-generate-gimple-pass.h"
205
206__visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version)
207{
208 int i;
209 const char * const plugin_name = plugin_info->base_name;
210 const int argc = plugin_info->argc;
211 const struct plugin_argument * const argv = plugin_info->argv;
212 bool enable = true;
213
214 PASS_INFO(structleak, "early_optimizations", 1, PASS_POS_INSERT_BEFORE);
215
216 if (!plugin_default_version_check(version, &gcc_version)) {
217 error(G_("incompatible gcc/plugin versions"));
218 return 1;
219 }
220
221 if (strncmp(lang_hooks.name, "GNU C", 5) && !strncmp(lang_hooks.name, "GNU C+", 6)) {
222 inform(UNKNOWN_LOCATION, G_("%s supports C only, not %s"), plugin_name, lang_hooks.name);
223 enable = false;
224 }
225
226 for (i = 0; i < argc; ++i) {
227 if (!strcmp(argv[i].key, "disable")) {
228 enable = false;
229 continue;
230 }
231 if (!strcmp(argv[i].key, "verbose")) {
232 verbose = true;
233 continue;
234 }
235 if (!strcmp(argv[i].key, "byref-all")) {
236 byref_all = true;
237 continue;
238 }
239 error(G_("unknown option '-fplugin-arg-%s-%s'"), plugin_name, argv[i].key);
240 }
241
242 register_callback(plugin_name, PLUGIN_INFO, NULL, &structleak_plugin_info);
243 if (enable) {
244 register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &structleak_pass_info);
245 register_callback(plugin_name, PLUGIN_FINISH_TYPE, finish_type, NULL);
246 }
247 register_callback(plugin_name, PLUGIN_ATTRIBUTES, register_attributes, NULL);
248
249 return 0;
250}
251
