1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright 2011-2017 by the PaX Team <pageexec@freemail.hu>
4  * Modified by Alexander Popov <alex.popov@linux.com>
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(),
23  *     print_rtl_single() and debug_rtx();
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;
35 static bool build_for_x86 = false;
36 static const char track_function[] = "stackleak_track_stack";
37 static bool disable = false;
38 static bool verbose = false;
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 = {
47 	.version = PLUGIN_VERSION,
48 	.help = "track-min-size=nn\ttrack stack for functions with a stack frame size >= nn bytes\n"
49 		"arch=target_arch\tspecify target build arch\n"
50 		"disable\t\tdo not activate the plugin\n"
51 		"verbose\t\tprint info about the instrumentation\n"
52 };
53 
54 static void add_stack_tracking_gcall(gimple_stmt_iterator *gsi, bool after)
55 {
56 	gimple stmt;
57 	gcall *gimple_call;
58 	cgraph_node_ptr node;
59 	basic_block bb;
60 
61 	/* Insert calling stackleak_track_stack() */
62 	stmt = gimple_build_call(track_function_decl, 0);
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);
68 
69 	/* Update the cgraph */
70 	bb = gimple_bb(gimple_call);
71 	node = cgraph_get_create_node(track_function_decl);
72 	gcc_assert(node);
73 	cgraph_create_edge(cgraph_get_node(current_function_decl), node,
74 			gimple_call, bb->count,
75 			compute_call_stmt_bb_frequency(current_function_decl, bb));
76 }
77 
78 static bool is_alloca(gimple stmt)
79 {
80 	if (gimple_call_builtin_p(stmt, BUILT_IN_ALLOCA))
81 		return true;
82 
83 	if (gimple_call_builtin_p(stmt, BUILT_IN_ALLOCA_WITH_ALIGN))
84 		return true;
85 
86 	return false;
87 }
88 
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 
106 	if (verbose) {
107 		fprintf(stderr, "stackleak: missing current_stack_pointer in %s()\n",
108 			DECL_NAME_POINTER(current_function_decl));
109 	}
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 
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;
175 	gimple_stmt_iterator gsi = { 0 };
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 
203 			if (verbose) {
204 				fprintf(stderr, "stackleak: be careful, alloca() in %s()\n",
205 					DECL_NAME_POINTER(current_function_decl));
206 			}
207 
208 			/* Insert stackleak_track_stack() call after alloca() */
209 			add_stack_tracking(&gsi, true);
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);
254 	add_stack_tracking(&gsi, false);
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 
268 static void remove_stack_tracking_gcall(void)
269 {
270 	rtx_insn *insn, *next;
271 
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);
323 #if BUILDING_GCC_VERSION < 8000
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 	}
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 {
397 	const char *fn = DECL_NAME_POINTER(current_function_decl);
398 	bool removed = false;
399 
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);
413 		return 0;
414 	}
415 
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);
420 		return 0;
421 	}
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();
428 
429 	return 0;
430 }
431 
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 
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 
458 		if (STRING_EQUAL(section, ".init.text"))
459 			return false;
460 		if (STRING_EQUAL(section, ".devinit.text"))
461 			return false;
462 		if (STRING_EQUAL(section, ".cpuinit.text"))
463 			return false;
464 		if (STRING_EQUAL(section, ".meminit.text"))
465 			return false;
466 		if (STRING_EQUAL(section, ".noinstr.text"))
467 			return false;
468 		if (STRING_EQUAL(section, ".entry.text"))
469 			return false;
470 		if (STRING_EQUAL(section, ".head.text"))
471 			return false;
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 = &gt_ggc_mx_tree_node,
540 			.pchw = &gt_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 	/*
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.
560 	 */
561 	PASS_INFO(stackleak_cleanup, "*free_cfg", 1, PASS_POS_INSERT_BEFORE);
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++) {
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 			}
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;
592 		} else if (!strcmp(argv[i].key, "disable")) {
593 			disable = true;
594 		} else if (!strcmp(argv[i].key, "verbose")) {
595 			verbose = true;
596 		} else {
597 			error(G_("unknown option '-fplugin-arg-%s-%s'"),
598 					plugin_name, argv[i].key);
599 			return 1;
600 		}
601 	}
602 
603 	if (disable) {
604 		if (verbose)
605 			fprintf(stderr, "stackleak: disabled for this translation unit\n");
606 		return 0;
607 	}
608 
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 *)&gt_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 }
636