OSDN Git Service

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