gcc/testsuite/gcc.dg/plugin/selfassign.c

   1 /* This plugin contains an analysis pass that detects and warns about
   2    self-assignment statements.  */
   3 /* { dg-options "-O" } */
   4
   5 #include "gcc-plugin.h"
   6 #include "config.h"
   7 #include "system.h"
   8 #include "coretypes.h"
   9 #include "tm.h"
  10 #include "toplev.h"
  11 #include "basic-block.h"
  12 #include "gimple.h"
  13 #include "tree.h"
  14 #include "tree-pass.h"
  15 #include "intl.h"
  16
  17
  18 int plugin_is_GPL_compatible;
  19
  20 /* Indicate whether to check overloaded operator '=', which is performed by
  21    default. To disable it, use -fplugin-arg-NAME-no-check-operator-eq.  */
  22 bool check_operator_eq = true;
  23
  24 /* Given a rhs EXPR of a gimple assign statement, if it is
  25    - SSA_NAME : returns its var decl, or, if it is a temp variable,
  26                 returns the rhs of its SSA def statement.
  27    - VAR_DECL, PARM_DECL, FIELD_DECL, or a reference expression :
  28                 returns EXPR itself.
  29    - any other expression : returns NULL_TREE.  */
  30
  31 static tree
  32 get_real_ref_rhs (tree expr)
  33 {
  34   switch (TREE_CODE (expr))
  35     {
  36       case SSA_NAME:
  37         {
  38           /* Given a self-assign statement, say foo.x = foo.x,
  39              the IR (after SSA) looks like:
  40
  41              D.1797_14 = foo.x;
  42              foo.x ={v} D.1797_14;
  43
  44              So if the rhs EXPR is an SSA_NAME of a temp variable,
  45              e.g. D.1797_14, we need to grab the rhs of its SSA def
  46              statement (i.e. foo.x).  */
  47           tree vdecl = SSA_NAME_VAR (expr);
  48           if (DECL_ARTIFICIAL (vdecl)
  49               && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
  50             {
  51               gimple def_stmt = SSA_NAME_DEF_STMT (expr);
  52               /* We are only interested in an assignment with a single
  53                  rhs operand because if it is not, the original assignment
  54                  will not possibly be a self-assignment.  */
  55               if (is_gimple_assign (def_stmt)
  56                   && (get_gimple_rhs_class (gimple_assign_rhs_code (def_stmt))
  57                       == GIMPLE_SINGLE_RHS))
  58                 return get_real_ref_rhs (gimple_assign_rhs1 (def_stmt));
  59               else
  60                 return NULL_TREE;
  61             }
  62           else
  63             return vdecl;
  64         }
  65       case VAR_DECL:
  66       case PARM_DECL:
  67       case FIELD_DECL:
  68       case COMPONENT_REF:
  69       case INDIRECT_REF:
  70       case ARRAY_REF:
  71         return expr;
  72       default:
  73         return NULL_TREE;
  74     }
  75 }
  76
  77 /* Given an expression tree, EXPR, that may contains SSA names, returns an
  78    equivalent tree with the SSA names converted to var/parm/field decls
  79    so that it can be used with '%E' format modifier when emitting warning
  80    messages.
  81
  82    This function currently only supports VAR/PARM/FIELD_DECL, reference
  83    expressions (COMPONENT_REF, INDIRECT_REF, ARRAY_REF), integer constant,
  84    and SSA_NAME. If EXPR contains any other tree nodes (e.g. an arithmetic
  85    expression appears in array index), NULL_TREE is returned.  */
  86
  87 static tree
  88 get_non_ssa_expr (tree expr)
  89 {
  90   switch (TREE_CODE (expr))
  91     {
  92       case VAR_DECL:
  93       case PARM_DECL:
  94       case FIELD_DECL:
  95         {
  96           if (DECL_NAME (expr))
  97             return expr;
  98           else
  99             return NULL_TREE;
 100         }
 101       case COMPONENT_REF:
 102         {
 103           tree base, orig_base = TREE_OPERAND (expr, 0);
 104           tree component, orig_component = TREE_OPERAND (expr, 1);
 105           base = get_non_ssa_expr (orig_base);
 106           if (!base)
 107             return NULL_TREE;
 108           component = get_non_ssa_expr (orig_component);
 109           if (!component)
 110             return NULL_TREE;
 111           /* If either BASE or COMPONENT is converted, build a new
 112              component reference tree.  */
 113           if (base != orig_base || component != orig_component)
 114             return build3 (COMPONENT_REF, TREE_TYPE (component),
 115                            base, component, NULL_TREE);
 116           else
 117             return expr;
 118         }
 119       case INDIRECT_REF:
 120         {
 121           tree orig_base = TREE_OPERAND (expr, 0);
 122           tree base = get_non_ssa_expr (orig_base);
 123           if (!base)
 124             return NULL_TREE;
 125           /* If BASE is converted, build a new indirect reference tree.  */
 126           if (base != orig_base)
 127             return build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (base)), base);
 128           else
 129             return expr;
 130         }
 131       case ARRAY_REF:
 132         {
 133           tree array, orig_array = TREE_OPERAND (expr, 0);
 134           tree index, orig_index = TREE_OPERAND (expr, 1);
 135           array = get_non_ssa_expr (orig_array);
 136           if (!array)
 137             return NULL_TREE;
 138           index = get_non_ssa_expr (orig_index);
 139           if (!index)
 140             return NULL_TREE;
 141           /* If either ARRAY or INDEX is converted, build a new array
 142              reference tree.  */
 143           if (array != orig_array || index != orig_index)
 144             return build4 (ARRAY_REF, TREE_TYPE (expr), array, index,
 145                            TREE_OPERAND (expr, 2), TREE_OPERAND (expr, 3));
 146           else
 147             return expr;
 148         }
 149       case SSA_NAME:
 150         {
 151           tree vdecl = SSA_NAME_VAR (expr);
 152           if (DECL_ARTIFICIAL (vdecl)
 153               && !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))
 154             {
 155               gimple def_stmt = SSA_NAME_DEF_STMT (expr);
 156               if (is_gimple_assign (def_stmt)
 157                   && (get_gimple_rhs_class (gimple_assign_rhs_code (def_stmt))
 158                       == GIMPLE_SINGLE_RHS))
 159                 vdecl = gimple_assign_rhs1 (def_stmt);
 160             }
 161           return get_non_ssa_expr (vdecl);
 162         }
 163       case INTEGER_CST:
 164         return expr;
 165       default:
 166         /* Return NULL_TREE for any other kind of tree nodes.  */
 167         return NULL_TREE;
 168     }
 169 }
 170
 171 /* Given the LHS and (real) RHS of a gimple assign statement, STMT, check if
 172    they are the same. If so, print a warning message about self-assignment.  */
 173
 174 static void
 175 compare_and_warn (gimple stmt, tree lhs, tree rhs)
 176 {
 177   if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))
 178     {
 179       location_t location;
 180       location = (gimple_has_location (stmt)
 181                   ? gimple_location (stmt)
 182                   : (DECL_P (lhs)
 183                      ? DECL_SOURCE_LOCATION (lhs)
 184                      : input_location));
 185       /* If LHS contains any tree node not currently supported by
 186          get_non_ssa_expr, simply emit a generic warning without
 187          specifying LHS in the message.  */
 188       lhs = get_non_ssa_expr (lhs);
 189       if (lhs)
 190         warning_at (location, 0, G_("%qE is assigned to itself"), lhs);
 191       else
 192         warning_at (location, 0, G_("self-assignment detected"));
 193     }
 194 }
 195
 196 /* Check and warn if STMT is a self-assign statement.  */
 197
 198 static void
 199 warn_self_assign (gimple stmt)
 200 {
 201   tree rhs, lhs;
 202
 203   /* Check assigment statement.  */
 204   if (is_gimple_assign (stmt)
 205       && (get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
 206           == GIMPLE_SINGLE_RHS))
 207     {
 208       rhs = get_real_ref_rhs (gimple_assign_rhs1 (stmt));
 209       if (!rhs)
 210         return;
 211
 212       lhs = gimple_assign_lhs (stmt);
 213       if (TREE_CODE (lhs) == SSA_NAME)
 214         {
 215           lhs = SSA_NAME_VAR (lhs);
 216           if (DECL_ARTIFICIAL (lhs))
 217             return;
 218         }
 219
 220       compare_and_warn (stmt, lhs, rhs);
 221     }
 222   /* Check overloaded operator '=' (if enabled).  */
 223   else if (check_operator_eq && is_gimple_call (stmt))
 224     {
 225       tree fdecl = gimple_call_fndecl (stmt);
 226       if (fdecl && (DECL_NAME (fdecl) == maybe_get_identifier ("operator=")))
 227         {
 228           /* If 'operator=' takes reference operands, the arguments will be
 229              ADDR_EXPR trees. In this case, just remove the address-taken
 230              operator before we compare the lhs and rhs.  */
 231           lhs = gimple_call_arg (stmt, 0);
 232           if (TREE_CODE (lhs) == ADDR_EXPR)
 233             lhs = TREE_OPERAND (lhs, 0);
 234           rhs = gimple_call_arg (stmt, 1);
 235           if (TREE_CODE (rhs) == ADDR_EXPR)
 236             rhs = TREE_OPERAND (rhs, 0);
 237
 238           compare_and_warn (stmt, lhs, rhs);
 239         }
 240     }
 241 }
 242
 243 /* Entry point for the self-assignment detection pass.  */
 244
 245 static unsigned int
 246 execute_warn_self_assign (void)
 247 {
 248   gimple_stmt_iterator gsi;
 249   basic_block bb;
 250
 251   FOR_EACH_BB (bb)
 252     {
 253       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 254         warn_self_assign (gsi_stmt (gsi));
 255     }
 256
 257   return 0;
 258 }
 259
 260 /* Pass gate function. Currently always returns true.  */
 261
 262 static bool
 263 gate_warn_self_assign (void)
 264 {
 265   return true;
 266 }
 267
 268 static struct gimple_opt_pass pass_warn_self_assign =
 269 {
 270   {
 271     GIMPLE_PASS,
 272     "warn_self_assign",                   /* name */
 273     gate_warn_self_assign,                /* gate */
 274     execute_warn_self_assign,             /* execute */
 275     NULL,                                 /* sub */
 276     NULL,                                 /* next */
 277     0,                                    /* static_pass_number */
 278     0,                                    /* tv_id */
 279     PROP_ssa,                             /* properties_required */
 280     0,                                    /* properties_provided */
 281     0,                                    /* properties_destroyed */
 282     0,                                    /* todo_flags_start */
 283     TODO_dump_func                        /* todo_flags_finish */
 284   }
 285 };
 286
 287 /* The initialization routine exposed to and called by GCC. The spec of this
 288    function is defined in gcc/gcc-plugin.h.
 289
 290    PLUGIN_NAME - name of the plugin (useful for error reporting)
 291    ARGC        - the size of the ARGV array
 292    ARGV        - an array of key-value argument pair
 293
 294    Returns 0 if initialization finishes successfully.
 295
 296    Note that this function needs to be named exactly "plugin_init".  */
 297
 298 int
 299 plugin_init (struct plugin_name_args *plugin_info,
 300              struct plugin_gcc_version *version)
 301 {
 302   struct register_pass_info pass_info;
 303   const char *plugin_name = plugin_info->base_name;
 304   int argc = plugin_info->argc;
 305   struct plugin_argument *argv = plugin_info->argv;
 306   bool enabled = true;
 307   int i;
 308
 309   if (!plugin_default_version_check (version, version))
 310     return 1;
 311
 312   /* Self-assign detection should happen after SSA is constructed.  */
 313   pass_info.pass = &pass_warn_self_assign.pass;
 314   pass_info.reference_pass_name = "ssa";
 315   pass_info.ref_pass_instance_number = 1;
 316   pass_info.pos_op = PASS_POS_INSERT_AFTER;
 317
 318   /* Process the plugin arguments. This plugin takes the following arguments:
 319      check-operator-eq, no-check-operator-eq, enable, and disable.
 320      By default, the analysis is enabled with 'operator=' checked.  */
 321   for (i = 0; i < argc; ++i)
 322     {
 323       if (!strcmp (argv[i].key, "check-operator-eq"))
 324         {
 325           if (argv[i].value)
 326             warning (0, G_("option '-fplugin-arg-%s-check-operator-eq=%s'"
 327                            " ignored (superfluous '=%s')"),
 328                      plugin_name, argv[i].value, argv[i].value);
 329           else
 330             check_operator_eq = true;
 331         }
 332       else if (!strcmp (argv[i].key, "no-check-operator-eq"))
 333         {
 334           if (argv[i].value)
 335             warning (0, G_("option '-fplugin-arg-%s-no-check-operator-eq=%s'"
 336                            " ignored (superfluous '=%s')"),
 337                      plugin_name, argv[i].value, argv[i].value);
 338           else
 339             check_operator_eq = false;
 340         }
 341       else if (!strcmp (argv[i].key, "enable"))
 342         {
 343           if (argv[i].value)
 344             warning (0, G_("option '-fplugin-arg-%s-enable=%s' ignored"
 345                            " (superfluous '=%s')"),
 346                      plugin_name, argv[i].value, argv[i].value);
 347           else
 348             enabled = true;
 349         }
 350       else if (!strcmp (argv[i].key, "disable"))
 351         {
 352           if (argv[i].value)
 353             warning (0, G_("option '-fplugin-arg-%s-disable=%s' ignored"
 354                            " (superfluous '=%s')"),
 355                      plugin_name, argv[i].value, argv[i].value);
 356           else
 357             enabled = false;
 358         }
 359       else
 360         warning (0, G_("plugin %qs: unrecognized argument %qs ignored"),
 361                  plugin_name, argv[i].key);
 362     }
 363
 364   /* Register this new pass with GCC if the analysis is enabled.  */
 365   if (enabled)
 366     register_callback (plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL,
 367                        &pass_info);
 368
 369   return 0;
 370 }