5 files changed, 382 insertions, 30 deletions

diff --git a/scripts/gcc-plugins/cyc_complexity_plugin.c b/scripts/gcc-plugins/cyc_complexity_plugin.c
index 8af7db06122d..1909ec617431 100644
--- a/scripts/gcc-plugins/cyc_complexity_plugin.c
+++ b/scripts/gcc-plugins/cyc_complexity_plugin.c
@@ -52,12 +52,8 @@ static unsigned int cyc_complexity_execute(void)
 __visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version)
 {
         const char * const plugin_name = plugin_info->base_name;
-        struct register_pass_info cyc_complexity_pass_info;
 
-        cyc_complexity_pass_info.pass                           = make_cyc_complexity_pass();
-        cyc_complexity_pass_info.reference_pass_name            = "ssa";
-        cyc_complexity_pass_info.ref_pass_instance_number       = 1;
-        cyc_complexity_pass_info.pos_op                         = PASS_POS_INSERT_AFTER;
+        PASS_INFO(cyc_complexity, "ssa", 1, PASS_POS_INSERT_AFTER);
 
         if (!plugin_default_version_check(version, &gcc_version)) {
                 error(G_("incompatible gcc/plugin versions"));
diff --git a/scripts/gcc-plugins/gcc-common.h b/scripts/gcc-plugins/gcc-common.h
index 950fd2e64bb7..b232ab15624c 100644
--- a/scripts/gcc-plugins/gcc-common.h
+++ b/scripts/gcc-plugins/gcc-common.h
@@ -26,6 +26,9 @@
 #include "except.h"
 #include "function.h"
 #include "toplev.h"
+#if BUILDING_GCC_VERSION >= 5000
+#include "expr.h"
+#endif
 #include "basic-block.h"
 #include "intl.h"
 #include "ggc.h"
@@ -39,6 +42,9 @@
 #include "hash-map.h"
 #endif
 
+#if BUILDING_GCC_VERSION >= 7000
+#include "memmodel.h"
+#endif
 #include "emit-rtl.h"
 #include "debug.h"
 #include "target.h"
@@ -77,6 +83,9 @@
 #include "diagnostic.h"
 #include "tree-dump.h"
 #include "tree-pass.h"
+#if BUILDING_GCC_VERSION >= 4009
+#include "pass_manager.h"
+#endif
 #include "predict.h"
 #include "ipa-utils.h"
 
@@ -91,6 +100,9 @@
 #include "tree-ssa-alias.h"
 #include "tree-ssa.h"
 #include "stringpool.h"
+#if BUILDING_GCC_VERSION >= 7000
+#include "tree-vrp.h"
+#endif
 #include "tree-ssanames.h"
 #include "print-tree.h"
 #include "tree-eh.h"
@@ -113,20 +125,17 @@
 #include "builtins.h"
 #endif
 
-/* #include "expr.h" where are you... */
-extern rtx emit_move_insn(rtx x, rtx y);
-
 /* missing from basic_block.h... */
-extern void debug_dominance_info(enum cdi_direction dir);
-extern void debug_dominance_tree(enum cdi_direction dir, basic_block root);
+void debug_dominance_info(enum cdi_direction dir);
+void debug_dominance_tree(enum cdi_direction dir, basic_block root);
 
 #if BUILDING_GCC_VERSION == 4006
-extern void debug_gimple_stmt(gimple);
-extern void debug_gimple_seq(gimple_seq);
-extern void print_gimple_seq(FILE *, gimple_seq, int, int);
-extern void print_gimple_stmt(FILE *, gimple, int, int);
-extern void print_gimple_expr(FILE *, gimple, int, int);
-extern void dump_gimple_stmt(pretty_printer *, gimple, int, int);
+void debug_gimple_stmt(gimple);
+void debug_gimple_seq(gimple_seq);
+void print_gimple_seq(FILE *, gimple_seq, int, int);
+void print_gimple_stmt(FILE *, gimple, int, int);
+void print_gimple_expr(FILE *, gimple, int, int);
+void dump_gimple_stmt(pretty_printer *, gimple, int, int);
 #endif
 
 #define __unused __attribute__((__unused__))
@@ -140,6 +149,29 @@ extern void dump_gimple_stmt(pretty_printer *, gimple, int, int);
 /* should come from c-tree.h if only it were installed for gcc 4.5... */
 #define C_TYPE_FIELDS_READONLY(TYPE) TREE_LANG_FLAG_1(TYPE)
 
+static inline tree build_const_char_string(int len, const char *str)
+{
+        tree cstr, elem, index, type;
+
+        cstr = build_string(len, str);
+        elem = build_type_variant(char_type_node, 1, 0);
+        index = build_index_type(size_int(len - 1));
+        type = build_array_type(elem, index);
+        TREE_TYPE(cstr) = type;
+        TREE_CONSTANT(cstr) = 1;
+        TREE_READONLY(cstr) = 1;
+        TREE_STATIC(cstr) = 1;
+        return cstr;
+}
+
+#define PASS_INFO(NAME, REF, ID, POS)           \
+struct register_pass_info NAME##_pass_info = {  \
+        .pass = make_##NAME##_pass(),           \
+        .reference_pass_name = REF,             \
+        .ref_pass_instance_number = ID,         \
+        .pos_op = POS,                          \
+}
+
 #if BUILDING_GCC_VERSION == 4005
 #define FOR_EACH_LOCAL_DECL(FUN, I, D)                  \
         for (tree vars = (FUN)->local_decls, (I) = 0;   \
@@ -287,6 +319,22 @@ static inline struct cgraph_node *cgraph_next_function_with_gimple_body(struct c
         return NULL;
 }
 
+static inline bool cgraph_for_node_and_aliases(cgraph_node_ptr node, bool (*callback)(cgraph_node_ptr, void *), void *data, bool include_overwritable)
+{
+        cgraph_node_ptr alias;
+
+        if (callback(node, data))
+                return true;
+
+        for (alias = node->same_body; alias; alias = alias->next) {
+                if (include_overwritable || cgraph_function_body_availability(alias) > AVAIL_OVERWRITABLE)
+                        if (cgraph_for_node_and_aliases(alias, callback, data, include_overwritable))
+                                return true;
+        }
+
+        return false;
+}
+
 #define FOR_EACH_FUNCTION_WITH_GIMPLE_BODY(node) \
         for ((node) = cgraph_first_function_with_gimple_body(); (node); \
                 (node) = cgraph_next_function_with_gimple_body(node))
@@ -399,6 +447,7 @@ typedef union gimple_statement_d gassign;
 typedef union gimple_statement_d gcall;
 typedef union gimple_statement_d gcond;
 typedef union gimple_statement_d gdebug;
+typedef union gimple_statement_d ggoto;
 typedef union gimple_statement_d gphi;
 typedef union gimple_statement_d greturn;
 
@@ -452,6 +501,16 @@ static inline const gdebug *as_a_const_gdebug(const_gimple stmt)
         return stmt;
 }
 
+static inline ggoto *as_a_ggoto(gimple stmt)
+{
+        return stmt;
+}
+
+static inline const ggoto *as_a_const_ggoto(const_gimple stmt)
+{
+        return stmt;
+}
+
 static inline gphi *as_a_gphi(gimple stmt)
 {
         return stmt;
@@ -494,8 +553,18 @@ static inline const greturn *as_a_const_greturn(const_gimple stmt)
 #define section_name_prefix LTO_SECTION_NAME_PREFIX
 #define fatal_error(loc, gmsgid, ...) fatal_error((gmsgid), __VA_ARGS__)
 
+rtx emit_move_insn(rtx x, rtx y);
+
 typedef struct rtx_def rtx_insn;
 
+static inline const char *get_decl_section_name(const_tree decl)
+{
+        if (DECL_SECTION_NAME(decl) == NULL_TREE)
+                return NULL;
+
+        return TREE_STRING_POINTER(DECL_SECTION_NAME(decl));
+}
+
 static inline void set_decl_section_name(tree node, const char *value)
 {
         if (value)
@@ -511,6 +580,7 @@ typedef struct gimple_statement_base gassign;
 typedef struct gimple_statement_call gcall;
 typedef struct gimple_statement_base gcond;
 typedef struct gimple_statement_base gdebug;
+typedef struct gimple_statement_base ggoto;
 typedef struct gimple_statement_phi gphi;
 typedef struct gimple_statement_base greturn;
 
@@ -564,6 +634,16 @@ static inline const gdebug *as_a_const_gdebug(const_gimple stmt)
         return stmt;
 }
 
+static inline ggoto *as_a_ggoto(gimple stmt)
+{
+        return stmt;
+}
+
+static inline const ggoto *as_a_const_ggoto(const_gimple stmt)
+{
+        return stmt;
+}
+
 static inline gphi *as_a_gphi(gimple stmt)
 {
         return as_a<gphi>(stmt);
@@ -591,6 +671,11 @@ static inline const greturn *as_a_const_greturn(const_gimple stmt)
 #define NODE_DECL(node) (node)->decl
 #define cgraph_node_name(node) (node)->name()
 #define NODE_IMPLICIT_ALIAS(node) (node)->cpp_implicit_alias
+
+static inline opt_pass *get_pass_for_id(int id)
+{
+        return g->get_passes()->get_pass_for_id(id);
+}
 #endif
 
 #if BUILDING_GCC_VERSION >= 5000 && BUILDING_GCC_VERSION < 6000
@@ -611,6 +696,11 @@ inline bool is_a_helper<const gassign *>::test(const_gimple gs)
 
 #define INSN_DELETED_P(insn) (insn)->deleted()
 
+static inline const char *get_decl_section_name(const_tree decl)
+{
+        return DECL_SECTION_NAME(decl);
+}
+
 /* symtab/cgraph related */
 #define debug_cgraph_node(node) (node)->debug()
 #define cgraph_get_node(decl) cgraph_node::get(decl)
@@ -619,6 +709,7 @@ inline bool is_a_helper<const gassign *>::test(const_gimple gs)
 #define cgraph_n_nodes symtab->cgraph_count
 #define cgraph_max_uid symtab->cgraph_max_uid
 #define varpool_get_node(decl) varpool_node::get(decl)
+#define dump_varpool_node(file, node) (node)->dump(file)
 
 #define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \
         (caller)->create_edge((callee), (call_stmt), (count), (freq))
@@ -674,6 +765,11 @@ static inline cgraph_node_ptr cgraph_alias_target(cgraph_node_ptr node)
         return node->get_alias_target();
 }
 
+static inline bool cgraph_for_node_and_aliases(cgraph_node_ptr node, bool (*callback)(cgraph_node_ptr, void *), void *data, bool include_overwritable)
+{
+        return node->call_for_symbol_thunks_and_aliases(callback, data, include_overwritable);
+}
+
 static inline struct cgraph_node_hook_list *cgraph_add_function_insertion_hook(cgraph_node_hook hook, void *data)
 {
         return symtab->add_cgraph_insertion_hook(hook, data);
@@ -731,6 +827,13 @@ static inline gimple gimple_build_assign_with_ops(enum tree_code subcode, tree l
 
 template <>
 template <>
+inline bool is_a_helper<const ggoto *>::test(const_gimple gs)
+{
+        return gs->code == GIMPLE_GOTO;
+}
+
+template <>
+template <>
 inline bool is_a_helper<const greturn *>::test(const_gimple gs)
 {
         return gs->code == GIMPLE_RETURN;
@@ -766,6 +869,16 @@ static inline const gcall *as_a_const_gcall(const_gimple stmt)
         return as_a<const gcall *>(stmt);
 }
 
+static inline ggoto *as_a_ggoto(gimple stmt)
+{
+        return as_a<ggoto *>(stmt);
+}
+
+static inline const ggoto *as_a_const_ggoto(const_gimple stmt)
+{
+        return as_a<const ggoto *>(stmt);
+}
+
 static inline gphi *as_a_gphi(gimple stmt)
 {
         return as_a<gphi *>(stmt);
@@ -828,4 +941,9 @@ static inline void debug_gimple_stmt(const_gimple s)
 #define debug_gimple_stmt(s) debug_gimple_stmt(CONST_CAST_GIMPLE(s))
 #endif
 
+#if BUILDING_GCC_VERSION >= 7000
+#define get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, preversep, pvolatilep, keep_aligning)   \
+        get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, preversep, pvolatilep)
+#endif
+
 #endif
diff --git a/scripts/gcc-plugins/latent_entropy_plugin.c b/scripts/gcc-plugins/latent_entropy_plugin.c
index 12541126575b..65264960910d 100644
--- a/scripts/gcc-plugins/latent_entropy_plugin.c
+++ b/scripts/gcc-plugins/latent_entropy_plugin.c
@@ -328,9 +328,9 @@ static enum tree_code get_op(tree *rhs)
                         op = LROTATE_EXPR;
                         /*
                          * This code limits the value of random_const to
-                         * the size of a wide int for the rotation
+                         * the size of a long for the rotation
                          */
-                        random_const &= HOST_BITS_PER_WIDE_INT - 1;
+                        random_const %= TYPE_PRECISION(long_unsigned_type_node);
                         break;
                 }
 
@@ -592,12 +592,6 @@ __visible int plugin_init(struct plugin_name_args *plugin_info,
         const struct plugin_argument * const argv = plugin_info->argv;
         int i;
 
-        struct register_pass_info latent_entropy_pass_info;
-
-        latent_entropy_pass_info.pass           = make_latent_entropy_pass();
-        latent_entropy_pass_info.reference_pass_name            = "optimized";
-        latent_entropy_pass_info.ref_pass_instance_number       = 1;
-        latent_entropy_pass_info.pos_op         = PASS_POS_INSERT_BEFORE;
         static const struct ggc_root_tab gt_ggc_r_gt_latent_entropy[] = {
                 {
                         .base = &latent_entropy_decl,
@@ -609,6 +603,8 @@ __visible int plugin_init(struct plugin_name_args *plugin_info,
                 LAST_GGC_ROOT_TAB
         };
 
+        PASS_INFO(latent_entropy, "optimized", 1, PASS_POS_INSERT_BEFORE);
+
         if (!plugin_default_version_check(version, &gcc_version)) {
                 error(G_("incompatible gcc/plugin versions"));
                 return 1;
diff --git a/scripts/gcc-plugins/sancov_plugin.c b/scripts/gcc-plugins/sancov_plugin.c
index 70f5fe0d590a..9b0b5cbc5b89 100644
--- a/scripts/gcc-plugins/sancov_plugin.c
+++ b/scripts/gcc-plugins/sancov_plugin.c
@@ -89,7 +89,6 @@ static void sancov_start_unit(void __unused *gcc_data, void __unused *user_data)
 __visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version)
 {
         int i;
-        struct register_pass_info sancov_plugin_pass_info;
         const char * const plugin_name = plugin_info->base_name;
         const int argc = plugin_info->argc;
         const struct plugin_argument * const argv = plugin_info->argv;
@@ -107,14 +106,11 @@ __visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gc
         };
 
         /* BBs can be split afterwards?? */
-        sancov_plugin_pass_info.pass                            = make_sancov_pass();
 #if BUILDING_GCC_VERSION >= 4009
-        sancov_plugin_pass_info.reference_pass_name             = "asan";
+        PASS_INFO(sancov, "asan", 0, PASS_POS_INSERT_BEFORE);
 #else
-        sancov_plugin_pass_info.reference_pass_name             = "nrv";
+        PASS_INFO(sancov, "nrv", 1, PASS_POS_INSERT_BEFORE);
 #endif
-        sancov_plugin_pass_info.ref_pass_instance_number        = 0;
-        sancov_plugin_pass_info.pos_op                          = PASS_POS_INSERT_BEFORE;
 
         if (!plugin_default_version_check(version, &gcc_version)) {
                 error(G_("incompatible gcc/plugin versions"));
diff --git a/scripts/gcc-plugins/structleak_plugin.c b/scripts/gcc-plugins/structleak_plugin.c
new file mode 100644
index 000000000000..fa3d7a4b26f2
--- /dev/null
+++ b/scripts/gcc-plugins/structleak_plugin.c
@@ -0,0 +1,246 @@
+/*
+ * Copyright 2013-2017 by PaX Team <pageexec@freemail.hu>
+ * Licensed under the GPL v2
+ *
+ * Note: the choice of the license means that the compilation process is
+ *       NOT 'eligible' as defined by gcc's library exception to the GPL v3,
+ *       but for the kernel it doesn't matter since it doesn't link against
+ *       any of the gcc libraries
+ *
+ * gcc plugin to forcibly initialize certain local variables that could
+ * otherwise leak kernel stack to userland if they aren't properly initialized
+ * by later code
+ *
+ * Homepage: http://pax.grsecurity.net/
+ *
+ * Options:
+ * -fplugin-arg-structleak_plugin-disable
+ * -fplugin-arg-structleak_plugin-verbose
+ *
+ * Usage:
+ * $ # for 4.5/4.6/C based 4.7
+ * $ gcc -I`gcc -print-file-name=plugin`/include -I`gcc -print-file-name=plugin`/include/c-family -fPIC -shared -O2 -o structleak_plugin.so structleak_plugin.c
+ * $ # for C++ based 4.7/4.8+
+ * $ g++ -I`g++ -print-file-name=plugin`/include -I`g++ -print-file-name=plugin`/include/c-family -fPIC -shared -O2 -o structleak_plugin.so structleak_plugin.c
+ * $ gcc -fplugin=./structleak_plugin.so test.c -O2
+ *
+ * TODO: eliminate redundant initializers
+ *       increase type coverage
+ */
+
+#include "gcc-common.h"
+
+/* unused C type flag in all versions 4.5-6 */
+#define TYPE_USERSPACE(TYPE) TYPE_LANG_FLAG_5(TYPE)
+
+__visible int plugin_is_GPL_compatible;
+
+static struct plugin_info structleak_plugin_info = {
+        .version        = "201607271510vanilla",
+        .help           = "disable\tdo not activate plugin\n"
+                           "verbose\tprint all initialized variables\n",
+};
+
+static bool verbose;
+
+static tree handle_user_attribute(tree *node, tree name, tree args, int flags, bool *no_add_attrs)
+{
+        *no_add_attrs = true;
+
+        /* check for types? for now accept everything linux has to offer */
+        if (TREE_CODE(*node) != FIELD_DECL)
+                return NULL_TREE;
+
+        *no_add_attrs = false;
+        return NULL_TREE;
+}
+
+static struct attribute_spec user_attr = {
+        .name                   = "user",
+        .min_length             = 0,
+        .max_length             = 0,
+        .decl_required          = false,
+        .type_required          = false,
+        .function_type_required = false,
+        .handler                = handle_user_attribute,
+#if BUILDING_GCC_VERSION >= 4007
+        .affects_type_identity  = true
+#endif
+};
+
+static void register_attributes(void *event_data, void *data)
+{
+        register_attribute(&user_attr);
+}
+
+static tree get_field_type(tree field)
+{
+        return strip_array_types(TREE_TYPE(field));
+}
+
+static bool is_userspace_type(tree type)
+{
+        tree field;
+
+        for (field = TYPE_FIELDS(type); field; field = TREE_CHAIN(field)) {
+                tree fieldtype = get_field_type(field);
+                enum tree_code code = TREE_CODE(fieldtype);
+
+                if (code == RECORD_TYPE || code == UNION_TYPE)
+                        if (is_userspace_type(fieldtype))
+                                return true;
+
+                if (lookup_attribute("user", DECL_ATTRIBUTES(field)))
+                        return true;
+        }
+        return false;
+}
+
+static void finish_type(void *event_data, void *data)
+{
+        tree type = (tree)event_data;
+
+        if (type == NULL_TREE || type == error_mark_node)
+                return;
+
+#if BUILDING_GCC_VERSION >= 5000
+        if (TREE_CODE(type) == ENUMERAL_TYPE)
+                return;
+#endif
+
+        if (TYPE_USERSPACE(type))
+                return;
+
+        if (is_userspace_type(type))
+                TYPE_USERSPACE(type) = 1;
+}
+
+static void initialize(tree var)
+{
+        basic_block bb;
+        gimple_stmt_iterator gsi;
+        tree initializer;
+        gimple init_stmt;
+
+        /* this is the original entry bb before the forced split */
+        bb = single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun));
+
+        /* first check if variable is already initialized, warn otherwise */
+        for (gsi = gsi_start_bb(bb); !gsi_end_p(gsi); gsi_next(&gsi)) {
+                gimple stmt = gsi_stmt(gsi);
+                tree rhs1;
+
+                /* we're looking for an assignment of a single rhs... */
+                if (!gimple_assign_single_p(stmt))
+                        continue;
+                rhs1 = gimple_assign_rhs1(stmt);
+#if BUILDING_GCC_VERSION >= 4007
+                /* ... of a non-clobbering expression... */
+                if (TREE_CLOBBER_P(rhs1))
+                        continue;
+#endif
+                /* ... to our variable... */
+                if (gimple_get_lhs(stmt) != var)
+                        continue;
+                /* if it's an initializer then we're good */
+                if (TREE_CODE(rhs1) == CONSTRUCTOR)
+                        return;
+        }
+
+        /* these aren't the 0days you're looking for */
+        if (verbose)
+                inform(DECL_SOURCE_LOCATION(var),
+                        "userspace variable will be forcibly initialized");
+
+        /* build the initializer expression */
+        initializer = build_constructor(TREE_TYPE(var), NULL);
+
+        /* build the initializer stmt */
+        init_stmt = gimple_build_assign(var, initializer);
+        gsi = gsi_after_labels(single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
+        gsi_insert_before(&gsi, init_stmt, GSI_NEW_STMT);
+        update_stmt(init_stmt);
+}
+
+static unsigned int structleak_execute(void)
+{
+        basic_block bb;
+        unsigned int ret = 0;
+        tree var;
+        unsigned int i;
+
+        /* split the first bb where we can put the forced initializers */
+        gcc_assert(single_succ_p(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
+        bb = single_succ(ENTRY_BLOCK_PTR_FOR_FN(cfun));
+        if (!single_pred_p(bb)) {
+                split_edge(single_succ_edge(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
+                gcc_assert(single_succ_p(ENTRY_BLOCK_PTR_FOR_FN(cfun)));
+        }
+
+        /* enumerate all local variables and forcibly initialize our targets */
+        FOR_EACH_LOCAL_DECL(cfun, i, var) {
+                tree type = TREE_TYPE(var);
+
+                gcc_assert(DECL_P(var));
+                if (!auto_var_in_fn_p(var, current_function_decl))
+                        continue;
+
+                /* only care about structure types */
+                if (TREE_CODE(type) != RECORD_TYPE && TREE_CODE(type) != UNION_TYPE)
+                        continue;
+
+                /* if the type is of interest, examine the variable */
+                if (TYPE_USERSPACE(type))
+                        initialize(var);
+        }
+
+        return ret;
+}
+
+#define PASS_NAME structleak
+#define NO_GATE
+#define PROPERTIES_REQUIRED PROP_cfg
+#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
+#include "gcc-generate-gimple-pass.h"
+
+__visible int plugin_init(struct plugin_name_args *plugin_info, struct plugin_gcc_version *version)
+{
+        int i;
+        const char * const plugin_name = plugin_info->base_name;
+        const int argc = plugin_info->argc;
+        const struct plugin_argument * const argv = plugin_info->argv;
+        bool enable = true;
+
+        PASS_INFO(structleak, "early_optimizations", 1, PASS_POS_INSERT_BEFORE);
+
+        if (!plugin_default_version_check(version, &gcc_version)) {
+                error(G_("incompatible gcc/plugin versions"));
+                return 1;
+        }
+
+        if (strncmp(lang_hooks.name, "GNU C", 5) && !strncmp(lang_hooks.name, "GNU C+", 6)) {
+                inform(UNKNOWN_LOCATION, G_("%s supports C only, not %s"), plugin_name, lang_hooks.name);
+                enable = false;
+        }
+
+        for (i = 0; i < argc; ++i) {
+                if (!strcmp(argv[i].key, "disable")) {
+                        enable = false;
+                        continue;
+                }
+                if (!strcmp(argv[i].key, "verbose")) {
+                        verbose = true;
+                        continue;
+                }
+                error(G_("unknown option '-fplugin-arg-%s-%s'"), plugin_name, argv[i].key);
+        }
+
+        register_callback(plugin_name, PLUGIN_INFO, NULL, &structleak_plugin_info);
+        if (enable) {
+                register_callback(plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &structleak_pass_info);
+                register_callback(plugin_name, PLUGIN_FINISH_TYPE, finish_type, NULL);
+        }
+        register_callback(plugin_name, PLUGIN_ATTRIBUTES, register_attributes, NULL);
+
+        return 0;
+}