Commit 643519b7 by Diego Novillo Committed by Diego Novillo

ipa-type-escape.c: Tidy some comments and white space.


	* ipa-type-escape.c: Tidy some comments and white space.
	* tree-ssa-operands.c: Likewise.

From-SVN: r111310
parent 4b9e501c
2006-02-20 Diego Novillo <dnovillo@redhat.com>
* ipa-type-escape.c: Tidy some comments and white space.
* tree-ssa-operands.c: Likewise.
2006-02-20 Andrew Pinski <pinskia@physics.uc.edu> 2006-02-20 Andrew Pinski <pinskia@physics.uc.edu>
PR tree-opt/25879 PR tree-opt/25879
......
...@@ -394,7 +394,7 @@ ipa_type_escape_type_contained_p (tree type) ...@@ -394,7 +394,7 @@ ipa_type_escape_type_contained_p (tree type)
get_canon_type_uid (type, true, false)); get_canon_type_uid (type, true, false));
} }
/* Return true a modification to a field of type FIELD_TYPE cannot /* Return true if a modification to a field of type FIELD_TYPE cannot
clobber a record of RECORD_TYPE. */ clobber a record of RECORD_TYPE. */
bool bool
......
...@@ -1050,9 +1050,10 @@ swap_tree_operands (tree stmt, tree *exp0, tree *exp1) ...@@ -1050,9 +1050,10 @@ swap_tree_operands (tree stmt, tree *exp0, tree *exp1)
*exp1 = op0; *exp1 = op0;
} }
/* Recursively scan the expression pointed to by EXPR_P in statement referred
to by INFO. FLAGS is one of the OPF_* constants modifying how to interpret /* Recursively scan the expression pointed to by EXPR_P in statement
the operands found. */ referred to by INFO. FLAGS is one of the OPF_* constants modifying
how to interpret the operands found. */
static void static void
get_expr_operands (tree stmt, tree *expr_p, int flags) get_expr_operands (tree stmt, tree *expr_p, int flags)
...@@ -1072,22 +1073,22 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1072,22 +1073,22 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
{ {
case ADDR_EXPR: case ADDR_EXPR:
/* Taking the address of a variable does not represent a /* Taking the address of a variable does not represent a
reference to it, but the fact that the stmt takes its address will be reference to it, but the fact that the statement takes its
of interest to some passes (e.g. alias resolution). */ address will be of interest to some passes (e.g. alias
add_to_addressable_set (TREE_OPERAND (expr, 0), resolution). */
&s_ann->addresses_taken); add_to_addressable_set (TREE_OPERAND (expr, 0), &s_ann->addresses_taken);
/* If the address is invariant, there may be no interesting variable /* If the address is invariant, there may be no interesting
references inside. */ variable references inside. */
if (is_gimple_min_invariant (expr)) if (is_gimple_min_invariant (expr))
return; return;
/* There should be no VUSEs created, since the referenced objects are /* Otherwise, there may be variables referenced inside but there
not really accessed. The only operands that we should find here should be no VUSEs created, since the referenced objects are
are ARRAY_REF indices which will always be real operands (GIMPLE not really accessed. The only operands that we should find
does not allow non-registers as array indices). */ here are ARRAY_REF indices which will always be real operands
(GIMPLE does not allow non-registers as array indices). */
flags |= opf_no_vops; flags |= opf_no_vops;
get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags); get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
return; return;
...@@ -1095,7 +1096,6 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1095,7 +1096,6 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
case STRUCT_FIELD_TAG: case STRUCT_FIELD_TAG:
case TYPE_MEMORY_TAG: case TYPE_MEMORY_TAG:
case NAME_MEMORY_TAG: case NAME_MEMORY_TAG:
add_stmt_operand (expr_p, s_ann, flags); add_stmt_operand (expr_p, s_ann, flags);
return; return;
...@@ -1105,9 +1105,9 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1105,9 +1105,9 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
{ {
subvar_t svars; subvar_t svars;
/* Add the subvars for a variable if it has subvars, to DEFS or USES. /* Add the subvars for a variable if it has subvars, to DEFS
Otherwise, add the variable itself. or USES. Otherwise, add the variable itself. Whether it
Whether it goes to USES or DEFS depends on the operand flags. */ goes to USES or DEFS depends on the operand flags. */
if (var_can_have_subvars (expr) if (var_can_have_subvars (expr)
&& (svars = get_subvars_for_var (expr))) && (svars = get_subvars_for_var (expr)))
{ {
...@@ -1116,11 +1116,11 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1116,11 +1116,11 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
add_stmt_operand (&sv->var, s_ann, flags); add_stmt_operand (&sv->var, s_ann, flags);
} }
else else
{ add_stmt_operand (expr_p, s_ann, flags);
add_stmt_operand (expr_p, s_ann, flags);
}
return; return;
} }
case MISALIGNED_INDIRECT_REF: case MISALIGNED_INDIRECT_REF:
get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags); get_expr_operands (stmt, &TREE_OPERAND (expr, 1), flags);
/* fall through */ /* fall through */
...@@ -1139,9 +1139,6 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1139,9 +1139,6 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
/* Treat array references as references to the virtual variable /* Treat array references as references to the virtual variable
representing the array. The virtual variable for an ARRAY_REF representing the array. The virtual variable for an ARRAY_REF
is the VAR_DECL for the array. */ is the VAR_DECL for the array. */
/* Add the virtual variable for the ARRAY_REF to VDEFS or VUSES
according to the value of IS_DEF. */
get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags); get_expr_operands (stmt, &TREE_OPERAND (expr, 0), flags);
get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none); get_expr_operands (stmt, &TREE_OPERAND (expr, 1), opf_none);
get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none); get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
...@@ -1156,30 +1153,33 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1156,30 +1153,33 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
tree ref; tree ref;
HOST_WIDE_INT offset, size, maxsize; HOST_WIDE_INT offset, size, maxsize;
bool none = true; bool none = true;
/* This component ref becomes an access to all of the subvariables
it can touch, if we can determine that, but *NOT* the real one.
If we can't determine which fields we could touch, the recursion
will eventually get to a variable and add *all* of its subvars, or
whatever is the minimum correct subset. */
/* This component reference becomes an access to all of the
subvariables it can touch, if we can determine that, but
*NOT* the real one. If we can't determine which fields we
could touch, the recursion will eventually get to a
variable and add *all* of its subvars, or whatever is the
minimum correct subset. */
ref = get_ref_base_and_extent (expr, &offset, &size, &maxsize); ref = get_ref_base_and_extent (expr, &offset, &size, &maxsize);
if (SSA_VAR_P (ref) && get_subvars_for_var (ref)) if (SSA_VAR_P (ref) && get_subvars_for_var (ref))
{ {
subvar_t svars = get_subvars_for_var (ref);
subvar_t sv; subvar_t sv;
subvar_t svars = get_subvars_for_var (ref);
for (sv = svars; sv; sv = sv->next) for (sv = svars; sv; sv = sv->next)
{ {
bool exact; bool exact;
if (overlap_subvar (offset, maxsize, sv->var, &exact)) if (overlap_subvar (offset, maxsize, sv->var, &exact))
{ {
int subvar_flags = flags; int subvar_flags = flags;
none = false; none = false;
if (!exact if (!exact || size != maxsize)
|| size != maxsize)
subvar_flags &= ~opf_kill_def; subvar_flags &= ~opf_kill_def;
add_stmt_operand (&sv->var, s_ann, subvar_flags); add_stmt_operand (&sv->var, s_ann, subvar_flags);
} }
} }
if (!none) if (!none)
flags |= opf_no_vops; flags |= opf_no_vops;
} }
...@@ -1193,7 +1193,7 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1193,7 +1193,7 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
/* Even if we found subvars above we need to ensure to see /* Even if we found subvars above we need to ensure to see
immediate uses for d in s.a[d]. In case of s.a having immediate uses for d in s.a[d]. In case of s.a having
a subvar we'd miss it otherwise. */ a subvar we'd miss it otherwise. */
get_expr_operands (stmt, &TREE_OPERAND (expr, 0), get_expr_operands (stmt, &TREE_OPERAND (expr, 0),
flags & ~opf_kill_def); flags & ~opf_kill_def);
if (code == COMPONENT_REF) if (code == COMPONENT_REF)
...@@ -1208,8 +1208,10 @@ get_expr_operands (tree stmt, tree *expr_p, int flags) ...@@ -1208,8 +1208,10 @@ get_expr_operands (tree stmt, tree *expr_p, int flags)
get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none); get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none); get_expr_operands (stmt, &TREE_OPERAND (expr, 3), opf_none);
} }
return; return;
} }
case WITH_SIZE_EXPR: case WITH_SIZE_EXPR:
/* WITH_SIZE_EXPR is a pass-through reference to its first argument, /* WITH_SIZE_EXPR is a pass-through reference to its first argument,
and an rvalue reference to its second argument. */ and an rvalue reference to its second argument. */
...@@ -1368,10 +1370,9 @@ get_asm_expr_operands (tree stmt) ...@@ -1368,10 +1370,9 @@ get_asm_expr_operands (tree stmt)
for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link)) for (link = ASM_INPUTS (stmt); link; link = TREE_CHAIN (link))
{ {
constraint constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
= TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
parse_input_constraint (&constraint, 0, 0, noutputs, 0, parse_input_constraint (&constraint, 0, 0, noutputs, 0,
oconstraints, &allows_mem, &allows_reg); oconstraints, &allows_mem, &allows_reg);
/* Memory operands are addressable. Note that STMT needs the /* Memory operands are addressable. Note that STMT needs the
address of this operand. */ address of this operand. */
...@@ -1428,17 +1429,21 @@ get_asm_expr_operands (tree stmt) ...@@ -1428,17 +1429,21 @@ get_asm_expr_operands (tree stmt)
/* A subroutine of get_expr_operands to handle INDIRECT_REF, /* A subroutine of get_expr_operands to handle INDIRECT_REF,
ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF. ALIGN_INDIRECT_REF and MISALIGNED_INDIRECT_REF.
STMT is the statement being processed, EXPR is the INDIRECT_REF STMT is the statement being processed, EXPR is the INDIRECT_REF
that got us here. FLAGS is as in get_expr_operands. that got us here.
FLAGS is as in get_expr_operands.
FULL_REF contains the full pointer dereference expression, if we FULL_REF contains the full pointer dereference expression, if we
have it, or NULL otherwise. have it, or NULL otherwise.
OFFSET and SIZE are the location of the access inside the OFFSET and SIZE are the location of the access inside the
dereferenced pointer, if known. dereferenced pointer, if known.
RECURSE_ON_BASE should be set to true if we want to continue
calling get_expr_operands on the base pointer, and false if
something else will do it for us.
*/ RECURSE_ON_BASE should be set to true if we want to continue
calling get_expr_operands on the base pointer, and false if
something else will do it for us. */
static void static void
get_indirect_ref_operands (tree stmt, tree expr, int flags, get_indirect_ref_operands (tree stmt, tree expr, int flags,
...@@ -1496,25 +1501,27 @@ get_indirect_ref_operands (tree stmt, tree expr, int flags, ...@@ -1496,25 +1501,27 @@ get_indirect_ref_operands (tree stmt, tree expr, int flags,
full_ref, offset, size, false); full_ref, offset, size, false);
} }
} }
/* If a constant is used as a pointer, we can't generate a real
operand for it but we mark the statement volatile to prevent
optimizations from messing things up. */
else if (TREE_CODE (ptr) == INTEGER_CST) else if (TREE_CODE (ptr) == INTEGER_CST)
{ {
/* If a constant is used as a pointer, we can't generate a real
operand for it but we mark the statement volatile to prevent
optimizations from messing things up. */
if (s_ann) if (s_ann)
s_ann->has_volatile_ops = true; s_ann->has_volatile_ops = true;
return; return;
} }
/* Ok, this isn't even is_gimple_min_invariant. Something's broke. */
else else
gcc_unreachable (); {
/* Ok, this isn't even is_gimple_min_invariant. Something's broke. */
gcc_unreachable ();
}
/* Add a USE operand for the base pointer. */ /* If requested, add a USE operand for the base pointer. */
if (recurse_on_base) if (recurse_on_base)
get_expr_operands (stmt, pptr, opf_none); get_expr_operands (stmt, pptr, opf_none);
} }
/* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */ /* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
static void static void
...@@ -1567,6 +1574,7 @@ get_tmr_operands (tree stmt, tree expr, int flags) ...@@ -1567,6 +1574,7 @@ get_tmr_operands (tree stmt, tree expr, int flags)
} }
} }
/* A subroutine of get_expr_operands to handle CALL_EXPR. */ /* A subroutine of get_expr_operands to handle CALL_EXPR. */
static void static void
...@@ -1626,12 +1634,13 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset, ...@@ -1626,12 +1634,13 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
/* If ALIAS is an SFT, it can't be touched if the offset /* If ALIAS is an SFT, it can't be touched if the offset
and size of the access is not overlapping with the SFT offset and and size of the access is not overlapping with the SFT offset and
size. This is only true if we are accessing through a pointer size. This is only true if we are accessing through a pointer
to a type that is the same as SFT_PARENT_VAR. Otherwise, we may to a type that is the same as SFT_PARENT_VAR. Otherwise, we may
be accessing through a pointer to some substruct of the be accessing through a pointer to some substruct of the
structure, and if we try to prune there, we will have the wrong structure, and if we try to prune there, we will have the wrong
offset, and get the wrong answer. offset, and get the wrong answer.
i.e., we can't prune without more work if we have something like i.e., we can't prune without more work if we have something like
struct gcc_target struct gcc_target
{ {
struct asm_out struct asm_out
...@@ -1649,9 +1658,7 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset, ...@@ -1649,9 +1658,7 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
SFT.1, which represents hi, will have SFT_OFFSET=32 because in SFT.1, which represents hi, will have SFT_OFFSET=32 because in
terms of SFT_PARENT_VAR, that is where it is. terms of SFT_PARENT_VAR, that is where it is.
However, the access through the foo pointer will be at offset 0. However, the access through the foo pointer will be at offset 0. */
*/
if (size != -1 if (size != -1
&& TREE_CODE (alias) == STRUCT_FIELD_TAG && TREE_CODE (alias) == STRUCT_FIELD_TAG
&& base && base
...@@ -1672,12 +1679,12 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset, ...@@ -1672,12 +1679,12 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
through a pointer to touch a random variable, unless that through a pointer to touch a random variable, unless that
variable *is* a structure or a pointer. variable *is* a structure or a pointer.
That is, given p->c, and some random global variable b,
IE given p->c, and some random global variable b,
there is no legal way that p->c could be an access to b. there is no legal way that p->c could be an access to b.
Without strict aliasing on, we consider it legal to do something Without strict aliasing on, we consider it legal to do something
like: like:
struct foos { int l; }; struct foos { int l; };
int foo; int foo;
static struct foos *getfoo(void); static struct foos *getfoo(void);
...@@ -1695,7 +1702,6 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset, ...@@ -1695,7 +1702,6 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
(taken from 20000623-1.c) (taken from 20000623-1.c)
*/ */
else if (ref else if (ref
&& flag_strict_aliasing && flag_strict_aliasing
&& TREE_CODE (ref) != INDIRECT_REF && TREE_CODE (ref) != INDIRECT_REF
...@@ -1717,7 +1723,6 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset, ...@@ -1717,7 +1723,6 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
/* If the offset of the access is greater than the size of one of /* If the offset of the access is greater than the size of one of
the possible aliases, it can't be touching that alias, because it the possible aliases, it can't be touching that alias, because it
would be past the end of the structure. */ would be past the end of the structure. */
else if (ref else if (ref
&& flag_strict_aliasing && flag_strict_aliasing
&& TREE_CODE (ref) != INDIRECT_REF && TREE_CODE (ref) != INDIRECT_REF
...@@ -1737,11 +1742,12 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset, ...@@ -1737,11 +1742,12 @@ access_can_touch_variable (tree ref, tree alias, HOST_WIDE_INT offset,
#endif #endif
return false; return false;
} }
return true; return true;
} }
/* Add VAR to the virtual operands array. FLAGS is as in /* Add VAR to the virtual operands array. FLAGS is as in
get_expr_operands. FULL_REF is a tree that contains the entire get_expr_operands. FULL_REF is a tree that contains the entire
pointer dereference expression, if available, or NULL otherwise. pointer dereference expression, if available, or NULL otherwise.
OFFSET and SIZE come from the memory access expression that OFFSET and SIZE come from the memory access expression that
...@@ -1771,8 +1777,8 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags, ...@@ -1771,8 +1777,8 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags,
check that this only happens on non-specific stores. check that this only happens on non-specific stores.
Note that if this is a specific store, i.e. associated with a Note that if this is a specific store, i.e. associated with a
modify_expr, then we can't suppress the V_DEF, lest we run into modify_expr, then we can't suppress the V_MAY_DEF, lest we run
validation problems. into validation problems.
This can happen when programs cast away const, leaving us with a This can happen when programs cast away const, leaving us with a
store to read-only memory. If the statement is actually executed store to read-only memory. If the statement is actually executed
...@@ -1796,12 +1802,10 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags, ...@@ -1796,12 +1802,10 @@ add_virtual_operand (tree var, stmt_ann_t s_ann, int flags,
{ {
if (flags & opf_kill_def) if (flags & opf_kill_def)
{ {
/* Only regular variables or struct fields may get a
V_MUST_DEF operand. */
gcc_assert (!MTAG_P (var)
|| TREE_CODE (var) == STRUCT_FIELD_TAG);
/* V_MUST_DEF for non-aliased, non-GIMPLE register /* V_MUST_DEF for non-aliased, non-GIMPLE register
variable definitions. */ variable definitions. */
gcc_assert (!MTAG_P (var)
|| TREE_CODE (var) == STRUCT_FIELD_TAG);
append_v_must_def (var); append_v_must_def (var);
} }
else else
...@@ -1926,6 +1930,7 @@ add_stmt_operand (tree *var_p, stmt_ann_t s_ann, int flags) ...@@ -1926,6 +1930,7 @@ add_stmt_operand (tree *var_p, stmt_ann_t s_ann, int flags)
add_virtual_operand (var, s_ann, flags, NULL_TREE, 0, -1, false); add_virtual_operand (var, s_ann, flags, NULL_TREE, 0, -1, false);
} }
/* Add the base address of REF to the set *ADDRESSES_TAKEN. If /* Add the base address of REF to the set *ADDRESSES_TAKEN. If
*ADDRESSES_TAKEN is NULL, a new set is created. REF may be *ADDRESSES_TAKEN is NULL, a new set is created. REF may be
a single variable whose address has been taken or any other valid a single variable whose address has been taken or any other valid
...@@ -1970,6 +1975,7 @@ add_to_addressable_set (tree ref, bitmap *addresses_taken) ...@@ -1970,6 +1975,7 @@ add_to_addressable_set (tree ref, bitmap *addresses_taken)
} }
} }
/* Add clobbering definitions for .GLOBAL_VAR or for each of the call /* Add clobbering definitions for .GLOBAL_VAR or for each of the call
clobbered variables in the function. */ clobbered variables in the function. */
...@@ -1997,7 +2003,6 @@ add_call_clobber_ops (tree stmt, tree callee) ...@@ -1997,7 +2003,6 @@ add_call_clobber_ops (tree stmt, tree callee)
/* Get info for local and module level statics. There is a bit /* Get info for local and module level statics. There is a bit
set for each static if the call being processed does not read set for each static if the call being processed does not read
or write that variable. */ or write that variable. */
not_read_b = callee ? ipa_reference_get_not_read_global (callee) : NULL; not_read_b = callee ? ipa_reference_get_not_read_global (callee) : NULL;
not_written_b = callee ? ipa_reference_get_not_written_global (callee) : NULL; not_written_b = callee ? ipa_reference_get_not_written_global (callee) : NULL;
/* Add a V_MAY_DEF operand for every call clobbered variable. */ /* Add a V_MAY_DEF operand for every call clobbered variable. */
...@@ -2011,7 +2016,6 @@ add_call_clobber_ops (tree stmt, tree callee) ...@@ -2011,7 +2016,6 @@ add_call_clobber_ops (tree stmt, tree callee)
/* Not read and not written are computed on regular vars, not /* Not read and not written are computed on regular vars, not
subvars, so look at the parent var if this is an SFT. */ subvars, so look at the parent var if this is an SFT. */
if (TREE_CODE (var) == STRUCT_FIELD_TAG) if (TREE_CODE (var) == STRUCT_FIELD_TAG)
real_var = SFT_PARENT_VAR (var); real_var = SFT_PARENT_VAR (var);
...@@ -2144,7 +2148,9 @@ verify_imm_links (FILE *f, tree var) ...@@ -2144,7 +2148,9 @@ verify_imm_links (FILE *f, tree var)
prev = ptr; prev = ptr;
ptr = ptr->next; ptr = ptr->next;
/* Avoid infinite loops. 50,000,000 uses probably indicates a problem. */
/* Avoid infinite loops. 50,000,000 uses probably indicates a
problem. */
if (count++ > 50000000) if (count++ > 50000000)
goto error; goto error;
} }
...@@ -2210,6 +2216,7 @@ dump_immediate_uses_for (FILE *file, tree var) ...@@ -2210,6 +2216,7 @@ dump_immediate_uses_for (FILE *file, tree var)
fprintf(file, "\n"); fprintf(file, "\n");
} }
/* Dump all the immediate uses to FILE. */ /* Dump all the immediate uses to FILE. */
void void
...@@ -2244,4 +2251,5 @@ debug_immediate_uses_for (tree var) ...@@ -2244,4 +2251,5 @@ debug_immediate_uses_for (tree var)
{ {
dump_immediate_uses_for (stderr, var); dump_immediate_uses_for (stderr, var);
} }
#include "gt-tree-ssa-operands.h" #include "gt-tree-ssa-operands.h"
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment