scripts/gcc-plugins/stackleak_plugin.c

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