diff options
Diffstat (limited to 'gcc/testsuite/gcc.dg/plugin')
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/finish_unit-test-1.c | 7 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/finish_unit_plugin.c | 29 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c | 12 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/ggcplug.c | 114 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/one_time-test-1.c | 8 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/one_time_plugin.c | 63 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/plugin.exp | 82 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/plugindir1.c | 4 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/plugindir2.c | 4 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/plugindir3.c | 4 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/plugindir4.c | 4 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c | 23 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c | 23 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/selfassign.c | 366 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c | 7 | ||||
| -rw-r--r-- | gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c | 66 |
16 files changed, 816 insertions, 0 deletions
diff --git a/gcc/testsuite/gcc.dg/plugin/finish_unit-test-1.c b/gcc/testsuite/gcc.dg/plugin/finish_unit-test-1.c new file mode 100644 index 000000000..4cd8a40f4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/finish_unit-test-1.c @@ -0,0 +1,7 @@ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +int main (int argc, char **argv) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/finish_unit_plugin.c b/gcc/testsuite/gcc.dg/plugin/finish_unit_plugin.c new file mode 100644 index 000000000..26496a2e6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/finish_unit_plugin.c @@ -0,0 +1,29 @@ +/* This plugin creates a fake function in the FINISH_UNIT callback, in + * other words right after compilation of the translation unit. +*/ +#include "gcc-plugin.h" +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "toplev.h" +#include "basic-block.h" +#include "gimple.h" +#include "tree.h" +#include "tree-pass.h" +#include "intl.h" +#include "cgraph.h" + +int plugin_is_GPL_compatible; + +static void finish_unit_callback (void *gcc_data, void *user_data) +{ + cgraph_build_static_cdtor ('I', NULL, DEFAULT_INIT_PRIORITY); +} + +int plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version) +{ + register_callback ("finish_unit", PLUGIN_FINISH_UNIT, &finish_unit_callback, NULL); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c b/gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c new file mode 100644 index 000000000..74e68bb82 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/ggcplug-test-1.c @@ -0,0 +1,12 @@ +/* Test the ggcplug plugin. */ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +int main() +{ + int i=0, j=0; + for (i= 0; i<1000; i++) + if (i%8 == 0) + j++; + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/ggcplug.c b/gcc/testsuite/gcc.dg/plugin/ggcplug.c new file mode 100644 index 000000000..3094b2ebb --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/ggcplug.c @@ -0,0 +1,114 @@ +/* This plugin tests the GGC related plugin events. */ +/* { dg-options "-O" } */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "toplev.h" +#include "basic-block.h" +#include "gimple.h" +#include "tree.h" +#include "tree-pass.h" +#include "intl.h" +#include "gcc-plugin.h" +#include "plugin-version.h" +#include "diagnostic.h" + +int plugin_is_GPL_compatible; + +/* our callback is the same for all PLUGIN_GGC_START, + PLUGIN_GGC_MARKING, PLUGIN_GGC_END events; it just increments the + user_data which is an int */ +static void increment_callback (void *gcc_data, void *user_data); + +/* our counters are user_data */ +static int our_ggc_start_counter; +static int our_ggc_end_counter; +static int our_ggc_marking_counter; + +/* our empty GGC extra root table */ +static const struct ggc_root_tab our_xtratab[] = { + LAST_GGC_ROOT_TAB +}; + + +/* The initialization routine exposed to and called by GCC. The spec of this + function is defined in gcc/gcc-plugin.h. + + Note that this function needs to be named exactly "plugin_init". */ +int +plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version) +{ + const char *plugin_name = plugin_info->base_name; + int argc = plugin_info->argc; + int i = 0; + struct plugin_argument *argv = plugin_info->argv; + if (!plugin_default_version_check (version, &gcc_version)) + return 1; + /* Process the plugin arguments. This plugin takes the following arguments: + count-ggc-start count-ggc-end count-ggc-mark */ + for (i = 0; i < argc; ++i) + { + if (!strcmp (argv[i].key, "count-ggc-start")) + { + if (argv[i].value) + warning (0, G_ ("option '-fplugin-arg-%s-count-ggc-start=%s'" + " ignored (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + register_callback ("ggcplug", + PLUGIN_GGC_START, + increment_callback, + (void *) &our_ggc_start_counter); + } + else if (!strcmp (argv[i].key, "count-ggc-end")) + { + if (argv[i].value) + warning (0, G_ ("option '-fplugin-arg-%s-count-ggc-end=%s'" + " ignored (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + register_callback ("ggcplug", + PLUGIN_GGC_END, + increment_callback, + (void *) &our_ggc_end_counter); + } + else if (!strcmp (argv[i].key, "count-ggc-mark")) + { + if (argv[i].value) + warning (0, G_ ("option '-fplugin-arg-%s-count-ggc-mark=%s'" + " ignored (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + register_callback ("ggcplug", + PLUGIN_GGC_MARKING, + increment_callback, + (void *) &our_ggc_marking_counter); + } + else if (!strcmp (argv[i].key, "test-extra-root")) + { + if (argv[i].value) + warning (0, G_ ("option '-fplugin-arg-%s-test-extra-root=%s'" + " ignored (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + register_callback ("ggcplug", + PLUGIN_REGISTER_GGC_ROOTS, + NULL, + (void *) our_xtratab); + } + } + /* plugin initialization succeeded */ + return 0; + } + +static void +increment_callback (void *gcc_data, void *user_data) +{ + int *usercountptr = (int *) user_data; + gcc_assert (!gcc_data); + gcc_assert (user_data); + (*usercountptr)++; +} diff --git a/gcc/testsuite/gcc.dg/plugin/one_time-test-1.c b/gcc/testsuite/gcc.dg/plugin/one_time-test-1.c new file mode 100644 index 000000000..a49ecb4af --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/one_time-test-1.c @@ -0,0 +1,8 @@ +/* Test that pass is inserted and invoked once. */ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +int main (int argc, char **argv) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/one_time_plugin.c b/gcc/testsuite/gcc.dg/plugin/one_time_plugin.c new file mode 100644 index 000000000..2c4cd4971 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/one_time_plugin.c @@ -0,0 +1,63 @@ +/* Plugin that prints message if it inserted (and invoked) more than once. */ +#include "config.h" +#include "gcc-plugin.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "toplev.h" +#include "gimple.h" +#include "tree-pass.h" +#include "intl.h" + +int plugin_is_GPL_compatible; + +static bool one_pass_gate (void) +{ + return true; +} + +static unsigned int one_pass_exec (void) +{ + static int counter = 0; + + if (counter > 0) { + printf ("Executed more than once \n"); + } + counter++; + return 0; +} + +struct gimple_opt_pass one_pass = +{ + { + GIMPLE_PASS, + "cfg", /* name */ + one_pass_gate, /* gate */ + one_pass_exec, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_NONE, /* tv_id */ + PROP_gimple_any, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; + + +int plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version) +{ + struct register_pass_info p; + + p.pass = &one_pass.pass; + p.reference_pass_name = "cfg"; + p.ref_pass_instance_number = 1; + p.pos_op = PASS_POS_INSERT_AFTER; + + register_callback ("one_pass", PLUGIN_PASS_MANAGER_SETUP, NULL, &p); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/plugin.exp b/gcc/testsuite/gcc.dg/plugin/plugin.exp new file mode 100644 index 000000000..444bd1bb6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/plugin.exp @@ -0,0 +1,82 @@ +# Copyright (C) 2009, 2010 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# <http://www.gnu.org/licenses/>. + +# Test the functionality of the GCC plugin support + +load_lib target-supports.exp +load_lib gcc-dg.exp + +global TESTING_IN_BUILD_TREE +global ENABLE_PLUGIN + +# The plugin testcases currently only work when the build tree is available. +# Also check whether the host supports plugins. +if { ![info exists TESTING_IN_BUILD_TREE] || ![info exists ENABLE_PLUGIN] } { + return +} + +# If a testcase doesn't have special options, use these. +global DEFAULT_CFLAGS +if ![info exists DEFAULT_CFLAGS] then { + set DEFAULT_CFLAGS " -ansi -pedantic-errors" +} + +# The procedures in plugin-support.exp need these parameters. +set default_flags $DEFAULT_CFLAGS + +if $tracelevel then { + strace $tracelevel +} + +# Load support procs. +load_lib plugin-support.exp + +# Specify the plugin source file and the associated test files in a list. +# plugin_test_list={ {plugin1 test1 test2 ...} {plugin2 test1 ...} ... } +set plugin_test_list [list \ + { selfassign.c self-assign-test-1.c self-assign-test-2.c } \ + { ggcplug.c ggcplug-test-1.c } \ + { one_time_plugin.c one_time-test-1.c } \ + { start_unit_plugin.c start_unit-test-1.c } \ + { finish_unit_plugin.c finish_unit-test-1.c } \ +] + +foreach plugin_test $plugin_test_list { + # Replace each source file with its full-path name + for {set i 0} {$i < [llength $plugin_test]} {incr i} { + set basename [lindex $plugin_test $i] + set plugin_test [lreplace $plugin_test $i $i $srcdir/$subdir/$basename] + } + set plugin_src [lindex $plugin_test 0] + # If we're only testing specific files and this isn't one of them, skip it. + if ![runtest_file_p $runtests $plugin_src] then { + continue + } + set plugin_input_tests [lreplace $plugin_test 0 0] + plugin-test-execute $plugin_src $plugin_input_tests +} + +# run the plugindir tests + +# Initialize `dg'. +dg-init + +# Main loop. +dg-runtest [lsort [glob -nocomplain $srcdir/$subdir/plugindir*.\[cSi\]]] \ + "" $DEFAULT_CFLAGS + +# All done. +dg-finish diff --git a/gcc/testsuite/gcc.dg/plugin/plugindir1.c b/gcc/testsuite/gcc.dg/plugin/plugindir1.c new file mode 100644 index 000000000..a973ec0c5 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/plugindir1.c @@ -0,0 +1,4 @@ +/* { dg-do compile } */ +/* { dg-options "-c -fplugin=foo" } */ + +/* { dg-prune-output ".*inacessible plugin file.*foo\.so expanded from short plugin name.*" } */ diff --git a/gcc/testsuite/gcc.dg/plugin/plugindir2.c b/gcc/testsuite/gcc.dg/plugin/plugindir2.c new file mode 100644 index 000000000..58c150550 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/plugindir2.c @@ -0,0 +1,4 @@ +/* { dg-do compile } */ +/* { dg-options "-save-temps -c -fplugin=foo" } */ + +/* { dg-prune-output ".*inacessible plugin file.*foo\.so expanded from short plugin name.*" } */ diff --git a/gcc/testsuite/gcc.dg/plugin/plugindir3.c b/gcc/testsuite/gcc.dg/plugin/plugindir3.c new file mode 100644 index 000000000..41037534a --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/plugindir3.c @@ -0,0 +1,4 @@ +/* { dg-do preprocess } */ +/* { dg-options "-fplugin=foo" } */ + +/* { dg-prune-output ".*inacessible plugin file.*foo\.so expanded from short plugin name.*" } */ diff --git a/gcc/testsuite/gcc.dg/plugin/plugindir4.c b/gcc/testsuite/gcc.dg/plugin/plugindir4.c new file mode 100644 index 000000000..27b2f24aa --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/plugindir4.c @@ -0,0 +1,4 @@ +/* { dg-do preprocess } */ +/* { dg-options "-iplugindir=my-plugindir -fplugin=foo" } */ + +/* { dg-prune-output ".*inacessible plugin file.*my-plugindir/foo\.so expanded from short plugin name.*" } */ diff --git a/gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c b/gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c new file mode 100644 index 000000000..f6dc5240f --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/self-assign-test-1.c @@ -0,0 +1,23 @@ +/* Test the self-assignemnt detection plugin. */ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +struct Bar { + int b_; + int c_; +}; + +int g; + +int main() +{ + struct Bar *bar; + int x = x; /* { dg-warning "assigned to itself" } */ + static int y; + struct Bar b_array[5]; + + b_array[x+g].b_ = b_array[x+g].b_; /* { dg-warning "self-assignment detected" } */ + g = g; /* { dg-warning "assigned to itself" } */ + y = y; /* { dg-warning "assigned to itself" } */ + bar->b_ = bar->b_; /* { dg-warning "assigned to itself" } */ +} diff --git a/gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c b/gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c new file mode 100644 index 000000000..2ede371a6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/self-assign-test-2.c @@ -0,0 +1,23 @@ +/* Test the self-assignemnt detection plugin with the 'disable' argument. */ +/* { dg-do compile } */ +/* { dg-options "-O -fplugin-arg-selfassign-disable" } */ + +struct Bar { + int b_; + int c_; +}; + +int g; + +int main() +{ + struct Bar *bar; + int x = x; /* { dg-bogus "assigned to itself" } */ + static int y; + struct Bar b_array[5]; + + b_array[x+g].b_ = b_array[x+g].b_; /* { dg-bogus "self-assignment detected" } */ + g = g; /* { dg-bogus "assigned to itself" } */ + y = y; /* { dg-bogus "assigned to itself" } */ + bar->b_ = bar->b_; /* { dg-bogus "assigned to itself" } */ +} diff --git a/gcc/testsuite/gcc.dg/plugin/selfassign.c b/gcc/testsuite/gcc.dg/plugin/selfassign.c new file mode 100644 index 000000000..84d2801d2 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/selfassign.c @@ -0,0 +1,366 @@ +/* This plugin contains an analysis pass that detects and warns about + self-assignment statements. */ +/* { dg-options "-O" } */ + +#include "gcc-plugin.h" +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "toplev.h" +#include "basic-block.h" +#include "gimple.h" +#include "tree.h" +#include "tree-pass.h" +#include "intl.h" +#include "plugin-version.h" +#include "diagnostic.h" + +int plugin_is_GPL_compatible; + +/* Indicate whether to check overloaded operator '=', which is performed by + default. To disable it, use -fplugin-arg-NAME-no-check-operator-eq. */ +bool check_operator_eq = true; + +/* Given a rhs EXPR of a gimple assign statement, if it is + - SSA_NAME : returns its var decl, or, if it is a temp variable, + returns the rhs of its SSA def statement. + - VAR_DECL, PARM_DECL, FIELD_DECL, or a reference expression : + returns EXPR itself. + - any other expression : returns NULL_TREE. */ + +static tree +get_real_ref_rhs (tree expr) +{ + switch (TREE_CODE (expr)) + { + case SSA_NAME: + { + /* Given a self-assign statement, say foo.x = foo.x, + the IR (after SSA) looks like: + + D.1797_14 = foo.x; + foo.x ={v} D.1797_14; + + So if the rhs EXPR is an SSA_NAME of a temp variable, + e.g. D.1797_14, we need to grab the rhs of its SSA def + statement (i.e. foo.x). */ + tree vdecl = SSA_NAME_VAR (expr); + if (DECL_ARTIFICIAL (vdecl) + && !gimple_nop_p (SSA_NAME_DEF_STMT (expr))) + { + gimple def_stmt = SSA_NAME_DEF_STMT (expr); + /* We are only interested in an assignment with a single + rhs operand because if it is not, the original assignment + will not possibly be a self-assignment. */ + if (gimple_assign_single_p (def_stmt)) + return get_real_ref_rhs (gimple_assign_rhs1 (def_stmt)); + else + return NULL_TREE; + } + else + return vdecl; + } + case VAR_DECL: + case PARM_DECL: + case FIELD_DECL: + case COMPONENT_REF: + case MEM_REF: + case ARRAY_REF: + return expr; + default: + return NULL_TREE; + } +} + +/* Given an expression tree, EXPR, that may contains SSA names, returns an + equivalent tree with the SSA names converted to var/parm/field decls + so that it can be used with '%E' format modifier when emitting warning + messages. + + This function currently only supports VAR/PARM/FIELD_DECL, reference + expressions (COMPONENT_REF, INDIRECT_REF, ARRAY_REF), integer constant, + and SSA_NAME. If EXPR contains any other tree nodes (e.g. an arithmetic + expression appears in array index), NULL_TREE is returned. */ + +static tree +get_non_ssa_expr (tree expr) +{ + switch (TREE_CODE (expr)) + { + case VAR_DECL: + case PARM_DECL: + case FIELD_DECL: + { + if (DECL_NAME (expr)) + return expr; + else + return NULL_TREE; + } + case COMPONENT_REF: + { + tree base, orig_base = TREE_OPERAND (expr, 0); + tree component, orig_component = TREE_OPERAND (expr, 1); + base = get_non_ssa_expr (orig_base); + if (!base) + return NULL_TREE; + component = get_non_ssa_expr (orig_component); + if (!component) + return NULL_TREE; + /* If either BASE or COMPONENT is converted, build a new + component reference tree. */ + if (base != orig_base || component != orig_component) + return build3 (COMPONENT_REF, TREE_TYPE (component), + base, component, NULL_TREE); + else + return expr; + } + case MEM_REF: + { + tree orig_base = TREE_OPERAND (expr, 0); + if (TREE_CODE (orig_base) == SSA_NAME) + { + tree base = get_non_ssa_expr (orig_base); + if (!base) + return NULL_TREE; + return fold_build2 (MEM_REF, TREE_TYPE (expr), + base, TREE_OPERAND (expr, 1)); + } + return expr; + } + case ARRAY_REF: + { + tree array, orig_array = TREE_OPERAND (expr, 0); + tree index, orig_index = TREE_OPERAND (expr, 1); + array = get_non_ssa_expr (orig_array); + if (!array) + return NULL_TREE; + index = get_non_ssa_expr (orig_index); + if (!index) + return NULL_TREE; + /* If either ARRAY or INDEX is converted, build a new array + reference tree. */ + if (array != orig_array || index != orig_index) + return build4 (ARRAY_REF, TREE_TYPE (expr), array, index, + TREE_OPERAND (expr, 2), TREE_OPERAND (expr, 3)); + else + return expr; + } + case SSA_NAME: + { + tree vdecl = SSA_NAME_VAR (expr); + if (DECL_ARTIFICIAL (vdecl) + && !gimple_nop_p (SSA_NAME_DEF_STMT (expr))) + { + gimple def_stmt = SSA_NAME_DEF_STMT (expr); + if (gimple_assign_single_p (def_stmt)) + vdecl = gimple_assign_rhs1 (def_stmt); + } + return get_non_ssa_expr (vdecl); + } + case INTEGER_CST: + return expr; + default: + /* Return NULL_TREE for any other kind of tree nodes. */ + return NULL_TREE; + } +} + +/* Given the LHS and (real) RHS of a gimple assign statement, STMT, check if + they are the same. If so, print a warning message about self-assignment. */ + +static void +compare_and_warn (gimple stmt, tree lhs, tree rhs) +{ + if (operand_equal_p (lhs, rhs, OEP_PURE_SAME)) + { + location_t location; + location = (gimple_has_location (stmt) + ? gimple_location (stmt) + : (DECL_P (lhs) + ? DECL_SOURCE_LOCATION (lhs) + : input_location)); + /* If LHS contains any tree node not currently supported by + get_non_ssa_expr, simply emit a generic warning without + specifying LHS in the message. */ + lhs = get_non_ssa_expr (lhs); + if (lhs) + warning_at (location, 0, G_("%qE is assigned to itself"), lhs); + else + warning_at (location, 0, G_("self-assignment detected")); + } +} + +/* Check and warn if STMT is a self-assign statement. */ + +static void +warn_self_assign (gimple stmt) +{ + tree rhs, lhs; + + /* Check assigment statement. */ + if (gimple_assign_single_p (stmt)) + { + rhs = get_real_ref_rhs (gimple_assign_rhs1 (stmt)); + if (!rhs) + return; + + lhs = gimple_assign_lhs (stmt); + if (TREE_CODE (lhs) == SSA_NAME) + { + lhs = SSA_NAME_VAR (lhs); + if (DECL_ARTIFICIAL (lhs)) + return; + } + + compare_and_warn (stmt, lhs, rhs); + } + /* Check overloaded operator '=' (if enabled). */ + else if (check_operator_eq && is_gimple_call (stmt)) + { + tree fdecl = gimple_call_fndecl (stmt); + if (fdecl && (DECL_NAME (fdecl) == maybe_get_identifier ("operator="))) + { + /* If 'operator=' takes reference operands, the arguments will be + ADDR_EXPR trees. In this case, just remove the address-taken + operator before we compare the lhs and rhs. */ + lhs = gimple_call_arg (stmt, 0); + if (TREE_CODE (lhs) == ADDR_EXPR) + lhs = TREE_OPERAND (lhs, 0); + rhs = gimple_call_arg (stmt, 1); + if (TREE_CODE (rhs) == ADDR_EXPR) + rhs = TREE_OPERAND (rhs, 0); + + compare_and_warn (stmt, lhs, rhs); + } + } +} + +/* Entry point for the self-assignment detection pass. */ + +static unsigned int +execute_warn_self_assign (void) +{ + gimple_stmt_iterator gsi; + basic_block bb; + + FOR_EACH_BB (bb) + { + for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) + warn_self_assign (gsi_stmt (gsi)); + } + + return 0; +} + +/* Pass gate function. Currently always returns true. */ + +static bool +gate_warn_self_assign (void) +{ + return true; +} + +static struct gimple_opt_pass pass_warn_self_assign = +{ + { + GIMPLE_PASS, + "warn_self_assign", /* name */ + gate_warn_self_assign, /* gate */ + execute_warn_self_assign, /* execute */ + NULL, /* sub */ + NULL, /* next */ + 0, /* static_pass_number */ + TV_NONE, /* tv_id */ + PROP_ssa, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } +}; + +/* The initialization routine exposed to and called by GCC. The spec of this + function is defined in gcc/gcc-plugin.h. + + PLUGIN_NAME - name of the plugin (useful for error reporting) + ARGC - the size of the ARGV array + ARGV - an array of key-value argument pair + + Returns 0 if initialization finishes successfully. + + Note that this function needs to be named exactly "plugin_init". */ + +int +plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version) +{ + struct register_pass_info pass_info; + const char *plugin_name = plugin_info->base_name; + int argc = plugin_info->argc; + struct plugin_argument *argv = plugin_info->argv; + bool enabled = true; + int i; + + if (!plugin_default_version_check (version, &gcc_version)) + return 1; + + /* Self-assign detection should happen after SSA is constructed. */ + pass_info.pass = &pass_warn_self_assign.pass; + pass_info.reference_pass_name = "ssa"; + pass_info.ref_pass_instance_number = 1; + pass_info.pos_op = PASS_POS_INSERT_AFTER; + + /* Process the plugin arguments. This plugin takes the following arguments: + check-operator-eq, no-check-operator-eq, enable, and disable. + By default, the analysis is enabled with 'operator=' checked. */ + for (i = 0; i < argc; ++i) + { + if (!strcmp (argv[i].key, "check-operator-eq")) + { + if (argv[i].value) + warning (0, G_("option '-fplugin-arg-%s-check-operator-eq=%s'" + " ignored (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + check_operator_eq = true; + } + else if (!strcmp (argv[i].key, "no-check-operator-eq")) + { + if (argv[i].value) + warning (0, G_("option '-fplugin-arg-%s-no-check-operator-eq=%s'" + " ignored (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + check_operator_eq = false; + } + else if (!strcmp (argv[i].key, "enable")) + { + if (argv[i].value) + warning (0, G_("option '-fplugin-arg-%s-enable=%s' ignored" + " (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + enabled = true; + } + else if (!strcmp (argv[i].key, "disable")) + { + if (argv[i].value) + warning (0, G_("option '-fplugin-arg-%s-disable=%s' ignored" + " (superfluous '=%s')"), + plugin_name, argv[i].value, argv[i].value); + else + enabled = false; + } + else + warning (0, G_("plugin %qs: unrecognized argument %qs ignored"), + plugin_name, argv[i].key); + } + + /* Register this new pass with GCC if the analysis is enabled. */ + if (enabled) + register_callback (plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL, + &pass_info); + + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c b/gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c new file mode 100644 index 000000000..4cd8a40f4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/start_unit-test-1.c @@ -0,0 +1,7 @@ +/* { dg-do compile } */ +/* { dg-options "-O" } */ + +int main (int argc, char **argv) +{ + return 0; +} diff --git a/gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c b/gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c new file mode 100644 index 000000000..5b16e84a4 --- /dev/null +++ b/gcc/testsuite/gcc.dg/plugin/start_unit_plugin.c @@ -0,0 +1,66 @@ +/* This plugin tests the correct operation of a PLUGIN_START_UNIT callback. + * By the time a PLUGIN_START_UNIT callback is invoked, the frontend + * initialization should have completed. At least the different *_type_nodes + * should have been created. This plugin creates an artifical global + * interger variable. + * +*/ +#include "gcc-plugin.h" +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "toplev.h" +#include "basic-block.h" +#include "gimple.h" +#include "tree.h" +#include "tree-pass.h" +#include "intl.h" + +int plugin_is_GPL_compatible; +static tree fake_var = NULL; + +static bool +gate_start_unit (void) +{ + return true; +} + +static void start_unit_callback (void *gcc_data, void *user_data) +{ + if (integer_type_node) { + fake_var = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier ("_fake_var_"), + integer_type_node); + TREE_PUBLIC (fake_var) = 1; + DECL_ARTIFICIAL (fake_var) = 1; + } +} + +static void finish_unit_callback (void *gcc_data, void *user_data) +{ + if (fake_var == NULL) { + printf ("fake_var not created \n"); + return; + } + if (TREE_CODE (fake_var) != VAR_DECL) { + printf ("fake_var not a VAR_DECL \n"); + return; + } + if (TREE_CODE (TREE_TYPE (fake_var)) != INTEGER_TYPE) { + printf ("fake_var not INTEGER_TYPE \n"); + return; + } + if (DECL_ARTIFICIAL (fake_var) == 0) { + printf ("fake_var not ARTIFICIAL \n"); + return; + } +} + +int plugin_init (struct plugin_name_args *plugin_info, + struct plugin_gcc_version *version) +{ + register_callback ("start_unit", PLUGIN_START_UNIT, &start_unit_callback, NULL); + register_callback ("finish_unit", PLUGIN_FINISH_UNIT, &finish_unit_callback, NULL); + return 0; +} |