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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [tree-gimple.c] - Blame information for rev 816

Details | Compare with Previous | View Log


/* Functions to analyze and validate GIMPLE trees.
   Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
   Contributed by Diego Novillo <dnovillo@redhat.com>
   Rewritten by Jason Merrill <jason@redhat.com>
 
This file is part of GCC.
 
GCC 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, or (at your option)
any later version.
 
GCC 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/>.  */
 
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "ggc.h"
#include "tm.h"
#include "tree.h"
#include "tree-gimple.h"
#include "tree-flow.h"
#include "output.h"
#include "rtl.h"
#include "expr.h"
#include "bitmap.h"
 
/* For the definitive definition of GIMPLE, see doc/tree-ssa.texi.  */
 
/* Validation of GIMPLE expressions.  */
 
/* Return true if T is a GIMPLE RHS for an assignment to a temporary.  */
 
bool
is_gimple_formal_tmp_rhs (tree t)
{
  enum tree_code code = TREE_CODE (t);
 
  switch (TREE_CODE_CLASS (code))
    {
    case tcc_unary:
    case tcc_binary:
    case tcc_comparison:
      return true;
 
    default:
      break;
    }
 
  switch (code)
    {
    case TRUTH_NOT_EXPR:
    case TRUTH_AND_EXPR:
    case TRUTH_OR_EXPR:
    case TRUTH_XOR_EXPR:
    case ADDR_EXPR:
    case CALL_EXPR:
    case CONSTRUCTOR:
    case COMPLEX_EXPR:
    case INTEGER_CST:
    case REAL_CST:
    case STRING_CST:
    case COMPLEX_CST:
    case VECTOR_CST:
    case OBJ_TYPE_REF:
    case ASSERT_EXPR:
      return true;
 
    default:
      break;
    }
 
  return is_gimple_lvalue (t) || is_gimple_val (t);
}
 
/* Returns true iff T is a valid RHS for an assignment to a renamed
   user -- or front-end generated artificial -- variable.  */
 
bool
is_gimple_reg_rhs (tree t)
{
  /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
     and the LHS is a user variable, then we need to introduce a formal
     temporary.  This way the optimizers can determine that the user
     variable is only modified if evaluation of the RHS does not throw.
 
     Don't force a temp of a non-renamable type; the copy could be
     arbitrarily expensive.  Instead we will generate a V_MAY_DEF for
     the assignment.  */
 
  if (is_gimple_reg_type (TREE_TYPE (t))
      && ((TREE_CODE (t) == CALL_EXPR && TREE_SIDE_EFFECTS (t))
          || tree_could_throw_p (t)))
    return false;
 
  return is_gimple_formal_tmp_rhs (t);
}
 
/* Returns true iff T is a valid RHS for an assignment to an un-renamed
   LHS, or for a call argument.  */
 
bool
is_gimple_mem_rhs (tree t)
{
  /* If we're dealing with a renamable type, either source or dest must be
     a renamed variable.  Also force a temporary if the type doesn't need
     to be stored in memory, since it's cheap and prevents erroneous
     tailcalls (PR 17526).  */
  if (is_gimple_reg_type (TREE_TYPE (t))
      || (TYPE_MODE (TREE_TYPE (t)) != BLKmode
          && (TREE_CODE (t) != CALL_EXPR
              || ! aggregate_value_p (t, t))))
    return is_gimple_val (t);
  else
    return is_gimple_formal_tmp_rhs (t);
}
 
/* Returns the appropriate RHS predicate for this LHS.  */
 
gimple_predicate
rhs_predicate_for (tree lhs)
{
  if (is_gimple_formal_tmp_var (lhs))
    return is_gimple_formal_tmp_rhs;
  else if (is_gimple_reg (lhs))
    return is_gimple_reg_rhs;
  else
    return is_gimple_mem_rhs;
}
 
/*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
 
bool
is_gimple_lvalue (tree t)
{
  return (is_gimple_addressable (t)
          || TREE_CODE (t) == WITH_SIZE_EXPR
          /* These are complex lvalues, but don't have addresses, so they
             go here.  */
          || TREE_CODE (t) == BIT_FIELD_REF);
}
 
