URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [plugin/] [selfassign.c] - Blame information for rev 713

Go to most recent revision | Details | Compare with Previous | View Log


/* 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;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [g++.dg/] [plugin/] [selfassign.c] - Blame information for rev 713

Line No.	Rev	Author	Line
1	693	jeremybenn	`/* 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			`#include "plugin-version.h"`
17			`#include "diagnostic.h"`
18
19			`int plugin_is_GPL_compatible;`
20
21			`/* Indicate whether to check overloaded operator '=', which is performed by`
22			`default. To disable it, use -fplugin-arg-NAME-no-check-operator-eq. */`
23			`bool check_operator_eq = true;`
24
25			`/* Given a rhs EXPR of a gimple assign statement, if it is`
26			`- SSA_NAME : returns its var decl, or, if it is a temp variable,`
27			`returns the rhs of its SSA def statement.`
28			`- VAR_DECL, PARM_DECL, FIELD_DECL, or a reference expression :`
29			`returns EXPR itself.`
30			`- any other expression : returns NULL_TREE. */`
31
32			`static tree`
33			`get_real_ref_rhs (tree expr)`
34			`{`
35			`switch (TREE_CODE (expr))`
36			`{`
37			`case SSA_NAME:`
38			`{`
39			`/* Given a self-assign statement, say foo.x = foo.x,`
40			`the IR (after SSA) looks like:`
41
42			`D.1797_14 = foo.x;`
43			`foo.x ={v} D.1797_14;`
44
45			`So if the rhs EXPR is an SSA_NAME of a temp variable,`
46			`e.g. D.1797_14, we need to grab the rhs of its SSA def`
47			`statement (i.e. foo.x). */`
48			`tree vdecl = SSA_NAME_VAR (expr);`
49			`if (DECL_ARTIFICIAL (vdecl)`
50			`&& !gimple_nop_p (SSA_NAME_DEF_STMT (expr)))`
51			`{`
52			`gimple def_stmt = SSA_NAME_DEF_STMT (expr);`
53			`/* We are only interested in an assignment with a single`
54			`rhs operand because if it is not, the original assignment`
55			`will not possibly be a self-assignment. */`
56			`if (gimple_assign_single_p (def_stmt))`
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 MEM_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 MEM_REF:`
119			`{`
120			`tree orig_base = TREE_OPERAND (expr, 0);`
121			`if (TREE_CODE (orig_base) == SSA_NAME)`
122			`{`
123			`tree base = get_non_ssa_expr (orig_base);`
124			`if (!base)`
125			`return NULL_TREE;`
126			`return fold_build2 (MEM_REF, TREE_TYPE (expr),`
127			`base, TREE_OPERAND (expr, 1));`
128			`}`
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 (gimple_assign_single_p (def_stmt))`
157			`vdecl = gimple_assign_rhs1 (def_stmt);`
158			`}`
159			`return get_non_ssa_expr (vdecl);`
160			`}`
161			`case INTEGER_CST:`
162			`return expr;`
163			`default:`
164			`/* Return NULL_TREE for any other kind of tree nodes. */`
165			`return NULL_TREE;`
166			`}`
167			`}`
168
169			`/* Given the LHS and (real) RHS of a gimple assign statement, STMT, check if`
170			`they are the same. If so, print a warning message about self-assignment. */`
171
172			`static void`
173			`compare_and_warn (gimple stmt, tree lhs, tree rhs)`
174			`{`
175			`if (operand_equal_p (lhs, rhs, OEP_PURE_SAME))`
176			`{`
177			`location_t location;`
178			`location = (gimple_has_location (stmt)`
179			`? gimple_location (stmt)`
180			`: (DECL_P (lhs)`
181			`? DECL_SOURCE_LOCATION (lhs)`
182			`: input_location));`
183			`/* If LHS contains any tree node not currently supported by`
184			`get_non_ssa_expr, simply emit a generic warning without`
185			`specifying LHS in the message. */`
186			`lhs = get_non_ssa_expr (lhs);`
187			`if (lhs)`
188			`warning_at (location, 0, G_("%qE is assigned to itself"), lhs);`
189			`else`
190			`warning_at (location, 0, G_("self-assignment detected"));`
191			`}`
192			`}`
193
194			`/* Check and warn if STMT is a self-assign statement. */`
195
196			`static void`
197			`warn_self_assign (gimple stmt)`
198			`{`
199			`tree rhs, lhs;`
200
201			`/* Check assigment statement. */`
202			`if (gimple_assign_single_p (stmt))`
203			`{`
204			`rhs = get_real_ref_rhs (gimple_assign_rhs1 (stmt));`
205			`if (!rhs)`
206			`return;`
207
208			`lhs = gimple_assign_lhs (stmt);`
209			`if (TREE_CODE (lhs) == SSA_NAME)`
210			`{`
211			`lhs = SSA_NAME_VAR (lhs);`
212			`if (DECL_ARTIFICIAL (lhs))`
213			`return;`
214			`}`
215
216			`compare_and_warn (stmt, lhs, rhs);`
217			`}`
218			`/* Check overloaded operator '=' (if enabled). */`
219			`else if (check_operator_eq && is_gimple_call (stmt))`
220			`{`
221			`tree fdecl = gimple_call_fndecl (stmt);`
222			`if (fdecl && (DECL_NAME (fdecl) == maybe_get_identifier ("operator=")))`
223			`{`
224			`/* If 'operator=' takes reference operands, the arguments will be`
225			`ADDR_EXPR trees. In this case, just remove the address-taken`
226			`operator before we compare the lhs and rhs. */`
227			`lhs = gimple_call_arg (stmt, 0);`
228			`if (TREE_CODE (lhs) == ADDR_EXPR)`
229			`lhs = TREE_OPERAND (lhs, 0);`
230			`rhs = gimple_call_arg (stmt, 1);`
231			`if (TREE_CODE (rhs) == ADDR_EXPR)`
232			`rhs = TREE_OPERAND (rhs, 0);`
233
234			`compare_and_warn (stmt, lhs, rhs);`
235			`}`
236			`}`
237			`}`
238
239			`/* Entry point for the self-assignment detection pass. */`
240
241			`static unsigned int`
242			`execute_warn_self_assign (void)`
243			`{`
244			`gimple_stmt_iterator gsi;`
245			`basic_block bb;`
246
247			`FOR_EACH_BB (bb)`
248			`{`
249			`for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))`
250			`warn_self_assign (gsi_stmt (gsi));`
251			`}`
252
253			`return 0;`
254			`}`
255
256			`/* Pass gate function. Currently always returns true. */`
257
258			`static bool`
259			`gate_warn_self_assign (void)`
260			`{`
261			`return true;`
262			`}`
263
264			`static struct gimple_opt_pass pass_warn_self_assign =`
265			`{`
266			`{`
267			`GIMPLE_PASS,`
268			`"warn_self_assign", /* name */`
269			`gate_warn_self_assign, /* gate */`
270			`execute_warn_self_assign, /* execute */`
271			`NULL, /* sub */`
272			`NULL, /* next */`
273			`0, /* static_pass_number */`
274			`TV_NONE, /* tv_id */`
275			`PROP_ssa, /* properties_required */`
276			`0, /* properties_provided */`
277			`0, /* properties_destroyed */`
278			`0, /* todo_flags_start */`
279			`TODO_dump_func /* todo_flags_finish */`
280			`}`
281			`};`
282
283			`/* The initialization routine exposed to and called by GCC. The spec of this`
284			`function is defined in gcc/gcc-plugin.h.`
285
286			`PLUGIN_NAME - name of the plugin (useful for error reporting)`
287			`ARGC - the size of the ARGV array`
288			`ARGV - an array of key-value argument pair`
289
290			`Returns 0 if initialization finishes successfully.`
291
292			`Note that this function needs to be named exactly "plugin_init". */`
293
294			`int`
295			`plugin_init (struct plugin_name_args *plugin_info,`
296			`struct plugin_gcc_version *version)`
297			`{`
298			`struct register_pass_info pass_info;`
299			`const char *plugin_name = plugin_info->base_name;`
300			`int argc = plugin_info->argc;`
301			`struct plugin_argument *argv = plugin_info->argv;`
302			`bool enabled = true;`
303			`int i;`
304
305			`if (!plugin_default_version_check (version, &gcc_version))`
306			`return 1;`
307
308			`/* Self-assign detection should happen after SSA is constructed. */`
309			`pass_info.pass = &pass_warn_self_assign.pass;`
310			`pass_info.reference_pass_name = "ssa";`
311			`pass_info.ref_pass_instance_number = 1;`
312			`pass_info.pos_op = PASS_POS_INSERT_AFTER;`
313
314			`/* Process the plugin arguments. This plugin takes the following arguments:`
315			`check-operator-eq, no-check-operator-eq, enable, and disable.`
316			`By default, the analysis is enabled with 'operator=' checked. */`
317			`for (i = 0; i < argc; ++i)`
318			`{`
319			`if (!strcmp (argv[i].key, "check-operator-eq"))`
320			`{`
321			`if (argv[i].value)`
322			`warning (0, G_("option '-fplugin-arg-%s-check-operator-eq=%s'"`
323			`" ignored (superfluous '=%s')"),`
324			`plugin_name, argv[i].value, argv[i].value);`
325			`else`
326			`check_operator_eq = true;`
327			`}`
328			`else if (!strcmp (argv[i].key, "no-check-operator-eq"))`
329			`{`
330			`if (argv[i].value)`
331			`warning (0, G_("option '-fplugin-arg-%s-no-check-operator-eq=%s'"`
332			`" ignored (superfluous '=%s')"),`
333			`plugin_name, argv[i].value, argv[i].value);`
334			`else`
335			`check_operator_eq = false;`
336			`}`
337			`else if (!strcmp (argv[i].key, "enable"))`
338			`{`
339			`if (argv[i].value)`
340			`warning (0, G_("option '-fplugin-arg-%s-enable=%s' ignored"`
341			`" (superfluous '=%s')"),`
342			`plugin_name, argv[i].value, argv[i].value);`
343			`else`
344			`enabled = true;`
345			`}`
346			`else if (!strcmp (argv[i].key, "disable"))`
347			`{`
348			`if (argv[i].value)`
349			`warning (0, G_("option '-fplugin-arg-%s-disable=%s' ignored"`
350			`" (superfluous '=%s')"),`
351			`plugin_name, argv[i].value, argv[i].value);`
352			`else`
353			`enabled = false;`
354			`}`
355			`else`
356			`warning (0, G_("plugin %qs: unrecognized argument %qs ignored"),`
357			`plugin_name, argv[i].key);`
358			`}`
359
360			`/* Register this new pass with GCC if the analysis is enabled. */`
361			`if (enabled)`
362			`register_callback (plugin_name, PLUGIN_PASS_MANAGER_SETUP, NULL,`
363			`&pass_info);`
364
365			`return 0;`
366			`}`