Commit | Line | Data |
---|---|---|
fa82cce7 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
10e9ae9f AP |
2 | /* |
3 | * Copyright 2011-2017 by the PaX Team <pageexec@freemail.hu> | |
4 | * Modified by Alexander Popov <alex.popov@linux.com> | |
10e9ae9f AP |
5 | * |
6 | * Note: the choice of the license means that the compilation process is | |
7 | * NOT 'eligible' as defined by gcc's library exception to the GPL v3, | |
8 | * but for the kernel it doesn't matter since it doesn't link against | |
9 | * any of the gcc libraries | |
10 | * | |
11 | * This gcc plugin is needed for tracking the lowest border of the kernel stack. | |
12 | * It instruments the kernel code inserting stackleak_track_stack() calls: | |
13 | * - after alloca(); | |
14 | * - for the functions with a stack frame size greater than or equal | |
15 | * to the "track-min-size" plugin parameter. | |
16 | * | |
17 | * This plugin is ported from grsecurity/PaX. For more information see: | |
18 | * https://grsecurity.net/ | |
19 | * https://pax.grsecurity.net/ | |
20 | * | |
21 | * Debugging: | |
22 | * - use fprintf() to stderr, debug_generic_expr(), debug_gimple_stmt(), | |
feee1b8c | 23 | * print_rtl_single() and debug_rtx(); |
10e9ae9f AP |
24 | * - add "-fdump-tree-all -fdump-rtl-all" to the plugin CFLAGS in |
25 | * Makefile.gcc-plugins to see the verbose dumps of the gcc passes; | |
26 | * - use gcc -E to understand the preprocessing shenanigans; | |
27 | * - use gcc with enabled CFG/GIMPLE/SSA verification (--enable-checking). | |
28 | */ | |
29 | ||
30 | #include "gcc-common.h" | |
31 | ||
32 | __visible int plugin_is_GPL_compatible; | |
33 | ||
34 | static int track_frame_size = -1; | |
feee1b8c | 35 | static bool build_for_x86 = false; |
10e9ae9f | 36 | static const char track_function[] = "stackleak_track_stack"; |
8dd70543 AP |
37 | static bool disable = false; |
38 | static bool verbose = false; | |
10e9ae9f AP |
39 | |
40 | /* | |
41 | * Mark these global variables (roots) for gcc garbage collector since | |
42 | * they point to the garbage-collected memory. | |
43 | */ | |
44 | static GTY(()) tree track_function_decl; | |
45 | ||
46 | static struct plugin_info stackleak_plugin_info = { | |
d37aa2ef | 47 | .version = PLUGIN_VERSION, |
10e9ae9f | 48 | .help = "track-min-size=nn\ttrack stack for functions with a stack frame size >= nn bytes\n" |
feee1b8c | 49 | "arch=target_arch\tspecify target build arch\n" |
10e9ae9f | 50 | "disable\t\tdo not activate the plugin\n" |
8dd70543 | 51 | "verbose\t\tprint info about the instrumentation\n" |
10e9ae9f AP |
52 | }; |
53 | ||
feee1b8c | 54 | static void add_stack_tracking_gcall(gimple_stmt_iterator *gsi, bool after) |
10e9ae9f AP |
55 | { |
56 | gimple stmt; | |
feee1b8c | 57 | gcall *gimple_call; |
10e9ae9f | 58 | cgraph_node_ptr node; |
10e9ae9f AP |
59 | basic_block bb; |
60 | ||
feee1b8c | 61 | /* Insert calling stackleak_track_stack() */ |
10e9ae9f | 62 | stmt = gimple_build_call(track_function_decl, 0); |
feee1b8c AP |
63 | gimple_call = as_a_gcall(stmt); |
64 | if (after) | |
65 | gsi_insert_after(gsi, gimple_call, GSI_CONTINUE_LINKING); | |
66 | else | |
67 | gsi_insert_before(gsi, gimple_call, GSI_SAME_STMT); | |
10e9ae9f AP |
68 | |
69 | /* Update the cgraph */ | |
feee1b8c | 70 | bb = gimple_bb(gimple_call); |
10e9ae9f AP |
71 | node = cgraph_get_create_node(track_function_decl); |
72 | gcc_assert(node); | |
10e9ae9f | 73 | cgraph_create_edge(cgraph_get_node(current_function_decl), node, |
feee1b8c | 74 | gimple_call, bb->count, |
8d97fb39 | 75 | compute_call_stmt_bb_frequency(current_function_decl, bb)); |
10e9ae9f AP |
76 | } |
77 | ||
78 | static bool is_alloca(gimple stmt) | |
79 | { | |
80 | if (gimple_call_builtin_p(stmt, BUILT_IN_ALLOCA)) | |
81 | return true; | |
82 | ||
10e9ae9f AP |
83 | if (gimple_call_builtin_p(stmt, BUILT_IN_ALLOCA_WITH_ALIGN)) |
84 | return true; | |
10e9ae9f AP |
85 | |
86 | return false; | |
87 | } | |
88 | ||
feee1b8c AP |
89 | static tree get_current_stack_pointer_decl(void) |
90 | { | |
91 | varpool_node_ptr node; | |
92 | ||
93 | FOR_EACH_VARIABLE(node) { | |
94 | tree var = NODE_DECL(node); | |
95 | tree name = DECL_NAME(var); | |
96 | ||
97 | if (DECL_NAME_LENGTH(var) != sizeof("current_stack_pointer") - 1) | |
98 | continue; | |
99 | ||
100 | if (strcmp(IDENTIFIER_POINTER(name), "current_stack_pointer")) | |
101 | continue; | |
102 | ||
103 | return var; | |
104 | } | |
105 | ||
8dd70543 AP |
106 | if (verbose) { |
107 | fprintf(stderr, "stackleak: missing current_stack_pointer in %s()\n", | |
108 | DECL_NAME_POINTER(current_function_decl)); | |
109 | } | |
feee1b8c AP |
110 | return NULL_TREE; |
111 | } | |
112 | ||
113 | static void add_stack_tracking_gasm(gimple_stmt_iterator *gsi, bool after) | |
114 | { | |
115 | gasm *asm_call = NULL; | |
116 | tree sp_decl, input; | |
117 | vec<tree, va_gc> *inputs = NULL; | |
118 | ||
119 | /* 'no_caller_saved_registers' is currently supported only for x86 */ | |
120 | gcc_assert(build_for_x86); | |
121 | ||
122 | /* | |
123 | * Insert calling stackleak_track_stack() in asm: | |
124 | * asm volatile("call stackleak_track_stack" | |
125 | * :: "r" (current_stack_pointer)) | |
126 | * Use ASM_CALL_CONSTRAINT trick from arch/x86/include/asm/asm.h. | |
127 | * This constraint is taken into account during gcc shrink-wrapping | |
128 | * optimization. It is needed to be sure that stackleak_track_stack() | |
129 | * call is inserted after the prologue of the containing function, | |
130 | * when the stack frame is prepared. | |
131 | */ | |
132 | sp_decl = get_current_stack_pointer_decl(); | |
133 | if (sp_decl == NULL_TREE) { | |
134 | add_stack_tracking_gcall(gsi, after); | |
135 | return; | |
136 | } | |
137 | input = build_tree_list(NULL_TREE, build_const_char_string(2, "r")); | |
138 | input = chainon(NULL_TREE, build_tree_list(input, sp_decl)); | |
139 | vec_safe_push(inputs, input); | |
140 | asm_call = gimple_build_asm_vec("call stackleak_track_stack", | |
141 | inputs, NULL, NULL, NULL); | |
142 | gimple_asm_set_volatile(asm_call, true); | |
143 | if (after) | |
144 | gsi_insert_after(gsi, asm_call, GSI_CONTINUE_LINKING); | |
145 | else | |
146 | gsi_insert_before(gsi, asm_call, GSI_SAME_STMT); | |
147 | update_stmt(asm_call); | |
148 | } | |
149 | ||
150 | static void add_stack_tracking(gimple_stmt_iterator *gsi, bool after) | |
151 | { | |
152 | /* | |
153 | * The 'no_caller_saved_registers' attribute is used for | |
154 | * stackleak_track_stack(). If the compiler supports this attribute for | |
155 | * the target arch, we can add calling stackleak_track_stack() in asm. | |
156 | * That improves performance: we avoid useless operations with the | |
157 | * caller-saved registers in the functions from which we will remove | |
158 | * stackleak_track_stack() call during the stackleak_cleanup pass. | |
159 | */ | |
160 | if (lookup_attribute_spec(get_identifier("no_caller_saved_registers"))) | |
161 | add_stack_tracking_gasm(gsi, after); | |
162 | else | |
163 | add_stack_tracking_gcall(gsi, after); | |
164 | } | |
165 | ||
10e9ae9f AP |
166 | /* |
167 | * Work with the GIMPLE representation of the code. Insert the | |
168 | * stackleak_track_stack() call after alloca() and into the beginning | |
169 | * of the function if it is not instrumented. | |
170 | */ | |
171 | static unsigned int stackleak_instrument_execute(void) | |
172 | { | |
173 | basic_block bb, entry_bb; | |
174 | bool prologue_instrumented = false, is_leaf = true; | |
feee1b8c | 175 | gimple_stmt_iterator gsi = { 0 }; |
10e9ae9f AP |
176 | |
177 | /* | |
178 | * ENTRY_BLOCK_PTR is a basic block which represents possible entry | |
179 | * point of a function. This block does not contain any code and | |
180 | * has a CFG edge to its successor. | |
181 | */ | |
182 | gcc_assert(single_succ_p(ENTRY_BLOCK_PTR_FOR_FN(cfun))); | |
183 | entry_bb = single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun)); | |
184 | ||
185 | /* | |
186 | * Loop through the GIMPLE statements in each of cfun basic blocks. | |
187 | * cfun is a global variable which represents the function that is | |
188 | * currently processed. | |
189 | */ | |
190 | FOR_EACH_BB_FN(bb, cfun) { | |
191 | for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) { | |
192 | gimple stmt; | |
193 | ||
194 | stmt = gsi_stmt(gsi); | |
195 | ||
196 | /* Leaf function is a function which makes no calls */ | |
197 | if (is_gimple_call(stmt)) | |
198 | is_leaf = false; | |
199 | ||
200 | if (!is_alloca(stmt)) | |
201 | continue; | |
202 | ||
8dd70543 AP |
203 | if (verbose) { |
204 | fprintf(stderr, "stackleak: be careful, alloca() in %s()\n", | |
205 | DECL_NAME_POINTER(current_function_decl)); | |
206 | } | |
207 | ||
10e9ae9f | 208 | /* Insert stackleak_track_stack() call after alloca() */ |
feee1b8c | 209 | add_stack_tracking(&gsi, true); |
10e9ae9f AP |
210 | if (bb == entry_bb) |
211 | prologue_instrumented = true; | |
212 | } | |
213 | } | |
214 | ||
215 | if (prologue_instrumented) | |
216 | return 0; | |
217 | ||
218 | /* | |
219 | * Special cases to skip the instrumentation. | |
220 | * | |
221 | * Taking the address of static inline functions materializes them, | |
222 | * but we mustn't instrument some of them as the resulting stack | |
223 | * alignment required by the function call ABI will break other | |
224 | * assumptions regarding the expected (but not otherwise enforced) | |
225 | * register clobbering ABI. | |
226 | * | |
227 | * Case in point: native_save_fl on amd64 when optimized for size | |
228 | * clobbers rdx if it were instrumented here. | |
229 | * | |
230 | * TODO: any more special cases? | |
231 | */ | |
232 | if (is_leaf && | |
233 | !TREE_PUBLIC(current_function_decl) && | |
234 | DECL_DECLARED_INLINE_P(current_function_decl)) { | |
235 | return 0; | |
236 | } | |
237 | ||
238 | if (is_leaf && | |
239 | !strncmp(IDENTIFIER_POINTER(DECL_NAME(current_function_decl)), | |
240 | "_paravirt_", 10)) { | |
241 | return 0; | |
242 | } | |
243 | ||
244 | /* Insert stackleak_track_stack() call at the function beginning */ | |
245 | bb = entry_bb; | |
246 | if (!single_pred_p(bb)) { | |
247 | /* gcc_assert(bb_loop_depth(bb) || | |
248 | (bb->flags & BB_IRREDUCIBLE_LOOP)); */ | |
249 | split_edge(single_succ_edge(ENTRY_BLOCK_PTR_FOR_FN(cfun))); | |
250 | gcc_assert(single_succ_p(ENTRY_BLOCK_PTR_FOR_FN(cfun))); | |
251 | bb = single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun)); | |
252 | } | |
253 | gsi = gsi_after_labels(bb); | |
feee1b8c | 254 | add_stack_tracking(&gsi, false); |
10e9ae9f AP |
255 | |
256 | return 0; | |
257 | } | |
258 | ||
259 | static bool large_stack_frame(void) | |
260 | { | |
261 | #if BUILDING_GCC_VERSION >= 8000 | |
262 | return maybe_ge(get_frame_size(), track_frame_size); | |
263 | #else | |
264 | return (get_frame_size() >= track_frame_size); | |
265 | #endif | |
266 | } | |
267 | ||
feee1b8c | 268 | static void remove_stack_tracking_gcall(void) |
10e9ae9f AP |
269 | { |
270 | rtx_insn *insn, *next; | |
271 | ||
10e9ae9f AP |
272 | /* |
273 | * Find stackleak_track_stack() calls. Loop through the chain of insns, | |
274 | * which is an RTL representation of the code for a function. | |
275 | * | |
276 | * The example of a matching insn: | |
277 | * (call_insn 8 4 10 2 (call (mem (symbol_ref ("stackleak_track_stack") | |
278 | * [flags 0x41] <function_decl 0x7f7cd3302a80 stackleak_track_stack>) | |
279 | * [0 stackleak_track_stack S1 A8]) (0)) 675 {*call} (expr_list | |
280 | * (symbol_ref ("stackleak_track_stack") [flags 0x41] <function_decl | |
281 | * 0x7f7cd3302a80 stackleak_track_stack>) (expr_list (0) (nil))) (nil)) | |
282 | */ | |
283 | for (insn = get_insns(); insn; insn = next) { | |
284 | rtx body; | |
285 | ||
286 | next = NEXT_INSN(insn); | |
287 | ||
288 | /* Check the expression code of the insn */ | |
289 | if (!CALL_P(insn)) | |
290 | continue; | |
291 | ||
292 | /* | |
293 | * Check the expression code of the insn body, which is an RTL | |
294 | * Expression (RTX) describing the side effect performed by | |
295 | * that insn. | |
296 | */ | |
297 | body = PATTERN(insn); | |
298 | ||
299 | if (GET_CODE(body) == PARALLEL) | |
300 | body = XVECEXP(body, 0, 0); | |
301 | ||
302 | if (GET_CODE(body) != CALL) | |
303 | continue; | |
304 | ||
305 | /* | |
306 | * Check the first operand of the call expression. It should | |
307 | * be a mem RTX describing the needed subroutine with a | |
308 | * symbol_ref RTX. | |
309 | */ | |
310 | body = XEXP(body, 0); | |
311 | if (GET_CODE(body) != MEM) | |
312 | continue; | |
313 | ||
314 | body = XEXP(body, 0); | |
315 | if (GET_CODE(body) != SYMBOL_REF) | |
316 | continue; | |
317 | ||
318 | if (SYMBOL_REF_DECL(body) != track_function_decl) | |
319 | continue; | |
320 | ||
321 | /* Delete the stackleak_track_stack() call */ | |
322 | delete_insn_and_edges(insn); | |
af2d2225 | 323 | #if BUILDING_GCC_VERSION < 8000 |
10e9ae9f AP |
324 | if (GET_CODE(next) == NOTE && |
325 | NOTE_KIND(next) == NOTE_INSN_CALL_ARG_LOCATION) { | |
326 | insn = next; | |
327 | next = NEXT_INSN(insn); | |
328 | delete_insn_and_edges(insn); | |
329 | } | |
330 | #endif | |
331 | } | |
feee1b8c AP |
332 | } |
333 | ||
334 | static bool remove_stack_tracking_gasm(void) | |
335 | { | |
336 | bool removed = false; | |
337 | rtx_insn *insn, *next; | |
338 | ||
339 | /* 'no_caller_saved_registers' is currently supported only for x86 */ | |
340 | gcc_assert(build_for_x86); | |
341 | ||
342 | /* | |
343 | * Find stackleak_track_stack() asm calls. Loop through the chain of | |
344 | * insns, which is an RTL representation of the code for a function. | |
345 | * | |
346 | * The example of a matching insn: | |
347 | * (insn 11 5 12 2 (parallel [ (asm_operands/v | |
348 | * ("call stackleak_track_stack") ("") 0 | |
349 | * [ (reg/v:DI 7 sp [ current_stack_pointer ]) ] | |
350 | * [ (asm_input:DI ("r")) ] []) | |
351 | * (clobber (reg:CC 17 flags)) ]) -1 (nil)) | |
352 | */ | |
353 | for (insn = get_insns(); insn; insn = next) { | |
354 | rtx body; | |
355 | ||
356 | next = NEXT_INSN(insn); | |
357 | ||
358 | /* Check the expression code of the insn */ | |
359 | if (!NONJUMP_INSN_P(insn)) | |
360 | continue; | |
361 | ||
362 | /* | |
363 | * Check the expression code of the insn body, which is an RTL | |
364 | * Expression (RTX) describing the side effect performed by | |
365 | * that insn. | |
366 | */ | |
367 | body = PATTERN(insn); | |
368 | ||
369 | if (GET_CODE(body) != PARALLEL) | |
370 | continue; | |
371 | ||
372 | body = XVECEXP(body, 0, 0); | |
373 | ||
374 | if (GET_CODE(body) != ASM_OPERANDS) | |
375 | continue; | |
376 | ||
377 | if (strcmp(ASM_OPERANDS_TEMPLATE(body), | |
378 | "call stackleak_track_stack")) { | |
379 | continue; | |
380 | } | |
381 | ||
382 | delete_insn_and_edges(insn); | |
383 | gcc_assert(!removed); | |
384 | removed = true; | |
385 | } | |
386 | ||
387 | return removed; | |
388 | } | |
389 | ||
390 | /* | |
391 | * Work with the RTL representation of the code. | |
392 | * Remove the unneeded stackleak_track_stack() calls from the functions | |
393 | * which don't call alloca() and don't have a large enough stack frame size. | |
394 | */ | |
395 | static unsigned int stackleak_cleanup_execute(void) | |
396 | { | |
8dd70543 | 397 | const char *fn = DECL_NAME_POINTER(current_function_decl); |
feee1b8c AP |
398 | bool removed = false; |
399 | ||
8dd70543 AP |
400 | /* |
401 | * Leave stack tracking in functions that call alloca(). | |
402 | * Additional case: | |
403 | * gcc before version 7 called allocate_dynamic_stack_space() from | |
404 | * expand_stack_vars() for runtime alignment of constant-sized stack | |
405 | * variables. That caused cfun->calls_alloca to be set for functions | |
406 | * that in fact don't use alloca(). | |
407 | * For more info see gcc commit 7072df0aae0c59ae437e. | |
408 | * Let's leave such functions instrumented as well. | |
409 | */ | |
410 | if (cfun->calls_alloca) { | |
411 | if (verbose) | |
412 | fprintf(stderr, "stackleak: instrument %s(): calls_alloca\n", fn); | |
feee1b8c | 413 | return 0; |
8dd70543 | 414 | } |
feee1b8c | 415 | |
8dd70543 AP |
416 | /* Leave stack tracking in functions with large stack frame */ |
417 | if (large_stack_frame()) { | |
418 | if (verbose) | |
419 | fprintf(stderr, "stackleak: instrument %s()\n", fn); | |
feee1b8c | 420 | return 0; |
8dd70543 | 421 | } |
feee1b8c AP |
422 | |
423 | if (lookup_attribute_spec(get_identifier("no_caller_saved_registers"))) | |
424 | removed = remove_stack_tracking_gasm(); | |
425 | ||
426 | if (!removed) | |
427 | remove_stack_tracking_gcall(); | |
10e9ae9f AP |
428 | |
429 | return 0; | |
430 | } | |
431 | ||
27e9faf4 KC |
432 | /* |
433 | * STRING_CST may or may not be NUL terminated: | |
434 | * https://gcc.gnu.org/onlinedocs/gccint/Constant-expressions.html | |
435 | */ | |
436 | static inline bool string_equal(tree node, const char *string, int length) | |
437 | { | |
438 | if (TREE_STRING_LENGTH(node) < length) | |
439 | return false; | |
440 | if (TREE_STRING_LENGTH(node) > length + 1) | |
441 | return false; | |
442 | if (TREE_STRING_LENGTH(node) == length + 1 && | |
443 | TREE_STRING_POINTER(node)[length] != '\0') | |
444 | return false; | |
445 | return !memcmp(TREE_STRING_POINTER(node), string, length); | |
446 | } | |
447 | #define STRING_EQUAL(node, str) string_equal(node, str, strlen(str)) | |
448 | ||
10e9ae9f AP |
449 | static bool stackleak_gate(void) |
450 | { | |
451 | tree section; | |
452 | ||
453 | section = lookup_attribute("section", | |
454 | DECL_ATTRIBUTES(current_function_decl)); | |
455 | if (section && TREE_VALUE(section)) { | |
456 | section = TREE_VALUE(TREE_VALUE(section)); | |
457 | ||
27e9faf4 | 458 | if (STRING_EQUAL(section, ".init.text")) |
10e9ae9f | 459 | return false; |
27e9faf4 | 460 | if (STRING_EQUAL(section, ".devinit.text")) |
10e9ae9f | 461 | return false; |
27e9faf4 | 462 | if (STRING_EQUAL(section, ".cpuinit.text")) |
10e9ae9f | 463 | return false; |
27e9faf4 | 464 | if (STRING_EQUAL(section, ".meminit.text")) |
10e9ae9f | 465 | return false; |
ae978009 KC |
466 | if (STRING_EQUAL(section, ".noinstr.text")) |
467 | return false; | |
468 | if (STRING_EQUAL(section, ".entry.text")) | |
469 | return false; | |
e7d24c0a AB |
470 | if (STRING_EQUAL(section, ".head.text")) |
471 | return false; | |
10e9ae9f AP |
472 | } |
473 | ||
474 | return track_frame_size >= 0; | |
475 | } | |
476 | ||
477 | /* Build the function declaration for stackleak_track_stack() */ | |
478 | static void stackleak_start_unit(void *gcc_data __unused, | |
479 | void *user_data __unused) | |
480 | { | |
481 | tree fntype; | |
482 | ||
483 | /* void stackleak_track_stack(void) */ | |
484 | fntype = build_function_type_list(void_type_node, NULL_TREE); | |
485 | track_function_decl = build_fn_decl(track_function, fntype); | |
486 | DECL_ASSEMBLER_NAME(track_function_decl); /* for LTO */ | |
487 | TREE_PUBLIC(track_function_decl) = 1; | |
488 | TREE_USED(track_function_decl) = 1; | |
489 | DECL_EXTERNAL(track_function_decl) = 1; | |
490 | DECL_ARTIFICIAL(track_function_decl) = 1; | |
491 | DECL_PRESERVE_P(track_function_decl) = 1; | |
492 | } | |
493 | ||
494 | /* | |
495 | * Pass gate function is a predicate function that gets executed before the | |
496 | * corresponding pass. If the return value is 'true' the pass gets executed, | |
497 | * otherwise, it is skipped. | |
498 | */ | |
499 | static bool stackleak_instrument_gate(void) | |
500 | { | |
501 | return stackleak_gate(); | |
502 | } | |
503 | ||
504 | #define PASS_NAME stackleak_instrument | |
505 | #define PROPERTIES_REQUIRED PROP_gimple_leh | PROP_cfg | |
506 | #define TODO_FLAGS_START TODO_verify_ssa | TODO_verify_flow | TODO_verify_stmts | |
507 | #define TODO_FLAGS_FINISH TODO_verify_ssa | TODO_verify_stmts | TODO_dump_func \ | |
508 | | TODO_update_ssa | TODO_rebuild_cgraph_edges | |
509 | #include "gcc-generate-gimple-pass.h" | |
510 | ||
511 | static bool stackleak_cleanup_gate(void) | |
512 | { | |
513 | return stackleak_gate(); | |
514 | } | |
515 | ||
516 | #define PASS_NAME stackleak_cleanup | |
517 | #define TODO_FLAGS_FINISH TODO_dump_func | |
518 | #include "gcc-generate-rtl-pass.h" | |
519 | ||
520 | /* | |
521 | * Every gcc plugin exports a plugin_init() function that is called right | |
522 | * after the plugin is loaded. This function is responsible for registering | |
523 | * the plugin callbacks and doing other required initialization. | |
524 | */ | |
525 | __visible int plugin_init(struct plugin_name_args *plugin_info, | |
526 | struct plugin_gcc_version *version) | |
527 | { | |
528 | const char * const plugin_name = plugin_info->base_name; | |
529 | const int argc = plugin_info->argc; | |
530 | const struct plugin_argument * const argv = plugin_info->argv; | |
531 | int i = 0; | |
532 | ||
533 | /* Extra GGC root tables describing our GTY-ed data */ | |
534 | static const struct ggc_root_tab gt_ggc_r_gt_stackleak[] = { | |
535 | { | |
536 | .base = &track_function_decl, | |
537 | .nelt = 1, | |
538 | .stride = sizeof(track_function_decl), | |
539 | .cb = >_ggc_mx_tree_node, | |
540 | .pchw = >_pch_nx_tree_node | |
541 | }, | |
542 | LAST_GGC_ROOT_TAB | |
543 | }; | |
544 | ||
545 | /* | |
546 | * The stackleak_instrument pass should be executed before the | |
547 | * "optimized" pass, which is the control flow graph cleanup that is | |
548 | * performed just before expanding gcc trees to the RTL. In former | |
549 | * versions of the plugin this new pass was inserted before the | |
550 | * "tree_profile" pass, which is currently called "profile". | |
551 | */ | |
552 | PASS_INFO(stackleak_instrument, "optimized", 1, | |
553 | PASS_POS_INSERT_BEFORE); | |
554 | ||
555 | /* | |
8fb2dfb2 AP |
556 | * The stackleak_cleanup pass should be executed before the "*free_cfg" |
557 | * pass. It's the moment when the stack frame size is already final, | |
558 | * function prologues and epilogues are generated, and the | |
559 | * machine-dependent code transformations are not done. | |
10e9ae9f | 560 | */ |
8fb2dfb2 | 561 | PASS_INFO(stackleak_cleanup, "*free_cfg", 1, PASS_POS_INSERT_BEFORE); |
10e9ae9f AP |
562 | |
563 | if (!plugin_default_version_check(version, &gcc_version)) { | |
564 | error(G_("incompatible gcc/plugin versions")); | |
565 | return 1; | |
566 | } | |
567 | ||
568 | /* Parse the plugin arguments */ | |
569 | for (i = 0; i < argc; i++) { | |
10e9ae9f AP |
570 | if (!strcmp(argv[i].key, "track-min-size")) { |
571 | if (!argv[i].value) { | |
572 | error(G_("no value supplied for option '-fplugin-arg-%s-%s'"), | |
573 | plugin_name, argv[i].key); | |
574 | return 1; | |
575 | } | |
576 | ||
577 | track_frame_size = atoi(argv[i].value); | |
578 | if (track_frame_size < 0) { | |
579 | error(G_("invalid option argument '-fplugin-arg-%s-%s=%s'"), | |
580 | plugin_name, argv[i].key, argv[i].value); | |
581 | return 1; | |
582 | } | |
feee1b8c AP |
583 | } else if (!strcmp(argv[i].key, "arch")) { |
584 | if (!argv[i].value) { | |
585 | error(G_("no value supplied for option '-fplugin-arg-%s-%s'"), | |
586 | plugin_name, argv[i].key); | |
587 | return 1; | |
588 | } | |
589 | ||
590 | if (!strcmp(argv[i].value, "x86")) | |
591 | build_for_x86 = true; | |
8dd70543 AP |
592 | } else if (!strcmp(argv[i].key, "disable")) { |
593 | disable = true; | |
594 | } else if (!strcmp(argv[i].key, "verbose")) { | |
595 | verbose = true; | |
10e9ae9f AP |
596 | } else { |
597 | error(G_("unknown option '-fplugin-arg-%s-%s'"), | |
598 | plugin_name, argv[i].key); | |
599 | return 1; | |
600 | } | |
601 | } | |
602 | ||
8dd70543 AP |
603 | if (disable) { |
604 | if (verbose) | |
605 | fprintf(stderr, "stackleak: disabled for this translation unit\n"); | |
606 | return 0; | |
607 | } | |
608 | ||
10e9ae9f AP |
609 | /* Give the information about the plugin */ |
610 | register_callback(plugin_name, PLUGIN_INFO, NULL, | |
611 | &stackleak_plugin_info); | |
612 | ||
613 | /* Register to be called before processing a translation unit */ | |
614 | register_callback(plugin_name, PLUGIN_START_UNIT, | |
615 | &stackleak_start_unit, NULL); | |
616 | ||
617 | /* Register an extra GCC garbage collector (GGC) root table */ | |
618 | register_callback(plugin_name, PLUGIN_REGISTER_GGC_ROOTS, NULL, | |
619 | (void *)>_ggc_r_gt_stackleak); | |
620 | ||
621 | /* | |
622 | * Hook into the Pass Manager to register new gcc passes. | |
623 | * | |
624 | * The stack frame size info is available only at the last RTL pass, | |
625 | * when it's too late to insert complex code like a function call. | |
626 | * So we register two gcc passes to instrument every function at first | |
627 | * and remove the unneeded instrumentation later. | |
628 | */ | |
629 | register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, | |
630 | &stackleak_instrument_pass_info); | |
631 | register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, | |
632 | &stackleak_cleanup_pass_info); | |
633 | ||
634 | return 0; | |
635 | } |