/*  Return true if T is a GIMPLE condition.  */
 
bool
is_gimple_condexpr (tree t)
{
  return (is_gimple_val (t) || COMPARISON_CLASS_P (t));
}
 
/*  Return true if T is something whose address can be taken.  */
 
bool
is_gimple_addressable (tree t)
{
  return (is_gimple_id (t) || handled_component_p (t)
          || INDIRECT_REF_P (t));
}
 
/* Return true if T is function invariant.  Or rather a restricted
   form of function invariant.  */
 
bool
is_gimple_min_invariant (tree t)
{
  switch (TREE_CODE (t))
    {
    case ADDR_EXPR:
      return TREE_INVARIANT (t);
 
    case INTEGER_CST:
    case REAL_CST:
    case STRING_CST:
    case COMPLEX_CST:
    case VECTOR_CST:
      return true;
 
    default:
      return false;
    }
}
 
/* Return true if T looks like a valid GIMPLE statement.  */
 
bool
is_gimple_stmt (tree t)
{
  enum tree_code code = TREE_CODE (t);
 
  switch (code)
    {
    case NOP_EXPR:
      /* The only valid NOP_EXPR is the empty statement.  */
      return IS_EMPTY_STMT (t);
 
    case BIND_EXPR:
    case COND_EXPR:
      /* These are only valid if they're void.  */
      return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
 
    case SWITCH_EXPR:
    case GOTO_EXPR:
    case RETURN_EXPR:
    case LABEL_EXPR:
    case CASE_LABEL_EXPR:
    case TRY_CATCH_EXPR:
    case TRY_FINALLY_EXPR:
    case EH_FILTER_EXPR:
    case CATCH_EXPR:
    case ASM_EXPR:
    case RESX_EXPR:
    case PHI_NODE:
    case STATEMENT_LIST:
    case OMP_PARALLEL:
    case OMP_FOR:
    case OMP_SECTIONS:
    case OMP_SECTION:
    case OMP_SINGLE:
    case OMP_MASTER:
    case OMP_ORDERED:
    case OMP_CRITICAL:
    case OMP_RETURN:
    case OMP_CONTINUE:
      /* These are always void.  */
      return true;
 
    case CALL_EXPR:
    case MODIFY_EXPR:
      /* These are valid regardless of their type.  */
      return true;
 
    default:
      return false;
    }
}
 
/* Return true if T is a variable.  */
 
bool
is_gimple_variable (tree t)
{
  return (TREE_CODE (t) == VAR_DECL
          || TREE_CODE (t) == PARM_DECL
          || TREE_CODE (t) == RESULT_DECL
          || TREE_CODE (t) == SSA_NAME);
}
 
/*  Return true if T is a GIMPLE identifier (something with an address).  */
 
bool
is_gimple_id (tree t)
{
  return (is_gimple_variable (t)
          || TREE_CODE (t) == FUNCTION_DECL
          || TREE_CODE (t) == LABEL_DECL
          || TREE_CODE (t) == CONST_DECL
          /* Allow string constants, since they are addressable.  */
          || TREE_CODE (t) == STRING_CST);
}
 
/* Return true if TYPE is a suitable type for a scalar register variable.  */
 
bool
is_gimple_reg_type (tree type)
{
  return !AGGREGATE_TYPE_P (type);
}
 
/* Return true if T is a non-aggregate register variable.  */
 
bool
is_gimple_reg (tree t)
{
  if (TREE_CODE (t) == SSA_NAME)
    t = SSA_NAME_VAR (t);
 
  if (MTAG_P (t))
    return false;
 
  if (!is_gimple_variable (t))
    return false;
 
  if (!is_gimple_reg_type (TREE_TYPE (t)))
    return false;
 
  /* A volatile decl is not acceptable because we can't reuse it as
     needed.  We need to copy it into a temp first.  */
  if (TREE_THIS_VOLATILE (t))
    return false;
 
  /* We define "registers" as things that can be renamed as needed,
     which with our infrastructure does not apply to memory.  */
  if (needs_to_live_in_memory (t))
    return false;
 
  /* Hard register variables are an interesting case.  For those that
     are call-clobbered, we don't know where all the calls are, since
     we don't (want to) take into account which operations will turn
     into libcalls at the rtl level.  For those that are call-saved,
     we don't currently model the fact that calls may in fact change
     global hard registers, nor do we examine ASM_CLOBBERS at the tree
     level, and so miss variable changes that might imply.  All around,
     it seems safest to not do too much optimization with these at the
     tree level at all.  We'll have to rely on the rtl optimizers to
     clean this up, as there we've got all the appropriate bits exposed.  */
  if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
    return false;
 
  /* Complex values must have been put into ssa form.  That is, no
     assignments to the individual components.  */
  if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE)
    return DECL_COMPLEX_GIMPLE_REG_P (t);
 
  return true;
}
 
 
/* Returns true if T is a GIMPLE formal temporary variable.  */
 
bool
is_gimple_formal_tmp_var (tree t)
{
  if (TREE_CODE (t) == SSA_NAME)
    return true;
 
  return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
}
 
/* Returns true if T is a GIMPLE formal temporary register variable.  */
 
bool
is_gimple_formal_tmp_reg (tree t)
{
  /* The intent of this is to get hold of a value that won't change.
     An SSA_NAME qualifies no matter if its of a user variable or not.  */
  if (TREE_CODE (t) == SSA_NAME)
    return true;
 
  /* We don't know the lifetime characteristics of user variables.  */
  if (!is_gimple_formal_tmp_var (t))
    return false;
 
  /* Finally, it must be capable of being placed in a register.  */
  return is_gimple_reg (t);
}
 
/* Return true if T is a GIMPLE variable whose address is not needed.  */
 
bool
is_gimple_non_addressable (tree t)
{
  if (TREE_CODE (t) == SSA_NAME)
    t = SSA_NAME_VAR (t);
 
  return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
}
 
/* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
 
bool
is_gimple_val (tree t)
{
  /* Make loads from volatiles and memory vars explicit.  */
  if (is_gimple_variable (t)
      && is_gimple_reg_type (TREE_TYPE (t))
      && !is_gimple_reg (t))
    return false;
 
  /* FIXME make these decls.  That can happen only when we expose the
     entire landing-pad construct at the tree level.  */
  if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
    return 1;
 
  return (is_gimple_variable (t) || is_gimple_min_invariant (t));
}
 
/* Similarly, but accept hard registers as inputs to asm statements.  */
 
bool
is_gimple_asm_val (tree t)
{
  if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
    return true;
 
  return is_gimple_val (t);
}
 
/* Return true if T is a GIMPLE minimal lvalue.  */
 
bool
is_gimple_min_lval (tree t)
{
  return (is_gimple_id (t)
          || TREE_CODE (t) == INDIRECT_REF);
}
 
/* Return true if T is a typecast operation.  */
 
bool
is_gimple_cast (tree t)
{
  return (TREE_CODE (t) == NOP_EXPR
          || TREE_CODE (t) == CONVERT_EXPR
          || TREE_CODE (t) == FIX_TRUNC_EXPR
          || TREE_CODE (t) == FIX_CEIL_EXPR
          || TREE_CODE (t) == FIX_FLOOR_EXPR
          || TREE_CODE (t) == FIX_ROUND_EXPR);
}
 
/* Return true if T is a valid op0 of a CALL_EXPR.  */
 
bool
is_gimple_call_addr (tree t)
{
  return (TREE_CODE (t) == OBJ_TYPE_REF
          || is_gimple_val (t));
}
 
/* If T makes a function call, return the corresponding CALL_EXPR operand.
   Otherwise, return NULL_TREE.  */
 
tree
get_call_expr_in (tree t)
{
  if (TREE_CODE (t) == MODIFY_EXPR)
    t = TREE_OPERAND (t, 1);
  if (TREE_CODE (t) == WITH_SIZE_EXPR)
    t = TREE_OPERAND (t, 0);
  if (TREE_CODE (t) == CALL_EXPR)
    return t;
  return NULL_TREE;
}
 
/* Given a memory reference expression T, return its base address.
   The base address of a memory reference expression is the main
   object being referenced.  For instance, the base address for
   'array[i].fld[j]' is 'array'.  You can think of this as stripping
   away the offset part from a memory address.
 
   This function calls handled_component_p to strip away all the inner
   parts of the memory reference until it reaches the base object.  */
 
tree
get_base_address (tree t)
{
  while (handled_component_p (t))
    t = TREE_OPERAND (t, 0);
 
  if (SSA_VAR_P (t)
      || TREE_CODE (t) == STRING_CST
      || TREE_CODE (t) == CONSTRUCTOR
      || INDIRECT_REF_P (t))
    return t;
  else
    return NULL_TREE;
}
 
void
recalculate_side_effects (tree t)
{
  enum tree_code code = TREE_CODE (t);
  int len = TREE_CODE_LENGTH (code);
  int i;
 
  switch (TREE_CODE_CLASS (code))
    {
    case tcc_expression:
      switch (code)
        {
        case INIT_EXPR:
        case MODIFY_EXPR:
        case VA_ARG_EXPR:
        case PREDECREMENT_EXPR:
        case PREINCREMENT_EXPR:
        case POSTDECREMENT_EXPR:
        case POSTINCREMENT_EXPR:
          /* All of these have side-effects, no matter what their
             operands are.  */
          return;
 
        default:
          break;
        }
      /* Fall through.  */
 
    case tcc_comparison:  /* a comparison expression */
    case tcc_unary:       /* a unary arithmetic expression */
    case tcc_binary:      /* a binary arithmetic expression */
    case tcc_reference:   /* a reference */
      TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
      for (i = 0; i < len; ++i)
        {
          tree op = TREE_OPERAND (t, i);
          if (op && TREE_SIDE_EFFECTS (op))
            TREE_SIDE_EFFECTS (t) = 1;
        }
      break;
 
    default:
      /* Can never be used with non-expressions.  */
      gcc_unreachable ();
   }
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [tree-gimple.c] - Blame information for rev 816

Line No.	Rev	Author	Line
1	38	julius	`/* Functions to analyze and validate GIMPLE trees.`
2			`Copyright (C) 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.`
3			`Contributed by Diego Novillo <dnovillo@redhat.com>`
4			`Rewritten by Jason Merrill <jason@redhat.com>`
5
6			`This file is part of GCC.`
7
8			`GCC is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 3, or (at your option)`
11			`any later version.`
12
13			`GCC is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with GCC; see the file COPYING3. If not see`
20			`<http://www.gnu.org/licenses/>. */`
21
22			`#include "config.h"`
23			`#include "system.h"`
24			`#include "coretypes.h"`
25			`#include "ggc.h"`
26			`#include "tm.h"`
27			`#include "tree.h"`
28			`#include "tree-gimple.h"`
29			`#include "tree-flow.h"`
30			`#include "output.h"`
31			`#include "rtl.h"`
32			`#include "expr.h"`
33			`#include "bitmap.h"`
34
35			`/* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */`
36
37			`/* Validation of GIMPLE expressions. */`
38
39			`/* Return true if T is a GIMPLE RHS for an assignment to a temporary. */`
40
41			`bool`
42			`is_gimple_formal_tmp_rhs (tree t)`
43			`{`
44			`enum tree_code code = TREE_CODE (t);`
45
46			`switch (TREE_CODE_CLASS (code))`
47			`{`
48			`case tcc_unary:`
49			`case tcc_binary:`
50			`case tcc_comparison:`
51			`return true;`
52
53			`default:`
54			`break;`
55			`}`
56
57			`switch (code)`
58			`{`
59			`case TRUTH_NOT_EXPR:`
60			`case TRUTH_AND_EXPR:`
61			`case TRUTH_OR_EXPR:`
62			`case TRUTH_XOR_EXPR:`
63			`case ADDR_EXPR:`
64			`case CALL_EXPR:`
65			`case CONSTRUCTOR:`
66			`case COMPLEX_EXPR:`
67			`case INTEGER_CST:`
68			`case REAL_CST:`
69			`case STRING_CST:`
70			`case COMPLEX_CST:`
71			`case VECTOR_CST:`
72			`case OBJ_TYPE_REF:`
73			`case ASSERT_EXPR:`
74			`return true;`
75
76			`default:`
77			`break;`
78			`}`
79
80			`return is_gimple_lvalue (t) \|\| is_gimple_val (t);`
81			`}`
82
83			`/* Returns true iff T is a valid RHS for an assignment to a renamed`
84			`user -- or front-end generated artificial -- variable. */`
85
86			`bool`
87			`is_gimple_reg_rhs (tree t)`
88			`{`
89			`/* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto`
90			`and the LHS is a user variable, then we need to introduce a formal`
91			`temporary. This way the optimizers can determine that the user`
92			`variable is only modified if evaluation of the RHS does not throw.`
93
94			`Don't force a temp of a non-renamable type; the copy could be`
95			`arbitrarily expensive. Instead we will generate a V_MAY_DEF for`
96			`the assignment. */`
97
98			`if (is_gimple_reg_type (TREE_TYPE (t))`
99			`&& ((TREE_CODE (t) == CALL_EXPR && TREE_SIDE_EFFECTS (t))`
100			`\|\| tree_could_throw_p (t)))`
101			`return false;`
102
103			`return is_gimple_formal_tmp_rhs (t);`
104			`}`
105
106			`/* Returns true iff T is a valid RHS for an assignment to an un-renamed`
107			`LHS, or for a call argument. */`
108
109			`bool`
110			`is_gimple_mem_rhs (tree t)`
111			`{`
112			`/* If we're dealing with a renamable type, either source or dest must be`
113			`a renamed variable. Also force a temporary if the type doesn't need`
114			`to be stored in memory, since it's cheap and prevents erroneous`
115			`tailcalls (PR 17526). */`
116			`if (is_gimple_reg_type (TREE_TYPE (t))`
117			`\|\| (TYPE_MODE (TREE_TYPE (t)) != BLKmode`
118			`&& (TREE_CODE (t) != CALL_EXPR`
119			`\|\| ! aggregate_value_p (t, t))))`
120			`return is_gimple_val (t);`
121			`else`
122			`return is_gimple_formal_tmp_rhs (t);`
123			`}`
124
125			`/* Returns the appropriate RHS predicate for this LHS. */`
126
127			`gimple_predicate`
128			`rhs_predicate_for (tree lhs)`
129			`{`
130			`if (is_gimple_formal_tmp_var (lhs))`
131			`return is_gimple_formal_tmp_rhs;`
132			`else if (is_gimple_reg (lhs))`
133			`return is_gimple_reg_rhs;`
134			`else`
135			`return is_gimple_mem_rhs;`
136			`}`
137
138			`/* Return true if T is a valid LHS for a GIMPLE assignment expression. */`
139
140			`bool`
141			`is_gimple_lvalue (tree t)`
142			`{`
143			`return (is_gimple_addressable (t)`
144			`\|\| TREE_CODE (t) == WITH_SIZE_EXPR`
145			`/* These are complex lvalues, but don't have addresses, so they`
146			`go here. */`
147			`\|\| TREE_CODE (t) == BIT_FIELD_REF);`
148			`}`
149
150			`/* Return true if T is a GIMPLE condition. */`
151
152			`bool`
153			`is_gimple_condexpr (tree t)`
154			`{`
155			`return (is_gimple_val (t) \|\| COMPARISON_CLASS_P (t));`
156			`}`
157
158			`/* Return true if T is something whose address can be taken. */`
159
160			`bool`
161			`is_gimple_addressable (tree t)`
162			`{`
163			`return (is_gimple_id (t) \|\| handled_component_p (t)`
164			`\|\| INDIRECT_REF_P (t));`
165			`}`
166
167			`/* Return true if T is function invariant. Or rather a restricted`
168			`form of function invariant. */`
169
170			`bool`
171			`is_gimple_min_invariant (tree t)`
172			`{`
173			`switch (TREE_CODE (t))`
174			`{`
175			`case ADDR_EXPR:`
176			`return TREE_INVARIANT (t);`
177
178			`case INTEGER_CST:`
179			`case REAL_CST:`
180			`case STRING_CST:`
181			`case COMPLEX_CST:`
182			`case VECTOR_CST:`
183			`return true;`
184
185			`default:`
186			`return false;`
187			`}`
188			`}`
189
190			`/* Return true if T looks like a valid GIMPLE statement. */`
191
192			`bool`
193			`is_gimple_stmt (tree t)`
194			`{`
195			`enum tree_code code = TREE_CODE (t);`
196
197			`switch (code)`
198			`{`
199			`case NOP_EXPR:`
200			`/* The only valid NOP_EXPR is the empty statement. */`
201			`return IS_EMPTY_STMT (t);`
202
203			`case BIND_EXPR:`
204			`case COND_EXPR:`
205			`/* These are only valid if they're void. */`
206			`return TREE_TYPE (t) == NULL \|\| VOID_TYPE_P (TREE_TYPE (t));`
207
208			`case SWITCH_EXPR:`
209			`case GOTO_EXPR:`
210			`case RETURN_EXPR:`
211			`case LABEL_EXPR:`
212			`case CASE_LABEL_EXPR:`
213			`case TRY_CATCH_EXPR:`
214			`case TRY_FINALLY_EXPR:`
215			`case EH_FILTER_EXPR:`
216			`case CATCH_EXPR:`
217			`case ASM_EXPR:`
218			`case RESX_EXPR:`
219			`case PHI_NODE:`
220			`case STATEMENT_LIST:`
221			`case OMP_PARALLEL:`
222			`case OMP_FOR:`
223			`case OMP_SECTIONS:`
224			`case OMP_SECTION:`
225			`case OMP_SINGLE:`
226			`case OMP_MASTER:`
227			`case OMP_ORDERED:`
228			`case OMP_CRITICAL:`
229			`case OMP_RETURN:`
230			`case OMP_CONTINUE:`
231			`/* These are always void. */`
232			`return true;`
233
234			`case CALL_EXPR:`
235			`case MODIFY_EXPR:`
236			`/* These are valid regardless of their type. */`
237			`return true;`
238
239			`default:`
240			`return false;`
241			`}`
242			`}`
243
244			`/* Return true if T is a variable. */`
245
246			`bool`
247			`is_gimple_variable (tree t)`
248			`{`
249			`return (TREE_CODE (t) == VAR_DECL`
250			`\|\| TREE_CODE (t) == PARM_DECL`
251			`\|\| TREE_CODE (t) == RESULT_DECL`
252			`\|\| TREE_CODE (t) == SSA_NAME);`
253			`}`
254
255			`/* Return true if T is a GIMPLE identifier (something with an address). */`
256
257			`bool`
258			`is_gimple_id (tree t)`
259			`{`
260			`return (is_gimple_variable (t)`
261			`\|\| TREE_CODE (t) == FUNCTION_DECL`
262			`\|\| TREE_CODE (t) == LABEL_DECL`
263			`\|\| TREE_CODE (t) == CONST_DECL`
264			`/* Allow string constants, since they are addressable. */`
265			`\|\| TREE_CODE (t) == STRING_CST);`
266			`}`
267
268			`/* Return true if TYPE is a suitable type for a scalar register variable. */`
269
270			`bool`
271			`is_gimple_reg_type (tree type)`
272			`{`
273			`return !AGGREGATE_TYPE_P (type);`
274			`}`
275
276			`/* Return true if T is a non-aggregate register variable. */`
277
278			`bool`
279			`is_gimple_reg (tree t)`
280			`{`
281			`if (TREE_CODE (t) == SSA_NAME)`
282			`t = SSA_NAME_VAR (t);`
283
284			`if (MTAG_P (t))`
285			`return false;`
286
287			`if (!is_gimple_variable (t))`
288			`return false;`
289
290			`if (!is_gimple_reg_type (TREE_TYPE (t)))`
291			`return false;`
292
293			`/* A volatile decl is not acceptable because we can't reuse it as`
294			`needed. We need to copy it into a temp first. */`
295			`if (TREE_THIS_VOLATILE (t))`
296			`return false;`
297
298			`/* We define "registers" as things that can be renamed as needed,`
299			`which with our infrastructure does not apply to memory. */`
300			`if (needs_to_live_in_memory (t))`
301			`return false;`
302
303			`/* Hard register variables are an interesting case. For those that`
304			`are call-clobbered, we don't know where all the calls are, since`
305			`we don't (want to) take into account which operations will turn`
306			`into libcalls at the rtl level. For those that are call-saved,`
307			`we don't currently model the fact that calls may in fact change`
308			`global hard registers, nor do we examine ASM_CLOBBERS at the tree`
309			`level, and so miss variable changes that might imply. All around,`
310			`it seems safest to not do too much optimization with these at the`
311			`tree level at all. We'll have to rely on the rtl optimizers to`
312			`clean this up, as there we've got all the appropriate bits exposed. */`
313			`if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))`
314			`return false;`
315
316			`/* Complex values must have been put into ssa form. That is, no`
317			`assignments to the individual components. */`
318			`if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE)`
319			`return DECL_COMPLEX_GIMPLE_REG_P (t);`
320
321			`return true;`
322			`}`
323
324
325			`/* Returns true if T is a GIMPLE formal temporary variable. */`
326
327			`bool`
328			`is_gimple_formal_tmp_var (tree t)`
329			`{`
330			`if (TREE_CODE (t) == SSA_NAME)`
331			`return true;`
332
333			`return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);`
334			`}`
335
336			`/* Returns true if T is a GIMPLE formal temporary register variable. */`
337
338			`bool`
339			`is_gimple_formal_tmp_reg (tree t)`
340			`{`
341			`/* The intent of this is to get hold of a value that won't change.`
342			`An SSA_NAME qualifies no matter if its of a user variable or not. */`
343			`if (TREE_CODE (t) == SSA_NAME)`
344			`return true;`
345
346			`/* We don't know the lifetime characteristics of user variables. */`
347			`if (!is_gimple_formal_tmp_var (t))`
348			`return false;`
349
350			`/* Finally, it must be capable of being placed in a register. */`
351			`return is_gimple_reg (t);`
352			`}`
353
354			`/* Return true if T is a GIMPLE variable whose address is not needed. */`
355
356			`bool`
357			`is_gimple_non_addressable (tree t)`
358			`{`
359			`if (TREE_CODE (t) == SSA_NAME)`
360			`t = SSA_NAME_VAR (t);`
361
362			`return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));`
363			`}`
364
365			`/* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */`
366
367			`bool`
368			`is_gimple_val (tree t)`
369			`{`
370			`/* Make loads from volatiles and memory vars explicit. */`
371			`if (is_gimple_variable (t)`
372			`&& is_gimple_reg_type (TREE_TYPE (t))`
373			`&& !is_gimple_reg (t))`
374			`return false;`
375
376			`/* FIXME make these decls. That can happen only when we expose the`
377			`entire landing-pad construct at the tree level. */`
378			`if (TREE_CODE (t) == EXC_PTR_EXPR \|\| TREE_CODE (t) == FILTER_EXPR)`
379			`return 1;`
380
381			`return (is_gimple_variable (t) \|\| is_gimple_min_invariant (t));`
382			`}`
383
384			`/* Similarly, but accept hard registers as inputs to asm statements. */`
385
386			`bool`
387			`is_gimple_asm_val (tree t)`
388			`{`
389			`if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))`
390			`return true;`
391
392			`return is_gimple_val (t);`
393			`}`
394
395			`/* Return true if T is a GIMPLE minimal lvalue. */`
396
397			`bool`
398			`is_gimple_min_lval (tree t)`
399			`{`
400			`return (is_gimple_id (t)`
401			`\|\| TREE_CODE (t) == INDIRECT_REF);`
402			`}`
403
404			`/* Return true if T is a typecast operation. */`
405
406			`bool`
407			`is_gimple_cast (tree t)`
408			`{`
409			`return (TREE_CODE (t) == NOP_EXPR`
410			`\|\| TREE_CODE (t) == CONVERT_EXPR`
411			`\|\| TREE_CODE (t) == FIX_TRUNC_EXPR`
412			`\|\| TREE_CODE (t) == FIX_CEIL_EXPR`
413			`\|\| TREE_CODE (t) == FIX_FLOOR_EXPR`
414			`\|\| TREE_CODE (t) == FIX_ROUND_EXPR);`
415			`}`
416
417			`/* Return true if T is a valid op0 of a CALL_EXPR. */`
418
419			`bool`
420			`is_gimple_call_addr (tree t)`
421			`{`
422			`return (TREE_CODE (t) == OBJ_TYPE_REF`
423			`\|\| is_gimple_val (t));`
424			`}`
425
426			`/* If T makes a function call, return the corresponding CALL_EXPR operand.`
427			`Otherwise, return NULL_TREE. */`
428
429			`tree`
430			`get_call_expr_in (tree t)`
431			`{`
432			`if (TREE_CODE (t) == MODIFY_EXPR)`
433			`t = TREE_OPERAND (t, 1);`
434			`if (TREE_CODE (t) == WITH_SIZE_EXPR)`
435			`t = TREE_OPERAND (t, 0);`
436			`if (TREE_CODE (t) == CALL_EXPR)`
437			`return t;`
438			`return NULL_TREE;`
439			`}`
440
441			`/* Given a memory reference expression T, return its base address.`
442			`The base address of a memory reference expression is the main`
443			`object being referenced. For instance, the base address for`
444			`'array[i].fld[j]' is 'array'. You can think of this as stripping`
445			`away the offset part from a memory address.`
446
447			`This function calls handled_component_p to strip away all the inner`
448			`parts of the memory reference until it reaches the base object. */`
449
450			`tree`
451			`get_base_address (tree t)`
452			`{`
453			`while (handled_component_p (t))`
454			`t = TREE_OPERAND (t, 0);`
455
456			`if (SSA_VAR_P (t)`
457			`\|\| TREE_CODE (t) == STRING_CST`
458			`\|\| TREE_CODE (t) == CONSTRUCTOR`
459			`\|\| INDIRECT_REF_P (t))`
460			`return t;`
461			`else`
462			`return NULL_TREE;`
463			`}`
464
465			`void`
466			`recalculate_side_effects (tree t)`
467			`{`
468			`enum tree_code code = TREE_CODE (t);`
469			`int len = TREE_CODE_LENGTH (code);`
470			`int i;`
471
472			`switch (TREE_CODE_CLASS (code))`
473			`{`
474			`case tcc_expression:`
475			`switch (code)`
476			`{`
477			`case INIT_EXPR:`
478			`case MODIFY_EXPR:`
479			`case VA_ARG_EXPR:`
480			`case PREDECREMENT_EXPR:`
481			`case PREINCREMENT_EXPR:`
482			`case POSTDECREMENT_EXPR:`
483			`case POSTINCREMENT_EXPR:`
484			`/* All of these have side-effects, no matter what their`
485			`operands are. */`
486			`return;`
487
488			`default:`
489			`break;`
490			`}`
491			`/* Fall through. */`
492
493			`case tcc_comparison: /* a comparison expression */`
494			`case tcc_unary: /* a unary arithmetic expression */`
495			`case tcc_binary: /* a binary arithmetic expression */`
496			`case tcc_reference: /* a reference */`
497			`TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);`
498			`for (i = 0; i < len; ++i)`
499			`{`
500			`tree op = TREE_OPERAND (t, i);`
501			`if (op && TREE_SIDE_EFFECTS (op))`
502			`TREE_SIDE_EFFECTS (t) = 1;`
503			`}`
504			`break;`
505
506			`default:`
507			`/* Can never be used with non-expressions. */`
508			`gcc_unreachable ();`
509			`}`
510			`}`