/* Gimple IR support functions.
|
/* Gimple IR support functions.
|
|
|
Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
Copyright 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
|
Contributed by Aldy Hernandez <aldyh@redhat.com>
|
Contributed by Aldy Hernandez <aldyh@redhat.com>
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "target.h"
|
#include "target.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "hard-reg-set.h"
|
#include "hard-reg-set.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "gimple.h"
|
#include "gimple.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "diagnostic.h"
|
#include "diagnostic.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "value-prof.h"
|
#include "value-prof.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "alias.h"
|
#include "alias.h"
|
#include "demangle.h"
|
#include "demangle.h"
|
|
|
/* Global type table. FIXME lto, it should be possible to re-use some
|
/* Global type table. FIXME lto, it should be possible to re-use some
|
of the type hashing routines in tree.c (type_hash_canon, type_hash_lookup,
|
of the type hashing routines in tree.c (type_hash_canon, type_hash_lookup,
|
etc), but those assume that types were built with the various
|
etc), but those assume that types were built with the various
|
build_*_type routines which is not the case with the streamer. */
|
build_*_type routines which is not the case with the streamer. */
|
static htab_t gimple_types;
|
static htab_t gimple_types;
|
static struct pointer_map_t *type_hash_cache;
|
static struct pointer_map_t *type_hash_cache;
|
|
|
/* Global type comparison cache. */
|
/* Global type comparison cache. */
|
static htab_t gtc_visited;
|
static htab_t gtc_visited;
|
static struct obstack gtc_ob;
|
static struct obstack gtc_ob;
|
|
|
/* All the tuples have their operand vector (if present) at the very bottom
|
/* All the tuples have their operand vector (if present) at the very bottom
|
of the structure. Therefore, the offset required to find the
|
of the structure. Therefore, the offset required to find the
|
operands vector the size of the structure minus the size of the 1
|
operands vector the size of the structure minus the size of the 1
|
element tree array at the end (see gimple_ops). */
|
element tree array at the end (see gimple_ops). */
|
#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
|
#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
|
(HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
|
(HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
|
EXPORTED_CONST size_t gimple_ops_offset_[] = {
|
EXPORTED_CONST size_t gimple_ops_offset_[] = {
|
#include "gsstruct.def"
|
#include "gsstruct.def"
|
};
|
};
|
#undef DEFGSSTRUCT
|
#undef DEFGSSTRUCT
|
|
|
#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof(struct STRUCT),
|
#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof(struct STRUCT),
|
static const size_t gsstruct_code_size[] = {
|
static const size_t gsstruct_code_size[] = {
|
#include "gsstruct.def"
|
#include "gsstruct.def"
|
};
|
};
|
#undef DEFGSSTRUCT
|
#undef DEFGSSTRUCT
|
|
|
#define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
|
#define DEFGSCODE(SYM, NAME, GSSCODE) NAME,
|
const char *const gimple_code_name[] = {
|
const char *const gimple_code_name[] = {
|
#include "gimple.def"
|
#include "gimple.def"
|
};
|
};
|
#undef DEFGSCODE
|
#undef DEFGSCODE
|
|
|
#define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
|
#define DEFGSCODE(SYM, NAME, GSSCODE) GSSCODE,
|
EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
|
EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
|
#include "gimple.def"
|
#include "gimple.def"
|
};
|
};
|
#undef DEFGSCODE
|
#undef DEFGSCODE
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
/* Gimple stats. */
|
/* Gimple stats. */
|
|
|
int gimple_alloc_counts[(int) gimple_alloc_kind_all];
|
int gimple_alloc_counts[(int) gimple_alloc_kind_all];
|
int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
|
int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
|
|
|
/* Keep in sync with gimple.h:enum gimple_alloc_kind. */
|
/* Keep in sync with gimple.h:enum gimple_alloc_kind. */
|
static const char * const gimple_alloc_kind_names[] = {
|
static const char * const gimple_alloc_kind_names[] = {
|
"assignments",
|
"assignments",
|
"phi nodes",
|
"phi nodes",
|
"conditionals",
|
"conditionals",
|
"sequences",
|
"sequences",
|
"everything else"
|
"everything else"
|
};
|
};
|
|
|
#endif /* GATHER_STATISTICS */
|
#endif /* GATHER_STATISTICS */
|
|
|
/* A cache of gimple_seq objects. Sequences are created and destroyed
|
/* A cache of gimple_seq objects. Sequences are created and destroyed
|
fairly often during gimplification. */
|
fairly often during gimplification. */
|
static GTY ((deletable)) struct gimple_seq_d *gimple_seq_cache;
|
static GTY ((deletable)) struct gimple_seq_d *gimple_seq_cache;
|
|
|
/* Private API manipulation functions shared only with some
|
/* Private API manipulation functions shared only with some
|
other files. */
|
other files. */
|
extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
|
extern void gimple_set_stored_syms (gimple, bitmap, bitmap_obstack *);
|
extern void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *);
|
extern void gimple_set_loaded_syms (gimple, bitmap, bitmap_obstack *);
|
|
|
/* Gimple tuple constructors.
|
/* Gimple tuple constructors.
|
Note: Any constructor taking a ``gimple_seq'' as a parameter, can
|
Note: Any constructor taking a ``gimple_seq'' as a parameter, can
|
be passed a NULL to start with an empty sequence. */
|
be passed a NULL to start with an empty sequence. */
|
|
|
/* Set the code for statement G to CODE. */
|
/* Set the code for statement G to CODE. */
|
|
|
static inline void
|
static inline void
|
gimple_set_code (gimple g, enum gimple_code code)
|
gimple_set_code (gimple g, enum gimple_code code)
|
{
|
{
|
g->gsbase.code = code;
|
g->gsbase.code = code;
|
}
|
}
|
|
|
/* Return the number of bytes needed to hold a GIMPLE statement with
|
/* Return the number of bytes needed to hold a GIMPLE statement with
|
code CODE. */
|
code CODE. */
|
|
|
static inline size_t
|
static inline size_t
|
gimple_size (enum gimple_code code)
|
gimple_size (enum gimple_code code)
|
{
|
{
|
return gsstruct_code_size[gss_for_code (code)];
|
return gsstruct_code_size[gss_for_code (code)];
|
}
|
}
|
|
|
/* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
|
/* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
|
operands. */
|
operands. */
|
|
|
gimple
|
gimple
|
gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
|
gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
|
{
|
{
|
size_t size;
|
size_t size;
|
gimple stmt;
|
gimple stmt;
|
|
|
size = gimple_size (code);
|
size = gimple_size (code);
|
if (num_ops > 0)
|
if (num_ops > 0)
|
size += sizeof (tree) * (num_ops - 1);
|
size += sizeof (tree) * (num_ops - 1);
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
{
|
{
|
enum gimple_alloc_kind kind = gimple_alloc_kind (code);
|
enum gimple_alloc_kind kind = gimple_alloc_kind (code);
|
gimple_alloc_counts[(int) kind]++;
|
gimple_alloc_counts[(int) kind]++;
|
gimple_alloc_sizes[(int) kind] += size;
|
gimple_alloc_sizes[(int) kind] += size;
|
}
|
}
|
#endif
|
#endif
|
|
|
stmt = (gimple) ggc_alloc_cleared_stat (size PASS_MEM_STAT);
|
stmt = (gimple) ggc_alloc_cleared_stat (size PASS_MEM_STAT);
|
gimple_set_code (stmt, code);
|
gimple_set_code (stmt, code);
|
gimple_set_num_ops (stmt, num_ops);
|
gimple_set_num_ops (stmt, num_ops);
|
|
|
/* Do not call gimple_set_modified here as it has other side
|
/* Do not call gimple_set_modified here as it has other side
|
effects and this tuple is still not completely built. */
|
effects and this tuple is still not completely built. */
|
stmt->gsbase.modified = 1;
|
stmt->gsbase.modified = 1;
|
|
|
return stmt;
|
return stmt;
|
}
|
}
|
|
|
/* Set SUBCODE to be the code of the expression computed by statement G. */
|
/* Set SUBCODE to be the code of the expression computed by statement G. */
|
|
|
static inline void
|
static inline void
|
gimple_set_subcode (gimple g, unsigned subcode)
|
gimple_set_subcode (gimple g, unsigned subcode)
|
{
|
{
|
/* We only have 16 bits for the RHS code. Assert that we are not
|
/* We only have 16 bits for the RHS code. Assert that we are not
|
overflowing it. */
|
overflowing it. */
|
gcc_assert (subcode < (1 << 16));
|
gcc_assert (subcode < (1 << 16));
|
g->gsbase.subcode = subcode;
|
g->gsbase.subcode = subcode;
|
}
|
}
|
|
|
|
|
|
|
/* Build a tuple with operands. CODE is the statement to build (which
|
/* Build a tuple with operands. CODE is the statement to build (which
|
must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the sub-code
|
must be one of the GIMPLE_WITH_OPS tuples). SUBCODE is the sub-code
|
for the new tuple. NUM_OPS is the number of operands to allocate. */
|
for the new tuple. NUM_OPS is the number of operands to allocate. */
|
|
|
#define gimple_build_with_ops(c, s, n) \
|
#define gimple_build_with_ops(c, s, n) \
|
gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
|
gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
|
|
|
static gimple
|
static gimple
|
gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
|
gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
|
unsigned num_ops MEM_STAT_DECL)
|
unsigned num_ops MEM_STAT_DECL)
|
{
|
{
|
gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
|
gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
|
gimple_set_subcode (s, subcode);
|
gimple_set_subcode (s, subcode);
|
|
|
return s;
|
return s;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_RETURN statement returning RETVAL. */
|
/* Build a GIMPLE_RETURN statement returning RETVAL. */
|
|
|
gimple
|
gimple
|
gimple_build_return (tree retval)
|
gimple_build_return (tree retval)
|
{
|
{
|
gimple s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 1);
|
gimple s = gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK, 1);
|
if (retval)
|
if (retval)
|
gimple_return_set_retval (s, retval);
|
gimple_return_set_retval (s, retval);
|
return s;
|
return s;
|
}
|
}
|
|
|
/* Helper for gimple_build_call, gimple_build_call_vec and
|
/* Helper for gimple_build_call, gimple_build_call_vec and
|
gimple_build_call_from_tree. Build the basic components of a
|
gimple_build_call_from_tree. Build the basic components of a
|
GIMPLE_CALL statement to function FN with NARGS arguments. */
|
GIMPLE_CALL statement to function FN with NARGS arguments. */
|
|
|
static inline gimple
|
static inline gimple
|
gimple_build_call_1 (tree fn, unsigned nargs)
|
gimple_build_call_1 (tree fn, unsigned nargs)
|
{
|
{
|
gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
|
gimple s = gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK, nargs + 3);
|
if (TREE_CODE (fn) == FUNCTION_DECL)
|
if (TREE_CODE (fn) == FUNCTION_DECL)
|
fn = build_fold_addr_expr (fn);
|
fn = build_fold_addr_expr (fn);
|
gimple_set_op (s, 1, fn);
|
gimple_set_op (s, 1, fn);
|
return s;
|
return s;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_CALL statement to function FN with the arguments
|
/* Build a GIMPLE_CALL statement to function FN with the arguments
|
specified in vector ARGS. */
|
specified in vector ARGS. */
|
|
|
gimple
|
gimple
|
gimple_build_call_vec (tree fn, VEC(tree, heap) *args)
|
gimple_build_call_vec (tree fn, VEC(tree, heap) *args)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
unsigned nargs = VEC_length (tree, args);
|
unsigned nargs = VEC_length (tree, args);
|
gimple call = gimple_build_call_1 (fn, nargs);
|
gimple call = gimple_build_call_1 (fn, nargs);
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
gimple_call_set_arg (call, i, VEC_index (tree, args, i));
|
gimple_call_set_arg (call, i, VEC_index (tree, args, i));
|
|
|
return call;
|
return call;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
|
/* Build a GIMPLE_CALL statement to function FN. NARGS is the number of
|
arguments. The ... are the arguments. */
|
arguments. The ... are the arguments. */
|
|
|
gimple
|
gimple
|
gimple_build_call (tree fn, unsigned nargs, ...)
|
gimple_build_call (tree fn, unsigned nargs, ...)
|
{
|
{
|
va_list ap;
|
va_list ap;
|
gimple call;
|
gimple call;
|
unsigned i;
|
unsigned i;
|
|
|
gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
|
gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
|
|
|
call = gimple_build_call_1 (fn, nargs);
|
call = gimple_build_call_1 (fn, nargs);
|
|
|
va_start (ap, nargs);
|
va_start (ap, nargs);
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
gimple_call_set_arg (call, i, va_arg (ap, tree));
|
gimple_call_set_arg (call, i, va_arg (ap, tree));
|
va_end (ap);
|
va_end (ap);
|
|
|
return call;
|
return call;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
|
/* Build a GIMPLE_CALL statement from CALL_EXPR T. Note that T is
|
assumed to be in GIMPLE form already. Minimal checking is done of
|
assumed to be in GIMPLE form already. Minimal checking is done of
|
this fact. */
|
this fact. */
|
|
|
gimple
|
gimple
|
gimple_build_call_from_tree (tree t)
|
gimple_build_call_from_tree (tree t)
|
{
|
{
|
unsigned i, nargs;
|
unsigned i, nargs;
|
gimple call;
|
gimple call;
|
tree fndecl = get_callee_fndecl (t);
|
tree fndecl = get_callee_fndecl (t);
|
|
|
gcc_assert (TREE_CODE (t) == CALL_EXPR);
|
gcc_assert (TREE_CODE (t) == CALL_EXPR);
|
|
|
nargs = call_expr_nargs (t);
|
nargs = call_expr_nargs (t);
|
call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
|
call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
|
gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
|
|
|
gimple_set_block (call, TREE_BLOCK (t));
|
gimple_set_block (call, TREE_BLOCK (t));
|
|
|
/* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
|
/* Carry all the CALL_EXPR flags to the new GIMPLE_CALL. */
|
gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
|
gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
|
gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
|
gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
|
gimple_call_set_cannot_inline (call, CALL_CANNOT_INLINE_P (t));
|
gimple_call_set_cannot_inline (call, CALL_CANNOT_INLINE_P (t));
|
gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
|
gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
|
gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
|
gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
|
gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
|
gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
|
gimple_call_set_nothrow (call, TREE_NOTHROW (t));
|
gimple_call_set_nothrow (call, TREE_NOTHROW (t));
|
gimple_set_no_warning (call, TREE_NO_WARNING (t));
|
gimple_set_no_warning (call, TREE_NO_WARNING (t));
|
|
|
return call;
|
return call;
|
}
|
}
|
|
|
|
|
/* Extract the operands and code for expression EXPR into *SUBCODE_P,
|
/* Extract the operands and code for expression EXPR into *SUBCODE_P,
|
*OP1_P and *OP2_P respectively. */
|
*OP1_P and *OP2_P respectively. */
|
|
|
void
|
void
|
extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
|
extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
|
tree *op2_p)
|
tree *op2_p)
|
{
|
{
|
enum gimple_rhs_class grhs_class;
|
enum gimple_rhs_class grhs_class;
|
|
|
*subcode_p = TREE_CODE (expr);
|
*subcode_p = TREE_CODE (expr);
|
grhs_class = get_gimple_rhs_class (*subcode_p);
|
grhs_class = get_gimple_rhs_class (*subcode_p);
|
|
|
if (grhs_class == GIMPLE_BINARY_RHS)
|
if (grhs_class == GIMPLE_BINARY_RHS)
|
{
|
{
|
*op1_p = TREE_OPERAND (expr, 0);
|
*op1_p = TREE_OPERAND (expr, 0);
|
*op2_p = TREE_OPERAND (expr, 1);
|
*op2_p = TREE_OPERAND (expr, 1);
|
}
|
}
|
else if (grhs_class == GIMPLE_UNARY_RHS)
|
else if (grhs_class == GIMPLE_UNARY_RHS)
|
{
|
{
|
*op1_p = TREE_OPERAND (expr, 0);
|
*op1_p = TREE_OPERAND (expr, 0);
|
*op2_p = NULL_TREE;
|
*op2_p = NULL_TREE;
|
}
|
}
|
else if (grhs_class == GIMPLE_SINGLE_RHS)
|
else if (grhs_class == GIMPLE_SINGLE_RHS)
|
{
|
{
|
*op1_p = expr;
|
*op1_p = expr;
|
*op2_p = NULL_TREE;
|
*op2_p = NULL_TREE;
|
}
|
}
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_ASSIGN statement.
|
/* Build a GIMPLE_ASSIGN statement.
|
|
|
LHS of the assignment.
|
LHS of the assignment.
|
RHS of the assignment which can be unary or binary. */
|
RHS of the assignment which can be unary or binary. */
|
|
|
gimple
|
gimple
|
gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
|
gimple_build_assign_stat (tree lhs, tree rhs MEM_STAT_DECL)
|
{
|
{
|
enum tree_code subcode;
|
enum tree_code subcode;
|
tree op1, op2;
|
tree op1, op2;
|
|
|
extract_ops_from_tree (rhs, &subcode, &op1, &op2);
|
extract_ops_from_tree (rhs, &subcode, &op1, &op2);
|
return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2
|
return gimple_build_assign_with_ops_stat (subcode, lhs, op1, op2
|
PASS_MEM_STAT);
|
PASS_MEM_STAT);
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_ASSIGN statement with sub-code SUBCODE and operands
|
/* Build a GIMPLE_ASSIGN statement with sub-code SUBCODE and operands
|
OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
|
OP1 and OP2. If OP2 is NULL then SUBCODE must be of class
|
GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
|
GIMPLE_UNARY_RHS or GIMPLE_SINGLE_RHS. */
|
|
|
gimple
|
gimple
|
gimple_build_assign_with_ops_stat (enum tree_code subcode, tree lhs, tree op1,
|
gimple_build_assign_with_ops_stat (enum tree_code subcode, tree lhs, tree op1,
|
tree op2 MEM_STAT_DECL)
|
tree op2 MEM_STAT_DECL)
|
{
|
{
|
unsigned num_ops;
|
unsigned num_ops;
|
gimple p;
|
gimple p;
|
|
|
/* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
|
/* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
|
code). */
|
code). */
|
num_ops = get_gimple_rhs_num_ops (subcode) + 1;
|
num_ops = get_gimple_rhs_num_ops (subcode) + 1;
|
|
|
p = gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
|
p = gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
|
PASS_MEM_STAT);
|
PASS_MEM_STAT);
|
gimple_assign_set_lhs (p, lhs);
|
gimple_assign_set_lhs (p, lhs);
|
gimple_assign_set_rhs1 (p, op1);
|
gimple_assign_set_rhs1 (p, op1);
|
if (op2)
|
if (op2)
|
{
|
{
|
gcc_assert (num_ops > 2);
|
gcc_assert (num_ops > 2);
|
gimple_assign_set_rhs2 (p, op2);
|
gimple_assign_set_rhs2 (p, op2);
|
}
|
}
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
|
/* Build a new GIMPLE_ASSIGN tuple and append it to the end of *SEQ_P.
|
|
|
DST/SRC are the destination and source respectively. You can pass
|
DST/SRC are the destination and source respectively. You can pass
|
ungimplified trees in DST or SRC, in which case they will be
|
ungimplified trees in DST or SRC, in which case they will be
|
converted to a gimple operand if necessary.
|
converted to a gimple operand if necessary.
|
|
|
This function returns the newly created GIMPLE_ASSIGN tuple. */
|
This function returns the newly created GIMPLE_ASSIGN tuple. */
|
|
|
gimple
|
gimple
|
gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
|
gimplify_assign (tree dst, tree src, gimple_seq *seq_p)
|
{
|
{
|
tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
|
tree t = build2 (MODIFY_EXPR, TREE_TYPE (dst), dst, src);
|
gimplify_and_add (t, seq_p);
|
gimplify_and_add (t, seq_p);
|
ggc_free (t);
|
ggc_free (t);
|
return gimple_seq_last_stmt (*seq_p);
|
return gimple_seq_last_stmt (*seq_p);
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_COND statement.
|
/* Build a GIMPLE_COND statement.
|
|
|
PRED is the condition used to compare LHS and the RHS.
|
PRED is the condition used to compare LHS and the RHS.
|
T_LABEL is the label to jump to if the condition is true.
|
T_LABEL is the label to jump to if the condition is true.
|
F_LABEL is the label to jump to otherwise. */
|
F_LABEL is the label to jump to otherwise. */
|
|
|
gimple
|
gimple
|
gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
|
gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
|
tree t_label, tree f_label)
|
tree t_label, tree f_label)
|
{
|
{
|
gimple p;
|
gimple p;
|
|
|
gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
|
gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
|
p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
|
p = gimple_build_with_ops (GIMPLE_COND, pred_code, 4);
|
gimple_cond_set_lhs (p, lhs);
|
gimple_cond_set_lhs (p, lhs);
|
gimple_cond_set_rhs (p, rhs);
|
gimple_cond_set_rhs (p, rhs);
|
gimple_cond_set_true_label (p, t_label);
|
gimple_cond_set_true_label (p, t_label);
|
gimple_cond_set_false_label (p, f_label);
|
gimple_cond_set_false_label (p, f_label);
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
|
/* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */
|
|
|
void
|
void
|
gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
|
gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
|
tree *lhs_p, tree *rhs_p)
|
tree *lhs_p, tree *rhs_p)
|
{
|
{
|
location_t loc = EXPR_LOCATION (cond);
|
location_t loc = EXPR_LOCATION (cond);
|
gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
|
gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison
|
|| TREE_CODE (cond) == TRUTH_NOT_EXPR
|
|| TREE_CODE (cond) == TRUTH_NOT_EXPR
|
|| is_gimple_min_invariant (cond)
|
|| is_gimple_min_invariant (cond)
|
|| SSA_VAR_P (cond));
|
|| SSA_VAR_P (cond));
|
|
|
extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
|
extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
|
|
|
/* Canonicalize conditionals of the form 'if (!VAL)'. */
|
/* Canonicalize conditionals of the form 'if (!VAL)'. */
|
if (*code_p == TRUTH_NOT_EXPR)
|
if (*code_p == TRUTH_NOT_EXPR)
|
{
|
{
|
*code_p = EQ_EXPR;
|
*code_p = EQ_EXPR;
|
gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
|
gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
|
*rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
|
*rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
|
}
|
}
|
/* Canonicalize conditionals of the form 'if (VAL)' */
|
/* Canonicalize conditionals of the form 'if (VAL)' */
|
else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
|
else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
|
{
|
{
|
*code_p = NE_EXPR;
|
*code_p = NE_EXPR;
|
gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
|
gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
|
*rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
|
*rhs_p = fold_convert_loc (loc, TREE_TYPE (*lhs_p), integer_zero_node);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_COND statement from the conditional expression tree
|
/* Build a GIMPLE_COND statement from the conditional expression tree
|
COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
|
COND. T_LABEL and F_LABEL are as in gimple_build_cond. */
|
|
|
gimple
|
gimple
|
gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
|
gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
|
{
|
{
|
enum tree_code code;
|
enum tree_code code;
|
tree lhs, rhs;
|
tree lhs, rhs;
|
|
|
gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
|
gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
|
return gimple_build_cond (code, lhs, rhs, t_label, f_label);
|
return gimple_build_cond (code, lhs, rhs, t_label, f_label);
|
}
|
}
|
|
|
/* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
|
/* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
|
boolean expression tree COND. */
|
boolean expression tree COND. */
|
|
|
void
|
void
|
gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
|
gimple_cond_set_condition_from_tree (gimple stmt, tree cond)
|
{
|
{
|
enum tree_code code;
|
enum tree_code code;
|
tree lhs, rhs;
|
tree lhs, rhs;
|
|
|
gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
|
gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
|
gimple_cond_set_condition (stmt, code, lhs, rhs);
|
gimple_cond_set_condition (stmt, code, lhs, rhs);
|
}
|
}
|
|
|
/* Build a GIMPLE_LABEL statement for LABEL. */
|
/* Build a GIMPLE_LABEL statement for LABEL. */
|
|
|
gimple
|
gimple
|
gimple_build_label (tree label)
|
gimple_build_label (tree label)
|
{
|
{
|
gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
|
gimple p = gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1);
|
gimple_label_set_label (p, label);
|
gimple_label_set_label (p, label);
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_GOTO statement to label DEST. */
|
/* Build a GIMPLE_GOTO statement to label DEST. */
|
|
|
gimple
|
gimple
|
gimple_build_goto (tree dest)
|
gimple_build_goto (tree dest)
|
{
|
{
|
gimple p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
|
gimple p = gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1);
|
gimple_goto_set_dest (p, dest);
|
gimple_goto_set_dest (p, dest);
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_NOP statement. */
|
/* Build a GIMPLE_NOP statement. */
|
|
|
gimple
|
gimple
|
gimple_build_nop (void)
|
gimple_build_nop (void)
|
{
|
{
|
return gimple_alloc (GIMPLE_NOP, 0);
|
return gimple_alloc (GIMPLE_NOP, 0);
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_BIND statement.
|
/* Build a GIMPLE_BIND statement.
|
VARS are the variables in BODY.
|
VARS are the variables in BODY.
|
BLOCK is the containing block. */
|
BLOCK is the containing block. */
|
|
|
gimple
|
gimple
|
gimple_build_bind (tree vars, gimple_seq body, tree block)
|
gimple_build_bind (tree vars, gimple_seq body, tree block)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_BIND, 0);
|
gimple p = gimple_alloc (GIMPLE_BIND, 0);
|
gimple_bind_set_vars (p, vars);
|
gimple_bind_set_vars (p, vars);
|
if (body)
|
if (body)
|
gimple_bind_set_body (p, body);
|
gimple_bind_set_body (p, body);
|
if (block)
|
if (block)
|
gimple_bind_set_block (p, block);
|
gimple_bind_set_block (p, block);
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Helper function to set the simple fields of a asm stmt.
|
/* Helper function to set the simple fields of a asm stmt.
|
|
|
STRING is a pointer to a string that is the asm blocks assembly code.
|
STRING is a pointer to a string that is the asm blocks assembly code.
|
NINPUT is the number of register inputs.
|
NINPUT is the number of register inputs.
|
NOUTPUT is the number of register outputs.
|
NOUTPUT is the number of register outputs.
|
NCLOBBERS is the number of clobbered registers.
|
NCLOBBERS is the number of clobbered registers.
|
*/
|
*/
|
|
|
static inline gimple
|
static inline gimple
|
gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
|
gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
|
unsigned nclobbers, unsigned nlabels)
|
unsigned nclobbers, unsigned nlabels)
|
{
|
{
|
gimple p;
|
gimple p;
|
int size = strlen (string);
|
int size = strlen (string);
|
|
|
/* ASMs with labels cannot have outputs. This should have been
|
/* ASMs with labels cannot have outputs. This should have been
|
enforced by the front end. */
|
enforced by the front end. */
|
gcc_assert (nlabels == 0 || noutputs == 0);
|
gcc_assert (nlabels == 0 || noutputs == 0);
|
|
|
p = gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
|
p = gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
|
ninputs + noutputs + nclobbers + nlabels);
|
ninputs + noutputs + nclobbers + nlabels);
|
|
|
p->gimple_asm.ni = ninputs;
|
p->gimple_asm.ni = ninputs;
|
p->gimple_asm.no = noutputs;
|
p->gimple_asm.no = noutputs;
|
p->gimple_asm.nc = nclobbers;
|
p->gimple_asm.nc = nclobbers;
|
p->gimple_asm.nl = nlabels;
|
p->gimple_asm.nl = nlabels;
|
p->gimple_asm.string = ggc_alloc_string (string, size);
|
p->gimple_asm.string = ggc_alloc_string (string, size);
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
|
gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
|
#endif
|
#endif
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_ASM statement.
|
/* Build a GIMPLE_ASM statement.
|
|
|
STRING is the assembly code.
|
STRING is the assembly code.
|
NINPUT is the number of register inputs.
|
NINPUT is the number of register inputs.
|
NOUTPUT is the number of register outputs.
|
NOUTPUT is the number of register outputs.
|
NCLOBBERS is the number of clobbered registers.
|
NCLOBBERS is the number of clobbered registers.
|
INPUTS is a vector of the input register parameters.
|
INPUTS is a vector of the input register parameters.
|
OUTPUTS is a vector of the output register parameters.
|
OUTPUTS is a vector of the output register parameters.
|
CLOBBERS is a vector of the clobbered register parameters.
|
CLOBBERS is a vector of the clobbered register parameters.
|
LABELS is a vector of destination labels. */
|
LABELS is a vector of destination labels. */
|
|
|
gimple
|
gimple
|
gimple_build_asm_vec (const char *string, VEC(tree,gc)* inputs,
|
gimple_build_asm_vec (const char *string, VEC(tree,gc)* inputs,
|
VEC(tree,gc)* outputs, VEC(tree,gc)* clobbers,
|
VEC(tree,gc)* outputs, VEC(tree,gc)* clobbers,
|
VEC(tree,gc)* labels)
|
VEC(tree,gc)* labels)
|
{
|
{
|
gimple p;
|
gimple p;
|
unsigned i;
|
unsigned i;
|
|
|
p = gimple_build_asm_1 (string,
|
p = gimple_build_asm_1 (string,
|
VEC_length (tree, inputs),
|
VEC_length (tree, inputs),
|
VEC_length (tree, outputs),
|
VEC_length (tree, outputs),
|
VEC_length (tree, clobbers),
|
VEC_length (tree, clobbers),
|
VEC_length (tree, labels));
|
VEC_length (tree, labels));
|
|
|
for (i = 0; i < VEC_length (tree, inputs); i++)
|
for (i = 0; i < VEC_length (tree, inputs); i++)
|
gimple_asm_set_input_op (p, i, VEC_index (tree, inputs, i));
|
gimple_asm_set_input_op (p, i, VEC_index (tree, inputs, i));
|
|
|
for (i = 0; i < VEC_length (tree, outputs); i++)
|
for (i = 0; i < VEC_length (tree, outputs); i++)
|
gimple_asm_set_output_op (p, i, VEC_index (tree, outputs, i));
|
gimple_asm_set_output_op (p, i, VEC_index (tree, outputs, i));
|
|
|
for (i = 0; i < VEC_length (tree, clobbers); i++)
|
for (i = 0; i < VEC_length (tree, clobbers); i++)
|
gimple_asm_set_clobber_op (p, i, VEC_index (tree, clobbers, i));
|
gimple_asm_set_clobber_op (p, i, VEC_index (tree, clobbers, i));
|
|
|
for (i = 0; i < VEC_length (tree, labels); i++)
|
for (i = 0; i < VEC_length (tree, labels); i++)
|
gimple_asm_set_label_op (p, i, VEC_index (tree, labels, i));
|
gimple_asm_set_label_op (p, i, VEC_index (tree, labels, i));
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_CATCH statement.
|
/* Build a GIMPLE_CATCH statement.
|
|
|
TYPES are the catch types.
|
TYPES are the catch types.
|
HANDLER is the exception handler. */
|
HANDLER is the exception handler. */
|
|
|
gimple
|
gimple
|
gimple_build_catch (tree types, gimple_seq handler)
|
gimple_build_catch (tree types, gimple_seq handler)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_CATCH, 0);
|
gimple p = gimple_alloc (GIMPLE_CATCH, 0);
|
gimple_catch_set_types (p, types);
|
gimple_catch_set_types (p, types);
|
if (handler)
|
if (handler)
|
gimple_catch_set_handler (p, handler);
|
gimple_catch_set_handler (p, handler);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_EH_FILTER statement.
|
/* Build a GIMPLE_EH_FILTER statement.
|
|
|
TYPES are the filter's types.
|
TYPES are the filter's types.
|
FAILURE is the filter's failure action. */
|
FAILURE is the filter's failure action. */
|
|
|
gimple
|
gimple
|
gimple_build_eh_filter (tree types, gimple_seq failure)
|
gimple_build_eh_filter (tree types, gimple_seq failure)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
|
gimple p = gimple_alloc (GIMPLE_EH_FILTER, 0);
|
gimple_eh_filter_set_types (p, types);
|
gimple_eh_filter_set_types (p, types);
|
if (failure)
|
if (failure)
|
gimple_eh_filter_set_failure (p, failure);
|
gimple_eh_filter_set_failure (p, failure);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
|
/* Build a GIMPLE_EH_MUST_NOT_THROW statement. */
|
|
|
gimple
|
gimple
|
gimple_build_eh_must_not_throw (tree decl)
|
gimple_build_eh_must_not_throw (tree decl)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
|
gimple p = gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0);
|
|
|
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
|
gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
|
gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
|
gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
|
gimple_eh_must_not_throw_set_fndecl (p, decl);
|
gimple_eh_must_not_throw_set_fndecl (p, decl);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_TRY statement.
|
/* Build a GIMPLE_TRY statement.
|
|
|
EVAL is the expression to evaluate.
|
EVAL is the expression to evaluate.
|
CLEANUP is the cleanup expression.
|
CLEANUP is the cleanup expression.
|
KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
|
KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
|
whether this is a try/catch or a try/finally respectively. */
|
whether this is a try/catch or a try/finally respectively. */
|
|
|
gimple
|
gimple
|
gimple_build_try (gimple_seq eval, gimple_seq cleanup,
|
gimple_build_try (gimple_seq eval, gimple_seq cleanup,
|
enum gimple_try_flags kind)
|
enum gimple_try_flags kind)
|
{
|
{
|
gimple p;
|
gimple p;
|
|
|
gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
|
gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
|
p = gimple_alloc (GIMPLE_TRY, 0);
|
p = gimple_alloc (GIMPLE_TRY, 0);
|
gimple_set_subcode (p, kind);
|
gimple_set_subcode (p, kind);
|
if (eval)
|
if (eval)
|
gimple_try_set_eval (p, eval);
|
gimple_try_set_eval (p, eval);
|
if (cleanup)
|
if (cleanup)
|
gimple_try_set_cleanup (p, cleanup);
|
gimple_try_set_cleanup (p, cleanup);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
|
/* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
|
|
|
CLEANUP is the cleanup expression. */
|
CLEANUP is the cleanup expression. */
|
|
|
gimple
|
gimple
|
gimple_build_wce (gimple_seq cleanup)
|
gimple_build_wce (gimple_seq cleanup)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
|
gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
|
if (cleanup)
|
if (cleanup)
|
gimple_wce_set_cleanup (p, cleanup);
|
gimple_wce_set_cleanup (p, cleanup);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_RESX statement. */
|
/* Build a GIMPLE_RESX statement. */
|
|
|
gimple
|
gimple
|
gimple_build_resx (int region)
|
gimple_build_resx (int region)
|
{
|
{
|
gimple p = gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0);
|
gimple p = gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0);
|
p->gimple_eh_ctrl.region = region;
|
p->gimple_eh_ctrl.region = region;
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* The helper for constructing a gimple switch statement.
|
/* The helper for constructing a gimple switch statement.
|
INDEX is the switch's index.
|
INDEX is the switch's index.
|
NLABELS is the number of labels in the switch excluding the default.
|
NLABELS is the number of labels in the switch excluding the default.
|
DEFAULT_LABEL is the default label for the switch statement. */
|
DEFAULT_LABEL is the default label for the switch statement. */
|
|
|
gimple
|
gimple
|
gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
|
gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
|
{
|
{
|
/* nlabels + 1 default label + 1 index. */
|
/* nlabels + 1 default label + 1 index. */
|
gimple p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
|
gimple p = gimple_build_with_ops (GIMPLE_SWITCH, ERROR_MARK,
|
1 + (default_label != NULL) + nlabels);
|
1 + (default_label != NULL) + nlabels);
|
gimple_switch_set_index (p, index);
|
gimple_switch_set_index (p, index);
|
if (default_label)
|
if (default_label)
|
gimple_switch_set_default_label (p, default_label);
|
gimple_switch_set_default_label (p, default_label);
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_SWITCH statement.
|
/* Build a GIMPLE_SWITCH statement.
|
|
|
INDEX is the switch's index.
|
INDEX is the switch's index.
|
NLABELS is the number of labels in the switch excluding the DEFAULT_LABEL.
|
NLABELS is the number of labels in the switch excluding the DEFAULT_LABEL.
|
... are the labels excluding the default. */
|
... are the labels excluding the default. */
|
|
|
gimple
|
gimple
|
gimple_build_switch (unsigned nlabels, tree index, tree default_label, ...)
|
gimple_build_switch (unsigned nlabels, tree index, tree default_label, ...)
|
{
|
{
|
va_list al;
|
va_list al;
|
unsigned i, offset;
|
unsigned i, offset;
|
gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
|
gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
|
|
|
/* Store the rest of the labels. */
|
/* Store the rest of the labels. */
|
va_start (al, default_label);
|
va_start (al, default_label);
|
offset = (default_label != NULL);
|
offset = (default_label != NULL);
|
for (i = 0; i < nlabels; i++)
|
for (i = 0; i < nlabels; i++)
|
gimple_switch_set_label (p, i + offset, va_arg (al, tree));
|
gimple_switch_set_label (p, i + offset, va_arg (al, tree));
|
va_end (al);
|
va_end (al);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_SWITCH statement.
|
/* Build a GIMPLE_SWITCH statement.
|
|
|
INDEX is the switch's index.
|
INDEX is the switch's index.
|
DEFAULT_LABEL is the default label
|
DEFAULT_LABEL is the default label
|
ARGS is a vector of labels excluding the default. */
|
ARGS is a vector of labels excluding the default. */
|
|
|
gimple
|
gimple
|
gimple_build_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
|
gimple_build_switch_vec (tree index, tree default_label, VEC(tree, heap) *args)
|
{
|
{
|
unsigned i, offset, nlabels = VEC_length (tree, args);
|
unsigned i, offset, nlabels = VEC_length (tree, args);
|
gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
|
gimple p = gimple_build_switch_nlabels (nlabels, index, default_label);
|
|
|
/* Copy the labels from the vector to the switch statement. */
|
/* Copy the labels from the vector to the switch statement. */
|
offset = (default_label != NULL);
|
offset = (default_label != NULL);
|
for (i = 0; i < nlabels; i++)
|
for (i = 0; i < nlabels; i++)
|
gimple_switch_set_label (p, i + offset, VEC_index (tree, args, i));
|
gimple_switch_set_label (p, i + offset, VEC_index (tree, args, i));
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_EH_DISPATCH statement. */
|
/* Build a GIMPLE_EH_DISPATCH statement. */
|
|
|
gimple
|
gimple
|
gimple_build_eh_dispatch (int region)
|
gimple_build_eh_dispatch (int region)
|
{
|
{
|
gimple p = gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0);
|
gimple p = gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0);
|
p->gimple_eh_ctrl.region = region;
|
p->gimple_eh_ctrl.region = region;
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a new GIMPLE_DEBUG_BIND statement.
|
/* Build a new GIMPLE_DEBUG_BIND statement.
|
|
|
VAR is bound to VALUE; block and location are taken from STMT. */
|
VAR is bound to VALUE; block and location are taken from STMT. */
|
|
|
gimple
|
gimple
|
gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
|
gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
|
{
|
{
|
gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
|
gimple p = gimple_build_with_ops_stat (GIMPLE_DEBUG,
|
(unsigned)GIMPLE_DEBUG_BIND, 2
|
(unsigned)GIMPLE_DEBUG_BIND, 2
|
PASS_MEM_STAT);
|
PASS_MEM_STAT);
|
|
|
gimple_debug_bind_set_var (p, var);
|
gimple_debug_bind_set_var (p, var);
|
gimple_debug_bind_set_value (p, value);
|
gimple_debug_bind_set_value (p, value);
|
if (stmt)
|
if (stmt)
|
{
|
{
|
gimple_set_block (p, gimple_block (stmt));
|
gimple_set_block (p, gimple_block (stmt));
|
gimple_set_location (p, gimple_location (stmt));
|
gimple_set_location (p, gimple_location (stmt));
|
}
|
}
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_CRITICAL statement.
|
/* Build a GIMPLE_OMP_CRITICAL statement.
|
|
|
BODY is the sequence of statements for which only one thread can execute.
|
BODY is the sequence of statements for which only one thread can execute.
|
NAME is optional identifier for this critical block. */
|
NAME is optional identifier for this critical block. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_critical (gimple_seq body, tree name)
|
gimple_build_omp_critical (gimple_seq body, tree name)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_CRITICAL, 0);
|
gimple_omp_critical_set_name (p, name);
|
gimple_omp_critical_set_name (p, name);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_OMP_FOR statement.
|
/* Build a GIMPLE_OMP_FOR statement.
|
|
|
BODY is sequence of statements inside the for loop.
|
BODY is sequence of statements inside the for loop.
|
CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
|
CLAUSES, are any of the OMP loop construct's clauses: private, firstprivate,
|
lastprivate, reductions, ordered, schedule, and nowait.
|
lastprivate, reductions, ordered, schedule, and nowait.
|
COLLAPSE is the collapse count.
|
COLLAPSE is the collapse count.
|
PRE_BODY is the sequence of statements that are loop invariant. */
|
PRE_BODY is the sequence of statements that are loop invariant. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_for (gimple_seq body, tree clauses, size_t collapse,
|
gimple_build_omp_for (gimple_seq body, tree clauses, size_t collapse,
|
gimple_seq pre_body)
|
gimple_seq pre_body)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_FOR, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_FOR, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
gimple_omp_for_set_clauses (p, clauses);
|
gimple_omp_for_set_clauses (p, clauses);
|
p->gimple_omp_for.collapse = collapse;
|
p->gimple_omp_for.collapse = collapse;
|
p->gimple_omp_for.iter = GGC_CNEWVEC (struct gimple_omp_for_iter, collapse);
|
p->gimple_omp_for.iter = GGC_CNEWVEC (struct gimple_omp_for_iter, collapse);
|
if (pre_body)
|
if (pre_body)
|
gimple_omp_for_set_pre_body (p, pre_body);
|
gimple_omp_for_set_pre_body (p, pre_body);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_PARALLEL statement.
|
/* Build a GIMPLE_OMP_PARALLEL statement.
|
|
|
BODY is sequence of statements which are executed in parallel.
|
BODY is sequence of statements which are executed in parallel.
|
CLAUSES, are the OMP parallel construct's clauses.
|
CLAUSES, are the OMP parallel construct's clauses.
|
CHILD_FN is the function created for the parallel threads to execute.
|
CHILD_FN is the function created for the parallel threads to execute.
|
DATA_ARG are the shared data argument(s). */
|
DATA_ARG are the shared data argument(s). */
|
|
|
gimple
|
gimple
|
gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
|
gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
|
tree data_arg)
|
tree data_arg)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_PARALLEL, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
gimple_omp_parallel_set_clauses (p, clauses);
|
gimple_omp_parallel_set_clauses (p, clauses);
|
gimple_omp_parallel_set_child_fn (p, child_fn);
|
gimple_omp_parallel_set_child_fn (p, child_fn);
|
gimple_omp_parallel_set_data_arg (p, data_arg);
|
gimple_omp_parallel_set_data_arg (p, data_arg);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_TASK statement.
|
/* Build a GIMPLE_OMP_TASK statement.
|
|
|
BODY is sequence of statements which are executed by the explicit task.
|
BODY is sequence of statements which are executed by the explicit task.
|
CLAUSES, are the OMP parallel construct's clauses.
|
CLAUSES, are the OMP parallel construct's clauses.
|
CHILD_FN is the function created for the parallel threads to execute.
|
CHILD_FN is the function created for the parallel threads to execute.
|
DATA_ARG are the shared data argument(s).
|
DATA_ARG are the shared data argument(s).
|
COPY_FN is the optional function for firstprivate initialization.
|
COPY_FN is the optional function for firstprivate initialization.
|
ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
|
ARG_SIZE and ARG_ALIGN are size and alignment of the data block. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
|
gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
|
tree data_arg, tree copy_fn, tree arg_size,
|
tree data_arg, tree copy_fn, tree arg_size,
|
tree arg_align)
|
tree arg_align)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_TASK, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
gimple_omp_task_set_clauses (p, clauses);
|
gimple_omp_task_set_clauses (p, clauses);
|
gimple_omp_task_set_child_fn (p, child_fn);
|
gimple_omp_task_set_child_fn (p, child_fn);
|
gimple_omp_task_set_data_arg (p, data_arg);
|
gimple_omp_task_set_data_arg (p, data_arg);
|
gimple_omp_task_set_copy_fn (p, copy_fn);
|
gimple_omp_task_set_copy_fn (p, copy_fn);
|
gimple_omp_task_set_arg_size (p, arg_size);
|
gimple_omp_task_set_arg_size (p, arg_size);
|
gimple_omp_task_set_arg_align (p, arg_align);
|
gimple_omp_task_set_arg_align (p, arg_align);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_SECTION statement for a sections statement.
|
/* Build a GIMPLE_OMP_SECTION statement for a sections statement.
|
|
|
BODY is the sequence of statements in the section. */
|
BODY is the sequence of statements in the section. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_section (gimple_seq body)
|
gimple_build_omp_section (gimple_seq body)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_MASTER statement.
|
/* Build a GIMPLE_OMP_MASTER statement.
|
|
|
BODY is the sequence of statements to be executed by just the master. */
|
BODY is the sequence of statements to be executed by just the master. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_master (gimple_seq body)
|
gimple_build_omp_master (gimple_seq body)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_CONTINUE statement.
|
/* Build a GIMPLE_OMP_CONTINUE statement.
|
|
|
CONTROL_DEF is the definition of the control variable.
|
CONTROL_DEF is the definition of the control variable.
|
CONTROL_USE is the use of the control variable. */
|
CONTROL_USE is the use of the control variable. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_continue (tree control_def, tree control_use)
|
gimple_build_omp_continue (tree control_def, tree control_use)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_CONTINUE, 0);
|
gimple_omp_continue_set_control_def (p, control_def);
|
gimple_omp_continue_set_control_def (p, control_def);
|
gimple_omp_continue_set_control_use (p, control_use);
|
gimple_omp_continue_set_control_use (p, control_use);
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_OMP_ORDERED statement.
|
/* Build a GIMPLE_OMP_ORDERED statement.
|
|
|
BODY is the sequence of statements inside a loop that will executed in
|
BODY is the sequence of statements inside a loop that will executed in
|
sequence. */
|
sequence. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_ordered (gimple_seq body)
|
gimple_build_omp_ordered (gimple_seq body)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_RETURN statement.
|
/* Build a GIMPLE_OMP_RETURN statement.
|
WAIT_P is true if this is a non-waiting return. */
|
WAIT_P is true if this is a non-waiting return. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_return (bool wait_p)
|
gimple_build_omp_return (bool wait_p)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
|
if (wait_p)
|
if (wait_p)
|
gimple_omp_return_set_nowait (p);
|
gimple_omp_return_set_nowait (p);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_SECTIONS statement.
|
/* Build a GIMPLE_OMP_SECTIONS statement.
|
|
|
BODY is a sequence of section statements.
|
BODY is a sequence of section statements.
|
CLAUSES are any of the OMP sections contsruct's clauses: private,
|
CLAUSES are any of the OMP sections contsruct's clauses: private,
|
firstprivate, lastprivate, reduction, and nowait. */
|
firstprivate, lastprivate, reduction, and nowait. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_sections (gimple_seq body, tree clauses)
|
gimple_build_omp_sections (gimple_seq body, tree clauses)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_SECTIONS, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
gimple_omp_sections_set_clauses (p, clauses);
|
gimple_omp_sections_set_clauses (p, clauses);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
|
/* Build a GIMPLE_OMP_SECTIONS_SWITCH. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_sections_switch (void)
|
gimple_build_omp_sections_switch (void)
|
{
|
{
|
return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
|
return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_SINGLE statement.
|
/* Build a GIMPLE_OMP_SINGLE statement.
|
|
|
BODY is the sequence of statements that will be executed once.
|
BODY is the sequence of statements that will be executed once.
|
CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
|
CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
|
copyprivate, nowait. */
|
copyprivate, nowait. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_single (gimple_seq body, tree clauses)
|
gimple_build_omp_single (gimple_seq body, tree clauses)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_SINGLE, 0);
|
if (body)
|
if (body)
|
gimple_omp_set_body (p, body);
|
gimple_omp_set_body (p, body);
|
gimple_omp_single_set_clauses (p, clauses);
|
gimple_omp_single_set_clauses (p, clauses);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
|
/* Build a GIMPLE_OMP_ATOMIC_LOAD statement. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_atomic_load (tree lhs, tree rhs)
|
gimple_build_omp_atomic_load (tree lhs, tree rhs)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0);
|
gimple_omp_atomic_load_set_lhs (p, lhs);
|
gimple_omp_atomic_load_set_lhs (p, lhs);
|
gimple_omp_atomic_load_set_rhs (p, rhs);
|
gimple_omp_atomic_load_set_rhs (p, rhs);
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_OMP_ATOMIC_STORE statement.
|
/* Build a GIMPLE_OMP_ATOMIC_STORE statement.
|
|
|
VAL is the value we are storing. */
|
VAL is the value we are storing. */
|
|
|
gimple
|
gimple
|
gimple_build_omp_atomic_store (tree val)
|
gimple_build_omp_atomic_store (tree val)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
|
gimple p = gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0);
|
gimple_omp_atomic_store_set_val (p, val);
|
gimple_omp_atomic_store_set_val (p, val);
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
|
/* Build a GIMPLE_PREDICT statement. PREDICT is one of the predictors from
|
predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
|
predict.def, OUTCOME is NOT_TAKEN or TAKEN. */
|
|
|
gimple
|
gimple
|
gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
|
gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
|
{
|
{
|
gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
|
gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
|
/* Ensure all the predictors fit into the lower bits of the subcode. */
|
/* Ensure all the predictors fit into the lower bits of the subcode. */
|
gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
|
gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
|
gimple_predict_set_predictor (p, predictor);
|
gimple_predict_set_predictor (p, predictor);
|
gimple_predict_set_outcome (p, outcome);
|
gimple_predict_set_outcome (p, outcome);
|
return p;
|
return p;
|
}
|
}
|
|
|
#if defined ENABLE_GIMPLE_CHECKING
|
#if defined ENABLE_GIMPLE_CHECKING
|
/* Complain of a gimple type mismatch and die. */
|
/* Complain of a gimple type mismatch and die. */
|
|
|
void
|
void
|
gimple_check_failed (const_gimple gs, const char *file, int line,
|
gimple_check_failed (const_gimple gs, const char *file, int line,
|
const char *function, enum gimple_code code,
|
const char *function, enum gimple_code code,
|
enum tree_code subcode)
|
enum tree_code subcode)
|
{
|
{
|
internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
|
internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
|
gimple_code_name[code],
|
gimple_code_name[code],
|
tree_code_name[subcode],
|
tree_code_name[subcode],
|
gimple_code_name[gimple_code (gs)],
|
gimple_code_name[gimple_code (gs)],
|
gs->gsbase.subcode > 0
|
gs->gsbase.subcode > 0
|
? tree_code_name[gs->gsbase.subcode]
|
? tree_code_name[gs->gsbase.subcode]
|
: "",
|
: "",
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
#endif /* ENABLE_GIMPLE_CHECKING */
|
#endif /* ENABLE_GIMPLE_CHECKING */
|
|
|
|
|
/* Allocate a new GIMPLE sequence in GC memory and return it. If
|
/* Allocate a new GIMPLE sequence in GC memory and return it. If
|
there are free sequences in GIMPLE_SEQ_CACHE return one of those
|
there are free sequences in GIMPLE_SEQ_CACHE return one of those
|
instead. */
|
instead. */
|
|
|
gimple_seq
|
gimple_seq
|
gimple_seq_alloc (void)
|
gimple_seq_alloc (void)
|
{
|
{
|
gimple_seq seq = gimple_seq_cache;
|
gimple_seq seq = gimple_seq_cache;
|
if (seq)
|
if (seq)
|
{
|
{
|
gimple_seq_cache = gimple_seq_cache->next_free;
|
gimple_seq_cache = gimple_seq_cache->next_free;
|
gcc_assert (gimple_seq_cache != seq);
|
gcc_assert (gimple_seq_cache != seq);
|
memset (seq, 0, sizeof (*seq));
|
memset (seq, 0, sizeof (*seq));
|
}
|
}
|
else
|
else
|
{
|
{
|
seq = (gimple_seq) ggc_alloc_cleared (sizeof (*seq));
|
seq = (gimple_seq) ggc_alloc_cleared (sizeof (*seq));
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
|
gimple_alloc_counts[(int) gimple_alloc_kind_seq]++;
|
gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
|
gimple_alloc_sizes[(int) gimple_alloc_kind_seq] += sizeof (*seq);
|
#endif
|
#endif
|
}
|
}
|
|
|
return seq;
|
return seq;
|
}
|
}
|
|
|
/* Return SEQ to the free pool of GIMPLE sequences. */
|
/* Return SEQ to the free pool of GIMPLE sequences. */
|
|
|
void
|
void
|
gimple_seq_free (gimple_seq seq)
|
gimple_seq_free (gimple_seq seq)
|
{
|
{
|
if (seq == NULL)
|
if (seq == NULL)
|
return;
|
return;
|
|
|
gcc_assert (gimple_seq_first (seq) == NULL);
|
gcc_assert (gimple_seq_first (seq) == NULL);
|
gcc_assert (gimple_seq_last (seq) == NULL);
|
gcc_assert (gimple_seq_last (seq) == NULL);
|
|
|
/* If this triggers, it's a sign that the same list is being freed
|
/* If this triggers, it's a sign that the same list is being freed
|
twice. */
|
twice. */
|
gcc_assert (seq != gimple_seq_cache || gimple_seq_cache == NULL);
|
gcc_assert (seq != gimple_seq_cache || gimple_seq_cache == NULL);
|
|
|
/* Add SEQ to the pool of free sequences. */
|
/* Add SEQ to the pool of free sequences. */
|
seq->next_free = gimple_seq_cache;
|
seq->next_free = gimple_seq_cache;
|
gimple_seq_cache = seq;
|
gimple_seq_cache = seq;
|
}
|
}
|
|
|
|
|
/* Link gimple statement GS to the end of the sequence *SEQ_P. If
|
/* Link gimple statement GS to the end of the sequence *SEQ_P. If
|
*SEQ_P is NULL, a new sequence is allocated. */
|
*SEQ_P is NULL, a new sequence is allocated. */
|
|
|
void
|
void
|
gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
|
gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
|
{
|
{
|
gimple_stmt_iterator si;
|
gimple_stmt_iterator si;
|
|
|
if (gs == NULL)
|
if (gs == NULL)
|
return;
|
return;
|
|
|
if (*seq_p == NULL)
|
if (*seq_p == NULL)
|
*seq_p = gimple_seq_alloc ();
|
*seq_p = gimple_seq_alloc ();
|
|
|
si = gsi_last (*seq_p);
|
si = gsi_last (*seq_p);
|
gsi_insert_after (&si, gs, GSI_NEW_STMT);
|
gsi_insert_after (&si, gs, GSI_NEW_STMT);
|
}
|
}
|
|
|
|
|
/* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
|
/* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
|
NULL, a new sequence is allocated. */
|
NULL, a new sequence is allocated. */
|
|
|
void
|
void
|
gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
|
gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
|
{
|
{
|
gimple_stmt_iterator si;
|
gimple_stmt_iterator si;
|
|
|
if (src == NULL)
|
if (src == NULL)
|
return;
|
return;
|
|
|
if (*dst_p == NULL)
|
if (*dst_p == NULL)
|
*dst_p = gimple_seq_alloc ();
|
*dst_p = gimple_seq_alloc ();
|
|
|
si = gsi_last (*dst_p);
|
si = gsi_last (*dst_p);
|
gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
|
gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
|
}
|
}
|
|
|
|
|
/* Helper function of empty_body_p. Return true if STMT is an empty
|
/* Helper function of empty_body_p. Return true if STMT is an empty
|
statement. */
|
statement. */
|
|
|
static bool
|
static bool
|
empty_stmt_p (gimple stmt)
|
empty_stmt_p (gimple stmt)
|
{
|
{
|
if (gimple_code (stmt) == GIMPLE_NOP)
|
if (gimple_code (stmt) == GIMPLE_NOP)
|
return true;
|
return true;
|
if (gimple_code (stmt) == GIMPLE_BIND)
|
if (gimple_code (stmt) == GIMPLE_BIND)
|
return empty_body_p (gimple_bind_body (stmt));
|
return empty_body_p (gimple_bind_body (stmt));
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Return true if BODY contains nothing but empty statements. */
|
/* Return true if BODY contains nothing but empty statements. */
|
|
|
bool
|
bool
|
empty_body_p (gimple_seq body)
|
empty_body_p (gimple_seq body)
|
{
|
{
|
gimple_stmt_iterator i;
|
gimple_stmt_iterator i;
|
|
|
if (gimple_seq_empty_p (body))
|
if (gimple_seq_empty_p (body))
|
return true;
|
return true;
|
for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
|
for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
|
if (!empty_stmt_p (gsi_stmt (i))
|
if (!empty_stmt_p (gsi_stmt (i))
|
&& !is_gimple_debug (gsi_stmt (i)))
|
&& !is_gimple_debug (gsi_stmt (i)))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Perform a deep copy of sequence SRC and return the result. */
|
/* Perform a deep copy of sequence SRC and return the result. */
|
|
|
gimple_seq
|
gimple_seq
|
gimple_seq_copy (gimple_seq src)
|
gimple_seq_copy (gimple_seq src)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
gimple_seq new_seq = gimple_seq_alloc ();
|
gimple_seq new_seq = gimple_seq_alloc ();
|
gimple stmt;
|
gimple stmt;
|
|
|
for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
stmt = gimple_copy (gsi_stmt (gsi));
|
stmt = gimple_copy (gsi_stmt (gsi));
|
gimple_seq_add_stmt (&new_seq, stmt);
|
gimple_seq_add_stmt (&new_seq, stmt);
|
}
|
}
|
|
|
return new_seq;
|
return new_seq;
|
}
|
}
|
|
|
|
|
/* Walk all the statements in the sequence SEQ calling walk_gimple_stmt
|
/* Walk all the statements in the sequence SEQ calling walk_gimple_stmt
|
on each one. WI is as in walk_gimple_stmt.
|
on each one. WI is as in walk_gimple_stmt.
|
|
|
If walk_gimple_stmt returns non-NULL, the walk is stopped, the
|
If walk_gimple_stmt returns non-NULL, the walk is stopped, the
|
value is stored in WI->CALLBACK_RESULT and the statement that
|
value is stored in WI->CALLBACK_RESULT and the statement that
|
produced the value is returned.
|
produced the value is returned.
|
|
|
Otherwise, all the statements are walked and NULL returned. */
|
Otherwise, all the statements are walked and NULL returned. */
|
|
|
gimple
|
gimple
|
walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
|
walk_gimple_seq (gimple_seq seq, walk_stmt_fn callback_stmt,
|
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
{
|
{
|
gimple_stmt_iterator gsi;
|
gimple_stmt_iterator gsi;
|
|
|
for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
|
for (gsi = gsi_start (seq); !gsi_end_p (gsi); gsi_next (&gsi))
|
{
|
{
|
tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
|
tree ret = walk_gimple_stmt (&gsi, callback_stmt, callback_op, wi);
|
if (ret)
|
if (ret)
|
{
|
{
|
/* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
|
/* If CALLBACK_STMT or CALLBACK_OP return a value, WI must exist
|
to hold it. */
|
to hold it. */
|
gcc_assert (wi);
|
gcc_assert (wi);
|
wi->callback_result = ret;
|
wi->callback_result = ret;
|
return gsi_stmt (gsi);
|
return gsi_stmt (gsi);
|
}
|
}
|
}
|
}
|
|
|
if (wi)
|
if (wi)
|
wi->callback_result = NULL_TREE;
|
wi->callback_result = NULL_TREE;
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
|
|
/* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
|
/* Helper function for walk_gimple_stmt. Walk operands of a GIMPLE_ASM. */
|
|
|
static tree
|
static tree
|
walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
|
walk_gimple_asm (gimple stmt, walk_tree_fn callback_op,
|
struct walk_stmt_info *wi)
|
struct walk_stmt_info *wi)
|
{
|
{
|
tree ret, op;
|
tree ret, op;
|
unsigned noutputs;
|
unsigned noutputs;
|
const char **oconstraints;
|
const char **oconstraints;
|
unsigned i, n;
|
unsigned i, n;
|
const char *constraint;
|
const char *constraint;
|
bool allows_mem, allows_reg, is_inout;
|
bool allows_mem, allows_reg, is_inout;
|
|
|
noutputs = gimple_asm_noutputs (stmt);
|
noutputs = gimple_asm_noutputs (stmt);
|
oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
|
oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
|
|
|
if (wi)
|
if (wi)
|
wi->is_lhs = true;
|
wi->is_lhs = true;
|
|
|
for (i = 0; i < noutputs; i++)
|
for (i = 0; i < noutputs; i++)
|
{
|
{
|
op = gimple_asm_output_op (stmt, i);
|
op = gimple_asm_output_op (stmt, i);
|
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
|
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
|
oconstraints[i] = constraint;
|
oconstraints[i] = constraint;
|
parse_output_constraint (&constraint, i, 0, 0, &allows_mem, &allows_reg,
|
parse_output_constraint (&constraint, i, 0, 0, &allows_mem, &allows_reg,
|
&is_inout);
|
&is_inout);
|
if (wi)
|
if (wi)
|
wi->val_only = (allows_reg || !allows_mem);
|
wi->val_only = (allows_reg || !allows_mem);
|
ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
|
ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
}
|
}
|
|
|
n = gimple_asm_ninputs (stmt);
|
n = gimple_asm_ninputs (stmt);
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
{
|
{
|
op = gimple_asm_input_op (stmt, i);
|
op = gimple_asm_input_op (stmt, i);
|
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
|
constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
|
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);
|
if (wi)
|
if (wi)
|
{
|
{
|
wi->val_only = (allows_reg || !allows_mem);
|
wi->val_only = (allows_reg || !allows_mem);
|
/* Although input "m" is not really a LHS, we need a lvalue. */
|
/* Although input "m" is not really a LHS, we need a lvalue. */
|
wi->is_lhs = !wi->val_only;
|
wi->is_lhs = !wi->val_only;
|
}
|
}
|
ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
|
ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
}
|
}
|
|
|
if (wi)
|
if (wi)
|
{
|
{
|
wi->is_lhs = false;
|
wi->is_lhs = false;
|
wi->val_only = true;
|
wi->val_only = true;
|
}
|
}
|
|
|
n = gimple_asm_nlabels (stmt);
|
n = gimple_asm_nlabels (stmt);
|
for (i = 0; i < n; i++)
|
for (i = 0; i < n; i++)
|
{
|
{
|
op = gimple_asm_label_op (stmt, i);
|
op = gimple_asm_label_op (stmt, i);
|
ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
|
ret = walk_tree (&TREE_VALUE (op), callback_op, wi, NULL);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Helper function of WALK_GIMPLE_STMT. Walk every tree operand in
|
/* Helper function of WALK_GIMPLE_STMT. Walk every tree operand in
|
STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
|
STMT. CALLBACK_OP and WI are as in WALK_GIMPLE_STMT.
|
|
|
CALLBACK_OP is called on each operand of STMT via walk_tree.
|
CALLBACK_OP is called on each operand of STMT via walk_tree.
|
Additional parameters to walk_tree must be stored in WI. For each operand
|
Additional parameters to walk_tree must be stored in WI. For each operand
|
OP, walk_tree is called as:
|
OP, walk_tree is called as:
|
|
|
walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
|
walk_tree (&OP, CALLBACK_OP, WI, WI->PSET)
|
|
|
If CALLBACK_OP returns non-NULL for an operand, the remaining
|
If CALLBACK_OP returns non-NULL for an operand, the remaining
|
operands are not scanned.
|
operands are not scanned.
|
|
|
The return value is that returned by the last call to walk_tree, or
|
The return value is that returned by the last call to walk_tree, or
|
NULL_TREE if no CALLBACK_OP is specified. */
|
NULL_TREE if no CALLBACK_OP is specified. */
|
|
|
tree
|
tree
|
walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
|
walk_gimple_op (gimple stmt, walk_tree_fn callback_op,
|
struct walk_stmt_info *wi)
|
struct walk_stmt_info *wi)
|
{
|
{
|
struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
|
struct pointer_set_t *pset = (wi) ? wi->pset : NULL;
|
unsigned i;
|
unsigned i;
|
tree ret = NULL_TREE;
|
tree ret = NULL_TREE;
|
|
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
/* Walk the RHS operands. A formal temporary LHS may use a
|
/* Walk the RHS operands. A formal temporary LHS may use a
|
COMPONENT_REF RHS. */
|
COMPONENT_REF RHS. */
|
if (wi)
|
if (wi)
|
wi->val_only = !is_gimple_reg (gimple_assign_lhs (stmt))
|
wi->val_only = !is_gimple_reg (gimple_assign_lhs (stmt))
|
|| !gimple_assign_single_p (stmt);
|
|| !gimple_assign_single_p (stmt);
|
|
|
for (i = 1; i < gimple_num_ops (stmt); i++)
|
for (i = 1; i < gimple_num_ops (stmt); i++)
|
{
|
{
|
ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
|
ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Walk the LHS. If the RHS is appropriate for a memory, we
|
/* Walk the LHS. If the RHS is appropriate for a memory, we
|
may use a COMPONENT_REF on the LHS. */
|
may use a COMPONENT_REF on the LHS. */
|
if (wi)
|
if (wi)
|
{
|
{
|
/* If the RHS has more than 1 operand, it is not appropriate
|
/* If the RHS has more than 1 operand, it is not appropriate
|
for the memory. */
|
for the memory. */
|
wi->val_only = !is_gimple_mem_rhs (gimple_assign_rhs1 (stmt))
|
wi->val_only = !is_gimple_mem_rhs (gimple_assign_rhs1 (stmt))
|
|| !gimple_assign_single_p (stmt);
|
|| !gimple_assign_single_p (stmt);
|
wi->is_lhs = true;
|
wi->is_lhs = true;
|
}
|
}
|
|
|
ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
|
ret = walk_tree (gimple_op_ptr (stmt, 0), callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
if (wi)
|
if (wi)
|
{
|
{
|
wi->val_only = true;
|
wi->val_only = true;
|
wi->is_lhs = false;
|
wi->is_lhs = false;
|
}
|
}
|
break;
|
break;
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
if (wi)
|
if (wi)
|
wi->is_lhs = false;
|
wi->is_lhs = false;
|
|
|
ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
|
ret = walk_tree (gimple_call_chain_ptr (stmt), callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
|
ret = walk_tree (gimple_call_fn_ptr (stmt), callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
for (i = 0; i < gimple_call_num_args (stmt); i++)
|
for (i = 0; i < gimple_call_num_args (stmt); i++)
|
{
|
{
|
ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
|
ret = walk_tree (gimple_call_arg_ptr (stmt, i), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
}
|
}
|
|
|
if (wi)
|
if (wi)
|
wi->is_lhs = true;
|
wi->is_lhs = true;
|
|
|
ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
|
ret = walk_tree (gimple_call_lhs_ptr (stmt), callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
if (wi)
|
if (wi)
|
wi->is_lhs = false;
|
wi->is_lhs = false;
|
break;
|
break;
|
|
|
case GIMPLE_CATCH:
|
case GIMPLE_CATCH:
|
ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_catch_types_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_EH_FILTER:
|
case GIMPLE_EH_FILTER:
|
ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_eh_filter_types_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_ASM:
|
case GIMPLE_ASM:
|
ret = walk_gimple_asm (stmt, callback_op, wi);
|
ret = walk_gimple_asm (stmt, callback_op, wi);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_CONTINUE:
|
case GIMPLE_OMP_CONTINUE:
|
ret = walk_tree (gimple_omp_continue_control_def_ptr (stmt),
|
ret = walk_tree (gimple_omp_continue_control_def_ptr (stmt),
|
callback_op, wi, pset);
|
callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
ret = walk_tree (gimple_omp_continue_control_use_ptr (stmt),
|
ret = walk_tree (gimple_omp_continue_control_use_ptr (stmt),
|
callback_op, wi, pset);
|
callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_CRITICAL:
|
case GIMPLE_OMP_CRITICAL:
|
ret = walk_tree (gimple_omp_critical_name_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_omp_critical_name_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_FOR:
|
case GIMPLE_OMP_FOR:
|
ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_omp_for_clauses_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
|
for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
|
{
|
{
|
ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
|
ret = walk_tree (gimple_omp_for_index_ptr (stmt, i), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
|
ret = walk_tree (gimple_omp_for_initial_ptr (stmt, i), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
|
ret = walk_tree (gimple_omp_for_final_ptr (stmt, i), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
|
ret = walk_tree (gimple_omp_for_incr_ptr (stmt, i), callback_op,
|
wi, pset);
|
wi, pset);
|
}
|
}
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_PARALLEL:
|
case GIMPLE_OMP_PARALLEL:
|
ret = walk_tree (gimple_omp_parallel_clauses_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_parallel_clauses_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_parallel_child_fn_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_parallel_child_fn_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_parallel_data_arg_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_parallel_data_arg_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_TASK:
|
case GIMPLE_OMP_TASK:
|
ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_task_clauses_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_task_child_fn_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_task_data_arg_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_task_copy_fn_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_task_arg_size_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_task_arg_align_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_SECTIONS:
|
case GIMPLE_OMP_SECTIONS:
|
ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_sections_clauses_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_sections_control_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
break;
|
break;
|
|
|
case GIMPLE_OMP_SINGLE:
|
case GIMPLE_OMP_SINGLE:
|
ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_omp_single_clauses_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_ATOMIC_LOAD:
|
case GIMPLE_OMP_ATOMIC_LOAD:
|
ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_omp_atomic_load_lhs_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
|
|
ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi,
|
ret = walk_tree (gimple_omp_atomic_load_rhs_ptr (stmt), callback_op, wi,
|
pset);
|
pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_ATOMIC_STORE:
|
case GIMPLE_OMP_ATOMIC_STORE:
|
ret = walk_tree (gimple_omp_atomic_store_val_ptr (stmt), callback_op,
|
ret = walk_tree (gimple_omp_atomic_store_val_ptr (stmt), callback_op,
|
wi, pset);
|
wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
break;
|
break;
|
|
|
/* Tuples that do not have operands. */
|
/* Tuples that do not have operands. */
|
case GIMPLE_NOP:
|
case GIMPLE_NOP:
|
case GIMPLE_RESX:
|
case GIMPLE_RESX:
|
case GIMPLE_OMP_RETURN:
|
case GIMPLE_OMP_RETURN:
|
case GIMPLE_PREDICT:
|
case GIMPLE_PREDICT:
|
break;
|
break;
|
|
|
default:
|
default:
|
{
|
{
|
enum gimple_statement_structure_enum gss;
|
enum gimple_statement_structure_enum gss;
|
gss = gimple_statement_structure (stmt);
|
gss = gimple_statement_structure (stmt);
|
if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
|
if (gss == GSS_WITH_OPS || gss == GSS_WITH_MEM_OPS)
|
for (i = 0; i < gimple_num_ops (stmt); i++)
|
for (i = 0; i < gimple_num_ops (stmt); i++)
|
{
|
{
|
ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
|
ret = walk_tree (gimple_op_ptr (stmt, i), callback_op, wi, pset);
|
if (ret)
|
if (ret)
|
return ret;
|
return ret;
|
}
|
}
|
}
|
}
|
break;
|
break;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Walk the current statement in GSI (optionally using traversal state
|
/* Walk the current statement in GSI (optionally using traversal state
|
stored in WI). If WI is NULL, no state is kept during traversal.
|
stored in WI). If WI is NULL, no state is kept during traversal.
|
The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates
|
The callback CALLBACK_STMT is called. If CALLBACK_STMT indicates
|
that it has handled all the operands of the statement, its return
|
that it has handled all the operands of the statement, its return
|
value is returned. Otherwise, the return value from CALLBACK_STMT
|
value is returned. Otherwise, the return value from CALLBACK_STMT
|
is discarded and its operands are scanned.
|
is discarded and its operands are scanned.
|
|
|
If CALLBACK_STMT is NULL or it didn't handle the operands,
|
If CALLBACK_STMT is NULL or it didn't handle the operands,
|
CALLBACK_OP is called on each operand of the statement via
|
CALLBACK_OP is called on each operand of the statement via
|
walk_gimple_op. If walk_gimple_op returns non-NULL for any
|
walk_gimple_op. If walk_gimple_op returns non-NULL for any
|
operand, the remaining operands are not scanned. In this case, the
|
operand, the remaining operands are not scanned. In this case, the
|
return value from CALLBACK_OP is returned.
|
return value from CALLBACK_OP is returned.
|
|
|
In any other case, NULL_TREE is returned. */
|
In any other case, NULL_TREE is returned. */
|
|
|
tree
|
tree
|
walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
|
walk_gimple_stmt (gimple_stmt_iterator *gsi, walk_stmt_fn callback_stmt,
|
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
walk_tree_fn callback_op, struct walk_stmt_info *wi)
|
{
|
{
|
gimple ret;
|
gimple ret;
|
tree tree_ret;
|
tree tree_ret;
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
|
|
if (wi)
|
if (wi)
|
wi->gsi = *gsi;
|
wi->gsi = *gsi;
|
|
|
if (wi && wi->want_locations && gimple_has_location (stmt))
|
if (wi && wi->want_locations && gimple_has_location (stmt))
|
input_location = gimple_location (stmt);
|
input_location = gimple_location (stmt);
|
|
|
ret = NULL;
|
ret = NULL;
|
|
|
/* Invoke the statement callback. Return if the callback handled
|
/* Invoke the statement callback. Return if the callback handled
|
all of STMT operands by itself. */
|
all of STMT operands by itself. */
|
if (callback_stmt)
|
if (callback_stmt)
|
{
|
{
|
bool handled_ops = false;
|
bool handled_ops = false;
|
tree_ret = callback_stmt (gsi, &handled_ops, wi);
|
tree_ret = callback_stmt (gsi, &handled_ops, wi);
|
if (handled_ops)
|
if (handled_ops)
|
return tree_ret;
|
return tree_ret;
|
|
|
/* If CALLBACK_STMT did not handle operands, it should not have
|
/* If CALLBACK_STMT did not handle operands, it should not have
|
a value to return. */
|
a value to return. */
|
gcc_assert (tree_ret == NULL);
|
gcc_assert (tree_ret == NULL);
|
|
|
/* Re-read stmt in case the callback changed it. */
|
/* Re-read stmt in case the callback changed it. */
|
stmt = gsi_stmt (*gsi);
|
stmt = gsi_stmt (*gsi);
|
}
|
}
|
|
|
/* If CALLBACK_OP is defined, invoke it on every operand of STMT. */
|
/* If CALLBACK_OP is defined, invoke it on every operand of STMT. */
|
if (callback_op)
|
if (callback_op)
|
{
|
{
|
tree_ret = walk_gimple_op (stmt, callback_op, wi);
|
tree_ret = walk_gimple_op (stmt, callback_op, wi);
|
if (tree_ret)
|
if (tree_ret)
|
return tree_ret;
|
return tree_ret;
|
}
|
}
|
|
|
/* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them. */
|
/* If STMT can have statements inside (e.g. GIMPLE_BIND), walk them. */
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_BIND:
|
case GIMPLE_BIND:
|
ret = walk_gimple_seq (gimple_bind_body (stmt), callback_stmt,
|
ret = walk_gimple_seq (gimple_bind_body (stmt), callback_stmt,
|
callback_op, wi);
|
callback_op, wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
break;
|
break;
|
|
|
case GIMPLE_CATCH:
|
case GIMPLE_CATCH:
|
ret = walk_gimple_seq (gimple_catch_handler (stmt), callback_stmt,
|
ret = walk_gimple_seq (gimple_catch_handler (stmt), callback_stmt,
|
callback_op, wi);
|
callback_op, wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
break;
|
break;
|
|
|
case GIMPLE_EH_FILTER:
|
case GIMPLE_EH_FILTER:
|
ret = walk_gimple_seq (gimple_eh_filter_failure (stmt), callback_stmt,
|
ret = walk_gimple_seq (gimple_eh_filter_failure (stmt), callback_stmt,
|
callback_op, wi);
|
callback_op, wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
break;
|
break;
|
|
|
case GIMPLE_TRY:
|
case GIMPLE_TRY:
|
ret = walk_gimple_seq (gimple_try_eval (stmt), callback_stmt, callback_op,
|
ret = walk_gimple_seq (gimple_try_eval (stmt), callback_stmt, callback_op,
|
wi);
|
wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
|
|
ret = walk_gimple_seq (gimple_try_cleanup (stmt), callback_stmt,
|
ret = walk_gimple_seq (gimple_try_cleanup (stmt), callback_stmt,
|
callback_op, wi);
|
callback_op, wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
break;
|
break;
|
|
|
case GIMPLE_OMP_FOR:
|
case GIMPLE_OMP_FOR:
|
ret = walk_gimple_seq (gimple_omp_for_pre_body (stmt), callback_stmt,
|
ret = walk_gimple_seq (gimple_omp_for_pre_body (stmt), callback_stmt,
|
callback_op, wi);
|
callback_op, wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
|
|
/* FALL THROUGH. */
|
/* FALL THROUGH. */
|
case GIMPLE_OMP_CRITICAL:
|
case GIMPLE_OMP_CRITICAL:
|
case GIMPLE_OMP_MASTER:
|
case GIMPLE_OMP_MASTER:
|
case GIMPLE_OMP_ORDERED:
|
case GIMPLE_OMP_ORDERED:
|
case GIMPLE_OMP_SECTION:
|
case GIMPLE_OMP_SECTION:
|
case GIMPLE_OMP_PARALLEL:
|
case GIMPLE_OMP_PARALLEL:
|
case GIMPLE_OMP_TASK:
|
case GIMPLE_OMP_TASK:
|
case GIMPLE_OMP_SECTIONS:
|
case GIMPLE_OMP_SECTIONS:
|
case GIMPLE_OMP_SINGLE:
|
case GIMPLE_OMP_SINGLE:
|
ret = walk_gimple_seq (gimple_omp_body (stmt), callback_stmt, callback_op,
|
ret = walk_gimple_seq (gimple_omp_body (stmt), callback_stmt, callback_op,
|
wi);
|
wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
break;
|
break;
|
|
|
case GIMPLE_WITH_CLEANUP_EXPR:
|
case GIMPLE_WITH_CLEANUP_EXPR:
|
ret = walk_gimple_seq (gimple_wce_cleanup (stmt), callback_stmt,
|
ret = walk_gimple_seq (gimple_wce_cleanup (stmt), callback_stmt,
|
callback_op, wi);
|
callback_op, wi);
|
if (ret)
|
if (ret)
|
return wi->callback_result;
|
return wi->callback_result;
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_assert (!gimple_has_substatements (stmt));
|
gcc_assert (!gimple_has_substatements (stmt));
|
break;
|
break;
|
}
|
}
|
|
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
|
|
/* Set sequence SEQ to be the GIMPLE body for function FN. */
|
/* Set sequence SEQ to be the GIMPLE body for function FN. */
|
|
|
void
|
void
|
gimple_set_body (tree fndecl, gimple_seq seq)
|
gimple_set_body (tree fndecl, gimple_seq seq)
|
{
|
{
|
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
|
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
|
if (fn == NULL)
|
if (fn == NULL)
|
{
|
{
|
/* If FNDECL still does not have a function structure associated
|
/* If FNDECL still does not have a function structure associated
|
with it, then it does not make sense for it to receive a
|
with it, then it does not make sense for it to receive a
|
GIMPLE body. */
|
GIMPLE body. */
|
gcc_assert (seq == NULL);
|
gcc_assert (seq == NULL);
|
}
|
}
|
else
|
else
|
fn->gimple_body = seq;
|
fn->gimple_body = seq;
|
}
|
}
|
|
|
|
|
/* Return the body of GIMPLE statements for function FN. */
|
/* Return the body of GIMPLE statements for function FN. */
|
|
|
gimple_seq
|
gimple_seq
|
gimple_body (tree fndecl)
|
gimple_body (tree fndecl)
|
{
|
{
|
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
|
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
|
return fn ? fn->gimple_body : NULL;
|
return fn ? fn->gimple_body : NULL;
|
}
|
}
|
|
|
/* Return true when FNDECL has Gimple body either in unlowered
|
/* Return true when FNDECL has Gimple body either in unlowered
|
or CFG form. */
|
or CFG form. */
|
bool
|
bool
|
gimple_has_body_p (tree fndecl)
|
gimple_has_body_p (tree fndecl)
|
{
|
{
|
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
|
struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
|
return (gimple_body (fndecl) || (fn && fn->cfg));
|
return (gimple_body (fndecl) || (fn && fn->cfg));
|
}
|
}
|
|
|
/* Detect flags from a GIMPLE_CALL. This is just like
|
/* Detect flags from a GIMPLE_CALL. This is just like
|
call_expr_flags, but for gimple tuples. */
|
call_expr_flags, but for gimple tuples. */
|
|
|
int
|
int
|
gimple_call_flags (const_gimple stmt)
|
gimple_call_flags (const_gimple stmt)
|
{
|
{
|
int flags;
|
int flags;
|
tree decl = gimple_call_fndecl (stmt);
|
tree decl = gimple_call_fndecl (stmt);
|
tree t;
|
tree t;
|
|
|
if (decl)
|
if (decl)
|
flags = flags_from_decl_or_type (decl);
|
flags = flags_from_decl_or_type (decl);
|
else
|
else
|
{
|
{
|
t = TREE_TYPE (gimple_call_fn (stmt));
|
t = TREE_TYPE (gimple_call_fn (stmt));
|
if (t && TREE_CODE (t) == POINTER_TYPE)
|
if (t && TREE_CODE (t) == POINTER_TYPE)
|
flags = flags_from_decl_or_type (TREE_TYPE (t));
|
flags = flags_from_decl_or_type (TREE_TYPE (t));
|
else
|
else
|
flags = 0;
|
flags = 0;
|
}
|
}
|
|
|
if (stmt->gsbase.subcode & GF_CALL_NOTHROW)
|
if (stmt->gsbase.subcode & GF_CALL_NOTHROW)
|
flags |= ECF_NOTHROW;
|
flags |= ECF_NOTHROW;
|
|
|
return flags;
|
return flags;
|
}
|
}
|
|
|
|
|
/* Return true if GS is a copy assignment. */
|
/* Return true if GS is a copy assignment. */
|
|
|
bool
|
bool
|
gimple_assign_copy_p (gimple gs)
|
gimple_assign_copy_p (gimple gs)
|
{
|
{
|
return gimple_code (gs) == GIMPLE_ASSIGN
|
return gimple_code (gs) == GIMPLE_ASSIGN
|
&& get_gimple_rhs_class (gimple_assign_rhs_code (gs))
|
&& get_gimple_rhs_class (gimple_assign_rhs_code (gs))
|
== GIMPLE_SINGLE_RHS
|
== GIMPLE_SINGLE_RHS
|
&& is_gimple_val (gimple_op (gs, 1));
|
&& is_gimple_val (gimple_op (gs, 1));
|
}
|
}
|
|
|
|
|
/* Return true if GS is a SSA_NAME copy assignment. */
|
/* Return true if GS is a SSA_NAME copy assignment. */
|
|
|
bool
|
bool
|
gimple_assign_ssa_name_copy_p (gimple gs)
|
gimple_assign_ssa_name_copy_p (gimple gs)
|
{
|
{
|
return (gimple_code (gs) == GIMPLE_ASSIGN
|
return (gimple_code (gs) == GIMPLE_ASSIGN
|
&& (get_gimple_rhs_class (gimple_assign_rhs_code (gs))
|
&& (get_gimple_rhs_class (gimple_assign_rhs_code (gs))
|
== GIMPLE_SINGLE_RHS)
|
== GIMPLE_SINGLE_RHS)
|
&& TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
|
&& TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
|
&& TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
|
}
|
}
|
|
|
|
|
/* Return true if GS is an assignment with a singleton RHS, i.e.,
|
/* Return true if GS is an assignment with a singleton RHS, i.e.,
|
there is no operator associated with the assignment itself.
|
there is no operator associated with the assignment itself.
|
Unlike gimple_assign_copy_p, this predicate returns true for
|
Unlike gimple_assign_copy_p, this predicate returns true for
|
any RHS operand, including those that perform an operation
|
any RHS operand, including those that perform an operation
|
and do not have the semantics of a copy, such as COND_EXPR. */
|
and do not have the semantics of a copy, such as COND_EXPR. */
|
|
|
bool
|
bool
|
gimple_assign_single_p (gimple gs)
|
gimple_assign_single_p (gimple gs)
|
{
|
{
|
return (gimple_code (gs) == GIMPLE_ASSIGN
|
return (gimple_code (gs) == GIMPLE_ASSIGN
|
&& get_gimple_rhs_class (gimple_assign_rhs_code (gs))
|
&& get_gimple_rhs_class (gimple_assign_rhs_code (gs))
|
== GIMPLE_SINGLE_RHS);
|
== GIMPLE_SINGLE_RHS);
|
}
|
}
|
|
|
/* Return true if GS is an assignment with a unary RHS, but the
|
/* Return true if GS is an assignment with a unary RHS, but the
|
operator has no effect on the assigned value. The logic is adapted
|
operator has no effect on the assigned value. The logic is adapted
|
from STRIP_NOPS. This predicate is intended to be used in tuplifying
|
from STRIP_NOPS. This predicate is intended to be used in tuplifying
|
instances in which STRIP_NOPS was previously applied to the RHS of
|
instances in which STRIP_NOPS was previously applied to the RHS of
|
an assignment.
|
an assignment.
|
|
|
NOTE: In the use cases that led to the creation of this function
|
NOTE: In the use cases that led to the creation of this function
|
and of gimple_assign_single_p, it is typical to test for either
|
and of gimple_assign_single_p, it is typical to test for either
|
condition and to proceed in the same manner. In each case, the
|
condition and to proceed in the same manner. In each case, the
|
assigned value is represented by the single RHS operand of the
|
assigned value is represented by the single RHS operand of the
|
assignment. I suspect there may be cases where gimple_assign_copy_p,
|
assignment. I suspect there may be cases where gimple_assign_copy_p,
|
gimple_assign_single_p, or equivalent logic is used where a similar
|
gimple_assign_single_p, or equivalent logic is used where a similar
|
treatment of unary NOPs is appropriate. */
|
treatment of unary NOPs is appropriate. */
|
|
|
bool
|
bool
|
gimple_assign_unary_nop_p (gimple gs)
|
gimple_assign_unary_nop_p (gimple gs)
|
{
|
{
|
return (gimple_code (gs) == GIMPLE_ASSIGN
|
return (gimple_code (gs) == GIMPLE_ASSIGN
|
&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
|
&& (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
|
|| gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
|
|| gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
|
&& gimple_assign_rhs1 (gs) != error_mark_node
|
&& gimple_assign_rhs1 (gs) != error_mark_node
|
&& (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
|
&& (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
|
== TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
|
== TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
|
}
|
}
|
|
|
/* Set BB to be the basic block holding G. */
|
/* Set BB to be the basic block holding G. */
|
|
|
void
|
void
|
gimple_set_bb (gimple stmt, basic_block bb)
|
gimple_set_bb (gimple stmt, basic_block bb)
|
{
|
{
|
stmt->gsbase.bb = bb;
|
stmt->gsbase.bb = bb;
|
|
|
/* If the statement is a label, add the label to block-to-labels map
|
/* If the statement is a label, add the label to block-to-labels map
|
so that we can speed up edge creation for GIMPLE_GOTOs. */
|
so that we can speed up edge creation for GIMPLE_GOTOs. */
|
if (cfun->cfg && gimple_code (stmt) == GIMPLE_LABEL)
|
if (cfun->cfg && gimple_code (stmt) == GIMPLE_LABEL)
|
{
|
{
|
tree t;
|
tree t;
|
int uid;
|
int uid;
|
|
|
t = gimple_label_label (stmt);
|
t = gimple_label_label (stmt);
|
uid = LABEL_DECL_UID (t);
|
uid = LABEL_DECL_UID (t);
|
if (uid == -1)
|
if (uid == -1)
|
{
|
{
|
unsigned old_len = VEC_length (basic_block, label_to_block_map);
|
unsigned old_len = VEC_length (basic_block, label_to_block_map);
|
LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
|
LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
|
if (old_len <= (unsigned) uid)
|
if (old_len <= (unsigned) uid)
|
{
|
{
|
unsigned new_len = 3 * uid / 2 + 1;
|
unsigned new_len = 3 * uid / 2 + 1;
|
|
|
VEC_safe_grow_cleared (basic_block, gc, label_to_block_map,
|
VEC_safe_grow_cleared (basic_block, gc, label_to_block_map,
|
new_len);
|
new_len);
|
}
|
}
|
}
|
}
|
|
|
VEC_replace (basic_block, label_to_block_map, uid, bb);
|
VEC_replace (basic_block, label_to_block_map, uid, bb);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Modify the RHS of the assignment pointed-to by GSI using the
|
/* Modify the RHS of the assignment pointed-to by GSI using the
|
operands in the expression tree EXPR.
|
operands in the expression tree EXPR.
|
|
|
NOTE: The statement pointed-to by GSI may be reallocated if it
|
NOTE: The statement pointed-to by GSI may be reallocated if it
|
did not have enough operand slots.
|
did not have enough operand slots.
|
|
|
This function is useful to convert an existing tree expression into
|
This function is useful to convert an existing tree expression into
|
the flat representation used for the RHS of a GIMPLE assignment.
|
the flat representation used for the RHS of a GIMPLE assignment.
|
It will reallocate memory as needed to expand or shrink the number
|
It will reallocate memory as needed to expand or shrink the number
|
of operand slots needed to represent EXPR.
|
of operand slots needed to represent EXPR.
|
|
|
NOTE: If you find yourself building a tree and then calling this
|
NOTE: If you find yourself building a tree and then calling this
|
function, you are most certainly doing it the slow way. It is much
|
function, you are most certainly doing it the slow way. It is much
|
better to build a new assignment or to use the function
|
better to build a new assignment or to use the function
|
gimple_assign_set_rhs_with_ops, which does not require an
|
gimple_assign_set_rhs_with_ops, which does not require an
|
expression tree to be built. */
|
expression tree to be built. */
|
|
|
void
|
void
|
gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
|
gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
|
{
|
{
|
enum tree_code subcode;
|
enum tree_code subcode;
|
tree op1, op2;
|
tree op1, op2;
|
|
|
extract_ops_from_tree (expr, &subcode, &op1, &op2);
|
extract_ops_from_tree (expr, &subcode, &op1, &op2);
|
gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2);
|
gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2);
|
}
|
}
|
|
|
|
|
/* Set the RHS of assignment statement pointed-to by GSI to CODE with
|
/* Set the RHS of assignment statement pointed-to by GSI to CODE with
|
operands OP1 and OP2.
|
operands OP1 and OP2.
|
|
|
NOTE: The statement pointed-to by GSI may be reallocated if it
|
NOTE: The statement pointed-to by GSI may be reallocated if it
|
did not have enough operand slots. */
|
did not have enough operand slots. */
|
|
|
void
|
void
|
gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
|
gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
|
tree op1, tree op2)
|
tree op1, tree op2)
|
{
|
{
|
unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
|
unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
|
gimple stmt = gsi_stmt (*gsi);
|
gimple stmt = gsi_stmt (*gsi);
|
|
|
/* If the new CODE needs more operands, allocate a new statement. */
|
/* If the new CODE needs more operands, allocate a new statement. */
|
if (gimple_num_ops (stmt) < new_rhs_ops + 1)
|
if (gimple_num_ops (stmt) < new_rhs_ops + 1)
|
{
|
{
|
tree lhs = gimple_assign_lhs (stmt);
|
tree lhs = gimple_assign_lhs (stmt);
|
gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
|
gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
|
memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
|
memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
|
gsi_replace (gsi, new_stmt, true);
|
gsi_replace (gsi, new_stmt, true);
|
stmt = new_stmt;
|
stmt = new_stmt;
|
|
|
/* The LHS needs to be reset as this also changes the SSA name
|
/* The LHS needs to be reset as this also changes the SSA name
|
on the LHS. */
|
on the LHS. */
|
gimple_assign_set_lhs (stmt, lhs);
|
gimple_assign_set_lhs (stmt, lhs);
|
}
|
}
|
|
|
gimple_set_num_ops (stmt, new_rhs_ops + 1);
|
gimple_set_num_ops (stmt, new_rhs_ops + 1);
|
gimple_set_subcode (stmt, code);
|
gimple_set_subcode (stmt, code);
|
gimple_assign_set_rhs1 (stmt, op1);
|
gimple_assign_set_rhs1 (stmt, op1);
|
if (new_rhs_ops > 1)
|
if (new_rhs_ops > 1)
|
gimple_assign_set_rhs2 (stmt, op2);
|
gimple_assign_set_rhs2 (stmt, op2);
|
}
|
}
|
|
|
|
|
/* Return the LHS of a statement that performs an assignment,
|
/* Return the LHS of a statement that performs an assignment,
|
either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
|
either a GIMPLE_ASSIGN or a GIMPLE_CALL. Returns NULL_TREE
|
for a call to a function that returns no value, or for a
|
for a call to a function that returns no value, or for a
|
statement other than an assignment or a call. */
|
statement other than an assignment or a call. */
|
|
|
tree
|
tree
|
gimple_get_lhs (const_gimple stmt)
|
gimple_get_lhs (const_gimple stmt)
|
{
|
{
|
enum gimple_code code = gimple_code (stmt);
|
enum gimple_code code = gimple_code (stmt);
|
|
|
if (code == GIMPLE_ASSIGN)
|
if (code == GIMPLE_ASSIGN)
|
return gimple_assign_lhs (stmt);
|
return gimple_assign_lhs (stmt);
|
else if (code == GIMPLE_CALL)
|
else if (code == GIMPLE_CALL)
|
return gimple_call_lhs (stmt);
|
return gimple_call_lhs (stmt);
|
else
|
else
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Set the LHS of a statement that performs an assignment,
|
/* Set the LHS of a statement that performs an assignment,
|
either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
|
either a GIMPLE_ASSIGN or a GIMPLE_CALL. */
|
|
|
void
|
void
|
gimple_set_lhs (gimple stmt, tree lhs)
|
gimple_set_lhs (gimple stmt, tree lhs)
|
{
|
{
|
enum gimple_code code = gimple_code (stmt);
|
enum gimple_code code = gimple_code (stmt);
|
|
|
if (code == GIMPLE_ASSIGN)
|
if (code == GIMPLE_ASSIGN)
|
gimple_assign_set_lhs (stmt, lhs);
|
gimple_assign_set_lhs (stmt, lhs);
|
else if (code == GIMPLE_CALL)
|
else if (code == GIMPLE_CALL)
|
gimple_call_set_lhs (stmt, lhs);
|
gimple_call_set_lhs (stmt, lhs);
|
else
|
else
|
gcc_unreachable();
|
gcc_unreachable();
|
}
|
}
|
|
|
/* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
|
/* Replace the LHS of STMT, an assignment, either a GIMPLE_ASSIGN or a
|
GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
|
GIMPLE_CALL, with NLHS, in preparation for modifying the RHS to an
|
expression with a different value.
|
expression with a different value.
|
|
|
This will update any annotations (say debug bind stmts) referring
|
This will update any annotations (say debug bind stmts) referring
|
to the original LHS, so that they use the RHS instead. This is
|
to the original LHS, so that they use the RHS instead. This is
|
done even if NLHS and LHS are the same, for it is understood that
|
done even if NLHS and LHS are the same, for it is understood that
|
the RHS will be modified afterwards, and NLHS will not be assigned
|
the RHS will be modified afterwards, and NLHS will not be assigned
|
an equivalent value.
|
an equivalent value.
|
|
|
Adjusting any non-annotation uses of the LHS, if needed, is a
|
Adjusting any non-annotation uses of the LHS, if needed, is a
|
responsibility of the caller.
|
responsibility of the caller.
|
|
|
The effect of this call should be pretty much the same as that of
|
The effect of this call should be pretty much the same as that of
|
inserting a copy of STMT before STMT, and then removing the
|
inserting a copy of STMT before STMT, and then removing the
|
original stmt, at which time gsi_remove() would have update
|
original stmt, at which time gsi_remove() would have update
|
annotations, but using this function saves all the inserting,
|
annotations, but using this function saves all the inserting,
|
copying and removing. */
|
copying and removing. */
|
|
|
void
|
void
|
gimple_replace_lhs (gimple stmt, tree nlhs)
|
gimple_replace_lhs (gimple stmt, tree nlhs)
|
{
|
{
|
if (MAY_HAVE_DEBUG_STMTS)
|
if (MAY_HAVE_DEBUG_STMTS)
|
{
|
{
|
tree lhs = gimple_get_lhs (stmt);
|
tree lhs = gimple_get_lhs (stmt);
|
|
|
gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
|
gcc_assert (SSA_NAME_DEF_STMT (lhs) == stmt);
|
|
|
insert_debug_temp_for_var_def (NULL, lhs);
|
insert_debug_temp_for_var_def (NULL, lhs);
|
}
|
}
|
|
|
gimple_set_lhs (stmt, nlhs);
|
gimple_set_lhs (stmt, nlhs);
|
}
|
}
|
|
|
/* Return a deep copy of statement STMT. All the operands from STMT
|
/* Return a deep copy of statement STMT. All the operands from STMT
|
are reallocated and copied using unshare_expr. The DEF, USE, VDEF
|
are reallocated and copied using unshare_expr. The DEF, USE, VDEF
|
and VUSE operand arrays are set to empty in the new copy. */
|
and VUSE operand arrays are set to empty in the new copy. */
|
|
|
gimple
|
gimple
|
gimple_copy (gimple stmt)
|
gimple_copy (gimple stmt)
|
{
|
{
|
enum gimple_code code = gimple_code (stmt);
|
enum gimple_code code = gimple_code (stmt);
|
unsigned num_ops = gimple_num_ops (stmt);
|
unsigned num_ops = gimple_num_ops (stmt);
|
gimple copy = gimple_alloc (code, num_ops);
|
gimple copy = gimple_alloc (code, num_ops);
|
unsigned i;
|
unsigned i;
|
|
|
/* Shallow copy all the fields from STMT. */
|
/* Shallow copy all the fields from STMT. */
|
memcpy (copy, stmt, gimple_size (code));
|
memcpy (copy, stmt, gimple_size (code));
|
|
|
/* If STMT has sub-statements, deep-copy them as well. */
|
/* If STMT has sub-statements, deep-copy them as well. */
|
if (gimple_has_substatements (stmt))
|
if (gimple_has_substatements (stmt))
|
{
|
{
|
gimple_seq new_seq;
|
gimple_seq new_seq;
|
tree t;
|
tree t;
|
|
|
switch (gimple_code (stmt))
|
switch (gimple_code (stmt))
|
{
|
{
|
case GIMPLE_BIND:
|
case GIMPLE_BIND:
|
new_seq = gimple_seq_copy (gimple_bind_body (stmt));
|
new_seq = gimple_seq_copy (gimple_bind_body (stmt));
|
gimple_bind_set_body (copy, new_seq);
|
gimple_bind_set_body (copy, new_seq);
|
gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
|
gimple_bind_set_vars (copy, unshare_expr (gimple_bind_vars (stmt)));
|
gimple_bind_set_block (copy, gimple_bind_block (stmt));
|
gimple_bind_set_block (copy, gimple_bind_block (stmt));
|
break;
|
break;
|
|
|
case GIMPLE_CATCH:
|
case GIMPLE_CATCH:
|
new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
|
new_seq = gimple_seq_copy (gimple_catch_handler (stmt));
|
gimple_catch_set_handler (copy, new_seq);
|
gimple_catch_set_handler (copy, new_seq);
|
t = unshare_expr (gimple_catch_types (stmt));
|
t = unshare_expr (gimple_catch_types (stmt));
|
gimple_catch_set_types (copy, t);
|
gimple_catch_set_types (copy, t);
|
break;
|
break;
|
|
|
case GIMPLE_EH_FILTER:
|
case GIMPLE_EH_FILTER:
|
new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
|
new_seq = gimple_seq_copy (gimple_eh_filter_failure (stmt));
|
gimple_eh_filter_set_failure (copy, new_seq);
|
gimple_eh_filter_set_failure (copy, new_seq);
|
t = unshare_expr (gimple_eh_filter_types (stmt));
|
t = unshare_expr (gimple_eh_filter_types (stmt));
|
gimple_eh_filter_set_types (copy, t);
|
gimple_eh_filter_set_types (copy, t);
|
break;
|
break;
|
|
|
case GIMPLE_TRY:
|
case GIMPLE_TRY:
|
new_seq = gimple_seq_copy (gimple_try_eval (stmt));
|
new_seq = gimple_seq_copy (gimple_try_eval (stmt));
|
gimple_try_set_eval (copy, new_seq);
|
gimple_try_set_eval (copy, new_seq);
|
new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
|
new_seq = gimple_seq_copy (gimple_try_cleanup (stmt));
|
gimple_try_set_cleanup (copy, new_seq);
|
gimple_try_set_cleanup (copy, new_seq);
|
break;
|
break;
|
|
|
case GIMPLE_OMP_FOR:
|
case GIMPLE_OMP_FOR:
|
new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
|
new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
|
gimple_omp_for_set_pre_body (copy, new_seq);
|
gimple_omp_for_set_pre_body (copy, new_seq);
|
t = unshare_expr (gimple_omp_for_clauses (stmt));
|
t = unshare_expr (gimple_omp_for_clauses (stmt));
|
gimple_omp_for_set_clauses (copy, t);
|
gimple_omp_for_set_clauses (copy, t);
|
copy->gimple_omp_for.iter
|
copy->gimple_omp_for.iter
|
= GGC_NEWVEC (struct gimple_omp_for_iter,
|
= GGC_NEWVEC (struct gimple_omp_for_iter,
|
gimple_omp_for_collapse (stmt));
|
gimple_omp_for_collapse (stmt));
|
for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
|
for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
|
{
|
{
|
gimple_omp_for_set_cond (copy, i,
|
gimple_omp_for_set_cond (copy, i,
|
gimple_omp_for_cond (stmt, i));
|
gimple_omp_for_cond (stmt, i));
|
gimple_omp_for_set_index (copy, i,
|
gimple_omp_for_set_index (copy, i,
|
gimple_omp_for_index (stmt, i));
|
gimple_omp_for_index (stmt, i));
|
t = unshare_expr (gimple_omp_for_initial (stmt, i));
|
t = unshare_expr (gimple_omp_for_initial (stmt, i));
|
gimple_omp_for_set_initial (copy, i, t);
|
gimple_omp_for_set_initial (copy, i, t);
|
t = unshare_expr (gimple_omp_for_final (stmt, i));
|
t = unshare_expr (gimple_omp_for_final (stmt, i));
|
gimple_omp_for_set_final (copy, i, t);
|
gimple_omp_for_set_final (copy, i, t);
|
t = unshare_expr (gimple_omp_for_incr (stmt, i));
|
t = unshare_expr (gimple_omp_for_incr (stmt, i));
|
gimple_omp_for_set_incr (copy, i, t);
|
gimple_omp_for_set_incr (copy, i, t);
|
}
|
}
|
goto copy_omp_body;
|
goto copy_omp_body;
|
|
|
case GIMPLE_OMP_PARALLEL:
|
case GIMPLE_OMP_PARALLEL:
|
t = unshare_expr (gimple_omp_parallel_clauses (stmt));
|
t = unshare_expr (gimple_omp_parallel_clauses (stmt));
|
gimple_omp_parallel_set_clauses (copy, t);
|
gimple_omp_parallel_set_clauses (copy, t);
|
t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
|
t = unshare_expr (gimple_omp_parallel_child_fn (stmt));
|
gimple_omp_parallel_set_child_fn (copy, t);
|
gimple_omp_parallel_set_child_fn (copy, t);
|
t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
|
t = unshare_expr (gimple_omp_parallel_data_arg (stmt));
|
gimple_omp_parallel_set_data_arg (copy, t);
|
gimple_omp_parallel_set_data_arg (copy, t);
|
goto copy_omp_body;
|
goto copy_omp_body;
|
|
|
case GIMPLE_OMP_TASK:
|
case GIMPLE_OMP_TASK:
|
t = unshare_expr (gimple_omp_task_clauses (stmt));
|
t = unshare_expr (gimple_omp_task_clauses (stmt));
|
gimple_omp_task_set_clauses (copy, t);
|
gimple_omp_task_set_clauses (copy, t);
|
t = unshare_expr (gimple_omp_task_child_fn (stmt));
|
t = unshare_expr (gimple_omp_task_child_fn (stmt));
|
gimple_omp_task_set_child_fn (copy, t);
|
gimple_omp_task_set_child_fn (copy, t);
|
t = unshare_expr (gimple_omp_task_data_arg (stmt));
|
t = unshare_expr (gimple_omp_task_data_arg (stmt));
|
gimple_omp_task_set_data_arg (copy, t);
|
gimple_omp_task_set_data_arg (copy, t);
|
t = unshare_expr (gimple_omp_task_copy_fn (stmt));
|
t = unshare_expr (gimple_omp_task_copy_fn (stmt));
|
gimple_omp_task_set_copy_fn (copy, t);
|
gimple_omp_task_set_copy_fn (copy, t);
|
t = unshare_expr (gimple_omp_task_arg_size (stmt));
|
t = unshare_expr (gimple_omp_task_arg_size (stmt));
|
gimple_omp_task_set_arg_size (copy, t);
|
gimple_omp_task_set_arg_size (copy, t);
|
t = unshare_expr (gimple_omp_task_arg_align (stmt));
|
t = unshare_expr (gimple_omp_task_arg_align (stmt));
|
gimple_omp_task_set_arg_align (copy, t);
|
gimple_omp_task_set_arg_align (copy, t);
|
goto copy_omp_body;
|
goto copy_omp_body;
|
|
|
case GIMPLE_OMP_CRITICAL:
|
case GIMPLE_OMP_CRITICAL:
|
t = unshare_expr (gimple_omp_critical_name (stmt));
|
t = unshare_expr (gimple_omp_critical_name (stmt));
|
gimple_omp_critical_set_name (copy, t);
|
gimple_omp_critical_set_name (copy, t);
|
goto copy_omp_body;
|
goto copy_omp_body;
|
|
|
case GIMPLE_OMP_SECTIONS:
|
case GIMPLE_OMP_SECTIONS:
|
t = unshare_expr (gimple_omp_sections_clauses (stmt));
|
t = unshare_expr (gimple_omp_sections_clauses (stmt));
|
gimple_omp_sections_set_clauses (copy, t);
|
gimple_omp_sections_set_clauses (copy, t);
|
t = unshare_expr (gimple_omp_sections_control (stmt));
|
t = unshare_expr (gimple_omp_sections_control (stmt));
|
gimple_omp_sections_set_control (copy, t);
|
gimple_omp_sections_set_control (copy, t);
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
case GIMPLE_OMP_SINGLE:
|
case GIMPLE_OMP_SINGLE:
|
case GIMPLE_OMP_SECTION:
|
case GIMPLE_OMP_SECTION:
|
case GIMPLE_OMP_MASTER:
|
case GIMPLE_OMP_MASTER:
|
case GIMPLE_OMP_ORDERED:
|
case GIMPLE_OMP_ORDERED:
|
copy_omp_body:
|
copy_omp_body:
|
new_seq = gimple_seq_copy (gimple_omp_body (stmt));
|
new_seq = gimple_seq_copy (gimple_omp_body (stmt));
|
gimple_omp_set_body (copy, new_seq);
|
gimple_omp_set_body (copy, new_seq);
|
break;
|
break;
|
|
|
case GIMPLE_WITH_CLEANUP_EXPR:
|
case GIMPLE_WITH_CLEANUP_EXPR:
|
new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
|
new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
|
gimple_wce_set_cleanup (copy, new_seq);
|
gimple_wce_set_cleanup (copy, new_seq);
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Make copy of operands. */
|
/* Make copy of operands. */
|
if (num_ops > 0)
|
if (num_ops > 0)
|
{
|
{
|
for (i = 0; i < num_ops; i++)
|
for (i = 0; i < num_ops; i++)
|
gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
|
gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
|
|
|
/* Clear out SSA operand vectors on COPY. */
|
/* Clear out SSA operand vectors on COPY. */
|
if (gimple_has_ops (stmt))
|
if (gimple_has_ops (stmt))
|
{
|
{
|
gimple_set_def_ops (copy, NULL);
|
gimple_set_def_ops (copy, NULL);
|
gimple_set_use_ops (copy, NULL);
|
gimple_set_use_ops (copy, NULL);
|
}
|
}
|
|
|
if (gimple_has_mem_ops (stmt))
|
if (gimple_has_mem_ops (stmt))
|
{
|
{
|
gimple_set_vdef (copy, gimple_vdef (stmt));
|
gimple_set_vdef (copy, gimple_vdef (stmt));
|
gimple_set_vuse (copy, gimple_vuse (stmt));
|
gimple_set_vuse (copy, gimple_vuse (stmt));
|
}
|
}
|
|
|
/* SSA operands need to be updated. */
|
/* SSA operands need to be updated. */
|
gimple_set_modified (copy, true);
|
gimple_set_modified (copy, true);
|
}
|
}
|
|
|
return copy;
|
return copy;
|
}
|
}
|
|
|
|
|
/* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
|
/* Set the MODIFIED flag to MODIFIEDP, iff the gimple statement G has
|
a MODIFIED field. */
|
a MODIFIED field. */
|
|
|
void
|
void
|
gimple_set_modified (gimple s, bool modifiedp)
|
gimple_set_modified (gimple s, bool modifiedp)
|
{
|
{
|
if (gimple_has_ops (s))
|
if (gimple_has_ops (s))
|
{
|
{
|
s->gsbase.modified = (unsigned) modifiedp;
|
s->gsbase.modified = (unsigned) modifiedp;
|
|
|
if (modifiedp
|
if (modifiedp
|
&& cfun->gimple_df
|
&& cfun->gimple_df
|
&& is_gimple_call (s)
|
&& is_gimple_call (s)
|
&& gimple_call_noreturn_p (s))
|
&& gimple_call_noreturn_p (s))
|
VEC_safe_push (gimple, gc, MODIFIED_NORETURN_CALLS (cfun), s);
|
VEC_safe_push (gimple, gc, MODIFIED_NORETURN_CALLS (cfun), s);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return true if statement S has side-effects. We consider a
|
/* Return true if statement S has side-effects. We consider a
|
statement to have side effects if:
|
statement to have side effects if:
|
|
|
- It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
|
- It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
|
- Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
|
- Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS. */
|
|
|
bool
|
bool
|
gimple_has_side_effects (const_gimple s)
|
gimple_has_side_effects (const_gimple s)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
if (is_gimple_debug (s))
|
if (is_gimple_debug (s))
|
return false;
|
return false;
|
|
|
/* We don't have to scan the arguments to check for
|
/* We don't have to scan the arguments to check for
|
volatile arguments, though, at present, we still
|
volatile arguments, though, at present, we still
|
do a scan to check for TREE_SIDE_EFFECTS. */
|
do a scan to check for TREE_SIDE_EFFECTS. */
|
if (gimple_has_volatile_ops (s))
|
if (gimple_has_volatile_ops (s))
|
return true;
|
return true;
|
|
|
if (is_gimple_call (s))
|
if (is_gimple_call (s))
|
{
|
{
|
unsigned nargs = gimple_call_num_args (s);
|
unsigned nargs = gimple_call_num_args (s);
|
|
|
if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
|
if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
|
return true;
|
return true;
|
else if (gimple_call_flags (s) & ECF_LOOPING_CONST_OR_PURE)
|
else if (gimple_call_flags (s) & ECF_LOOPING_CONST_OR_PURE)
|
/* An infinite loop is considered a side effect. */
|
/* An infinite loop is considered a side effect. */
|
return true;
|
return true;
|
|
|
if (gimple_call_lhs (s)
|
if (gimple_call_lhs (s)
|
&& TREE_SIDE_EFFECTS (gimple_call_lhs (s)))
|
&& TREE_SIDE_EFFECTS (gimple_call_lhs (s)))
|
{
|
{
|
gcc_assert (gimple_has_volatile_ops (s));
|
gcc_assert (gimple_has_volatile_ops (s));
|
return true;
|
return true;
|
}
|
}
|
|
|
if (TREE_SIDE_EFFECTS (gimple_call_fn (s)))
|
if (TREE_SIDE_EFFECTS (gimple_call_fn (s)))
|
return true;
|
return true;
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i)))
|
if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i)))
|
{
|
{
|
gcc_assert (gimple_has_volatile_ops (s));
|
gcc_assert (gimple_has_volatile_ops (s));
|
return true;
|
return true;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
else
|
else
|
{
|
{
|
for (i = 0; i < gimple_num_ops (s); i++)
|
for (i = 0; i < gimple_num_ops (s); i++)
|
if (TREE_SIDE_EFFECTS (gimple_op (s, i)))
|
if (TREE_SIDE_EFFECTS (gimple_op (s, i)))
|
{
|
{
|
gcc_assert (gimple_has_volatile_ops (s));
|
gcc_assert (gimple_has_volatile_ops (s));
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if the RHS of statement S has side effects.
|
/* Return true if the RHS of statement S has side effects.
|
We may use it to determine if it is admissable to replace
|
We may use it to determine if it is admissable to replace
|
an assignment or call with a copy of a previously-computed
|
an assignment or call with a copy of a previously-computed
|
value. In such cases, side-effects due the the LHS are
|
value. In such cases, side-effects due the the LHS are
|
preserved. */
|
preserved. */
|
|
|
bool
|
bool
|
gimple_rhs_has_side_effects (const_gimple s)
|
gimple_rhs_has_side_effects (const_gimple s)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
if (is_gimple_call (s))
|
if (is_gimple_call (s))
|
{
|
{
|
unsigned nargs = gimple_call_num_args (s);
|
unsigned nargs = gimple_call_num_args (s);
|
|
|
if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
|
if (!(gimple_call_flags (s) & (ECF_CONST | ECF_PURE)))
|
return true;
|
return true;
|
|
|
/* We cannot use gimple_has_volatile_ops here,
|
/* We cannot use gimple_has_volatile_ops here,
|
because we must ignore a volatile LHS. */
|
because we must ignore a volatile LHS. */
|
if (TREE_SIDE_EFFECTS (gimple_call_fn (s))
|
if (TREE_SIDE_EFFECTS (gimple_call_fn (s))
|
|| TREE_THIS_VOLATILE (gimple_call_fn (s)))
|
|| TREE_THIS_VOLATILE (gimple_call_fn (s)))
|
{
|
{
|
gcc_assert (gimple_has_volatile_ops (s));
|
gcc_assert (gimple_has_volatile_ops (s));
|
return true;
|
return true;
|
}
|
}
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i))
|
if (TREE_SIDE_EFFECTS (gimple_call_arg (s, i))
|
|| TREE_THIS_VOLATILE (gimple_call_arg (s, i)))
|
|| TREE_THIS_VOLATILE (gimple_call_arg (s, i)))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
else if (is_gimple_assign (s))
|
else if (is_gimple_assign (s))
|
{
|
{
|
/* Skip the first operand, the LHS. */
|
/* Skip the first operand, the LHS. */
|
for (i = 1; i < gimple_num_ops (s); i++)
|
for (i = 1; i < gimple_num_ops (s); i++)
|
if (TREE_SIDE_EFFECTS (gimple_op (s, i))
|
if (TREE_SIDE_EFFECTS (gimple_op (s, i))
|
|| TREE_THIS_VOLATILE (gimple_op (s, i)))
|
|| TREE_THIS_VOLATILE (gimple_op (s, i)))
|
{
|
{
|
gcc_assert (gimple_has_volatile_ops (s));
|
gcc_assert (gimple_has_volatile_ops (s));
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
else if (is_gimple_debug (s))
|
else if (is_gimple_debug (s))
|
return false;
|
return false;
|
else
|
else
|
{
|
{
|
/* For statements without an LHS, examine all arguments. */
|
/* For statements without an LHS, examine all arguments. */
|
for (i = 0; i < gimple_num_ops (s); i++)
|
for (i = 0; i < gimple_num_ops (s); i++)
|
if (TREE_SIDE_EFFECTS (gimple_op (s, i))
|
if (TREE_SIDE_EFFECTS (gimple_op (s, i))
|
|| TREE_THIS_VOLATILE (gimple_op (s, i)))
|
|| TREE_THIS_VOLATILE (gimple_op (s, i)))
|
{
|
{
|
gcc_assert (gimple_has_volatile_ops (s));
|
gcc_assert (gimple_has_volatile_ops (s));
|
return true;
|
return true;
|
}
|
}
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
|
|
/* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
|
/* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
|
Return true if S can trap. If INCLUDE_LHS is true and S is a
|
Return true if S can trap. If INCLUDE_LHS is true and S is a
|
GIMPLE_ASSIGN, the LHS of the assignment is also checked.
|
GIMPLE_ASSIGN, the LHS of the assignment is also checked.
|
Otherwise, only the RHS of the assignment is checked. */
|
Otherwise, only the RHS of the assignment is checked. */
|
|
|
static bool
|
static bool
|
gimple_could_trap_p_1 (gimple s, bool include_lhs)
|
gimple_could_trap_p_1 (gimple s, bool include_lhs)
|
{
|
{
|
unsigned i, start;
|
unsigned i, start;
|
tree t, div = NULL_TREE;
|
tree t, div = NULL_TREE;
|
enum tree_code op;
|
enum tree_code op;
|
|
|
start = (is_gimple_assign (s) && !include_lhs) ? 1 : 0;
|
start = (is_gimple_assign (s) && !include_lhs) ? 1 : 0;
|
|
|
for (i = start; i < gimple_num_ops (s); i++)
|
for (i = start; i < gimple_num_ops (s); i++)
|
if (tree_could_trap_p (gimple_op (s, i)))
|
if (tree_could_trap_p (gimple_op (s, i)))
|
return true;
|
return true;
|
|
|
switch (gimple_code (s))
|
switch (gimple_code (s))
|
{
|
{
|
case GIMPLE_ASM:
|
case GIMPLE_ASM:
|
return gimple_asm_volatile_p (s);
|
return gimple_asm_volatile_p (s);
|
|
|
case GIMPLE_CALL:
|
case GIMPLE_CALL:
|
t = gimple_call_fndecl (s);
|
t = gimple_call_fndecl (s);
|
/* Assume that calls to weak functions may trap. */
|
/* Assume that calls to weak functions may trap. */
|
if (!t || !DECL_P (t) || DECL_WEAK (t))
|
if (!t || !DECL_P (t) || DECL_WEAK (t))
|
return true;
|
return true;
|
return false;
|
return false;
|
|
|
case GIMPLE_ASSIGN:
|
case GIMPLE_ASSIGN:
|
t = gimple_expr_type (s);
|
t = gimple_expr_type (s);
|
op = gimple_assign_rhs_code (s);
|
op = gimple_assign_rhs_code (s);
|
if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
|
if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
|
div = gimple_assign_rhs2 (s);
|
div = gimple_assign_rhs2 (s);
|
return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
|
return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
|
(INTEGRAL_TYPE_P (t)
|
(INTEGRAL_TYPE_P (t)
|
&& TYPE_OVERFLOW_TRAPS (t)),
|
&& TYPE_OVERFLOW_TRAPS (t)),
|
div));
|
div));
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return false;
|
return false;
|
|
|
}
|
}
|
|
|
|
|
/* Return true if statement S can trap. */
|
/* Return true if statement S can trap. */
|
|
|
bool
|
bool
|
gimple_could_trap_p (gimple s)
|
gimple_could_trap_p (gimple s)
|
{
|
{
|
return gimple_could_trap_p_1 (s, true);
|
return gimple_could_trap_p_1 (s, true);
|
}
|
}
|
|
|
|
|
/* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
|
/* Return true if RHS of a GIMPLE_ASSIGN S can trap. */
|
|
|
bool
|
bool
|
gimple_assign_rhs_could_trap_p (gimple s)
|
gimple_assign_rhs_could_trap_p (gimple s)
|
{
|
{
|
gcc_assert (is_gimple_assign (s));
|
gcc_assert (is_gimple_assign (s));
|
return gimple_could_trap_p_1 (s, false);
|
return gimple_could_trap_p_1 (s, false);
|
}
|
}
|
|
|
|
|
/* Print debugging information for gimple stmts generated. */
|
/* Print debugging information for gimple stmts generated. */
|
|
|
void
|
void
|
dump_gimple_statistics (void)
|
dump_gimple_statistics (void)
|
{
|
{
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
int i, total_tuples = 0, total_bytes = 0;
|
int i, total_tuples = 0, total_bytes = 0;
|
|
|
fprintf (stderr, "\nGIMPLE statements\n");
|
fprintf (stderr, "\nGIMPLE statements\n");
|
fprintf (stderr, "Kind Stmts Bytes\n");
|
fprintf (stderr, "Kind Stmts Bytes\n");
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "---------------------------------------\n");
|
for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
|
for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
|
{
|
{
|
fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
|
fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
|
gimple_alloc_counts[i], gimple_alloc_sizes[i]);
|
gimple_alloc_counts[i], gimple_alloc_sizes[i]);
|
total_tuples += gimple_alloc_counts[i];
|
total_tuples += gimple_alloc_counts[i];
|
total_bytes += gimple_alloc_sizes[i];
|
total_bytes += gimple_alloc_sizes[i];
|
}
|
}
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
|
fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "---------------------------------------\n");
|
#else
|
#else
|
fprintf (stderr, "No gimple statistics\n");
|
fprintf (stderr, "No gimple statistics\n");
|
#endif
|
#endif
|
}
|
}
|
|
|
|
|
/* Return the number of operands needed on the RHS of a GIMPLE
|
/* Return the number of operands needed on the RHS of a GIMPLE
|
assignment for an expression with tree code CODE. */
|
assignment for an expression with tree code CODE. */
|
|
|
unsigned
|
unsigned
|
get_gimple_rhs_num_ops (enum tree_code code)
|
get_gimple_rhs_num_ops (enum tree_code code)
|
{
|
{
|
enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
|
enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
|
|
|
if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
|
if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
|
return 1;
|
return 1;
|
else if (rhs_class == GIMPLE_BINARY_RHS)
|
else if (rhs_class == GIMPLE_BINARY_RHS)
|
return 2;
|
return 2;
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
#define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
|
#define DEFTREECODE(SYM, STRING, TYPE, NARGS) \
|
(unsigned char) \
|
(unsigned char) \
|
((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
|
((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS \
|
: ((TYPE) == tcc_binary \
|
: ((TYPE) == tcc_binary \
|
|| (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
|
|| (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS \
|
: ((TYPE) == tcc_constant \
|
: ((TYPE) == tcc_constant \
|
|| (TYPE) == tcc_declaration \
|
|| (TYPE) == tcc_declaration \
|
|| (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
|
|| (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS \
|
: ((SYM) == TRUTH_AND_EXPR \
|
: ((SYM) == TRUTH_AND_EXPR \
|
|| (SYM) == TRUTH_OR_EXPR \
|
|| (SYM) == TRUTH_OR_EXPR \
|
|| (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
|
|| (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS \
|
: (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
|
: (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS \
|
: ((SYM) == COND_EXPR \
|
: ((SYM) == COND_EXPR \
|
|| (SYM) == CONSTRUCTOR \
|
|| (SYM) == CONSTRUCTOR \
|
|| (SYM) == OBJ_TYPE_REF \
|
|| (SYM) == OBJ_TYPE_REF \
|
|| (SYM) == ASSERT_EXPR \
|
|| (SYM) == ASSERT_EXPR \
|
|| (SYM) == ADDR_EXPR \
|
|| (SYM) == ADDR_EXPR \
|
|| (SYM) == WITH_SIZE_EXPR \
|
|| (SYM) == WITH_SIZE_EXPR \
|
|| (SYM) == SSA_NAME \
|
|| (SYM) == SSA_NAME \
|
|| (SYM) == POLYNOMIAL_CHREC \
|
|| (SYM) == POLYNOMIAL_CHREC \
|
|| (SYM) == DOT_PROD_EXPR \
|
|| (SYM) == DOT_PROD_EXPR \
|
|| (SYM) == VEC_COND_EXPR \
|
|| (SYM) == VEC_COND_EXPR \
|
|| (SYM) == REALIGN_LOAD_EXPR) ? GIMPLE_SINGLE_RHS \
|
|| (SYM) == REALIGN_LOAD_EXPR) ? GIMPLE_SINGLE_RHS \
|
: GIMPLE_INVALID_RHS),
|
: GIMPLE_INVALID_RHS),
|
#define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
|
#define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
|
|
|
const unsigned char gimple_rhs_class_table[] = {
|
const unsigned char gimple_rhs_class_table[] = {
|
#include "all-tree.def"
|
#include "all-tree.def"
|
};
|
};
|
|
|
#undef DEFTREECODE
|
#undef DEFTREECODE
|
#undef END_OF_BASE_TREE_CODES
|
#undef END_OF_BASE_TREE_CODES
|
|
|
/* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
|
/* For the definitive definition of GIMPLE, see doc/tree-ssa.texi. */
|
|
|
/* Validation of GIMPLE expressions. */
|
/* Validation of GIMPLE expressions. */
|
|
|
/* Return true if OP is an acceptable tree node to be used as a GIMPLE
|
/* Return true if OP is an acceptable tree node to be used as a GIMPLE
|
operand. */
|
operand. */
|
|
|
bool
|
bool
|
is_gimple_operand (const_tree op)
|
is_gimple_operand (const_tree op)
|
{
|
{
|
return op && get_gimple_rhs_class (TREE_CODE (op)) == GIMPLE_SINGLE_RHS;
|
return op && get_gimple_rhs_class (TREE_CODE (op)) == GIMPLE_SINGLE_RHS;
|
}
|
}
|
|
|
/* Returns true iff T is a valid RHS for an assignment to a renamed
|
/* Returns true iff T is a valid RHS for an assignment to a renamed
|
user -- or front-end generated artificial -- variable. */
|
user -- or front-end generated artificial -- variable. */
|
|
|
bool
|
bool
|
is_gimple_reg_rhs (tree t)
|
is_gimple_reg_rhs (tree t)
|
{
|
{
|
return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
|
return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
|
}
|
}
|
|
|
/* Returns true iff T is a valid RHS for an assignment to an un-renamed
|
/* Returns true iff T is a valid RHS for an assignment to an un-renamed
|
LHS, or for a call argument. */
|
LHS, or for a call argument. */
|
|
|
bool
|
bool
|
is_gimple_mem_rhs (tree t)
|
is_gimple_mem_rhs (tree t)
|
{
|
{
|
/* If we're dealing with a renamable type, either source or dest must be
|
/* If we're dealing with a renamable type, either source or dest must be
|
a renamed variable. */
|
a renamed variable. */
|
if (is_gimple_reg_type (TREE_TYPE (t)))
|
if (is_gimple_reg_type (TREE_TYPE (t)))
|
return is_gimple_val (t);
|
return is_gimple_val (t);
|
else
|
else
|
return is_gimple_val (t) || is_gimple_lvalue (t);
|
return is_gimple_val (t) || is_gimple_lvalue (t);
|
}
|
}
|
|
|
/* Return true if T is a valid LHS for a GIMPLE assignment expression. */
|
/* Return true if T is a valid LHS for a GIMPLE assignment expression. */
|
|
|
bool
|
bool
|
is_gimple_lvalue (tree t)
|
is_gimple_lvalue (tree t)
|
{
|
{
|
return (is_gimple_addressable (t)
|
return (is_gimple_addressable (t)
|
|| TREE_CODE (t) == WITH_SIZE_EXPR
|
|| TREE_CODE (t) == WITH_SIZE_EXPR
|
/* These are complex lvalues, but don't have addresses, so they
|
/* These are complex lvalues, but don't have addresses, so they
|
go here. */
|
go here. */
|
|| TREE_CODE (t) == BIT_FIELD_REF);
|
|| TREE_CODE (t) == BIT_FIELD_REF);
|
}
|
}
|
|
|
/* Return true if T is a GIMPLE condition. */
|
/* Return true if T is a GIMPLE condition. */
|
|
|
bool
|
bool
|
is_gimple_condexpr (tree t)
|
is_gimple_condexpr (tree t)
|
{
|
{
|
return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
|
return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
|
&& !tree_could_trap_p (t)
|
&& !tree_could_trap_p (t)
|
&& is_gimple_val (TREE_OPERAND (t, 0))
|
&& is_gimple_val (TREE_OPERAND (t, 0))
|
&& is_gimple_val (TREE_OPERAND (t, 1))));
|
&& is_gimple_val (TREE_OPERAND (t, 1))));
|
}
|
}
|
|
|
/* Return true if T is something whose address can be taken. */
|
/* Return true if T is something whose address can be taken. */
|
|
|
bool
|
bool
|
is_gimple_addressable (tree t)
|
is_gimple_addressable (tree t)
|
{
|
{
|
return (is_gimple_id (t) || handled_component_p (t) || INDIRECT_REF_P (t));
|
return (is_gimple_id (t) || handled_component_p (t) || INDIRECT_REF_P (t));
|
}
|
}
|
|
|
/* Return true if T is a valid gimple constant. */
|
/* Return true if T is a valid gimple constant. */
|
|
|
bool
|
bool
|
is_gimple_constant (const_tree t)
|
is_gimple_constant (const_tree t)
|
{
|
{
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case INTEGER_CST:
|
case INTEGER_CST:
|
case REAL_CST:
|
case REAL_CST:
|
case FIXED_CST:
|
case FIXED_CST:
|
case STRING_CST:
|
case STRING_CST:
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
case VECTOR_CST:
|
case VECTOR_CST:
|
return true;
|
return true;
|
|
|
/* Vector constant constructors are gimple invariant. */
|
/* Vector constant constructors are gimple invariant. */
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
|
if (TREE_TYPE (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
|
return TREE_CONSTANT (t);
|
return TREE_CONSTANT (t);
|
else
|
else
|
return false;
|
return false;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Return true if T is a gimple address. */
|
/* Return true if T is a gimple address. */
|
|
|
bool
|
bool
|
is_gimple_address (const_tree t)
|
is_gimple_address (const_tree t)
|
{
|
{
|
tree op;
|
tree op;
|
|
|
if (TREE_CODE (t) != ADDR_EXPR)
|
if (TREE_CODE (t) != ADDR_EXPR)
|
return false;
|
return false;
|
|
|
op = TREE_OPERAND (t, 0);
|
op = TREE_OPERAND (t, 0);
|
while (handled_component_p (op))
|
while (handled_component_p (op))
|
{
|
{
|
if ((TREE_CODE (op) == ARRAY_REF
|
if ((TREE_CODE (op) == ARRAY_REF
|
|| TREE_CODE (op) == ARRAY_RANGE_REF)
|
|| TREE_CODE (op) == ARRAY_RANGE_REF)
|
&& !is_gimple_val (TREE_OPERAND (op, 1)))
|
&& !is_gimple_val (TREE_OPERAND (op, 1)))
|
return false;
|
return false;
|
|
|
op = TREE_OPERAND (op, 0);
|
op = TREE_OPERAND (op, 0);
|
}
|
}
|
|
|
if (CONSTANT_CLASS_P (op) || INDIRECT_REF_P (op))
|
if (CONSTANT_CLASS_P (op) || INDIRECT_REF_P (op))
|
return true;
|
return true;
|
|
|
switch (TREE_CODE (op))
|
switch (TREE_CODE (op))
|
{
|
{
|
case PARM_DECL:
|
case PARM_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
case LABEL_DECL:
|
case LABEL_DECL:
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
case VAR_DECL:
|
case VAR_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
return true;
|
return true;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Strip out all handled components that produce invariant
|
/* Strip out all handled components that produce invariant
|
offsets. */
|
offsets. */
|
|
|
static const_tree
|
static const_tree
|
strip_invariant_refs (const_tree op)
|
strip_invariant_refs (const_tree op)
|
{
|
{
|
while (handled_component_p (op))
|
while (handled_component_p (op))
|
{
|
{
|
switch (TREE_CODE (op))
|
switch (TREE_CODE (op))
|
{
|
{
|
case ARRAY_REF:
|
case ARRAY_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
if (!is_gimple_constant (TREE_OPERAND (op, 1))
|
if (!is_gimple_constant (TREE_OPERAND (op, 1))
|
|| TREE_OPERAND (op, 2) != NULL_TREE
|
|| TREE_OPERAND (op, 2) != NULL_TREE
|
|| TREE_OPERAND (op, 3) != NULL_TREE)
|
|| TREE_OPERAND (op, 3) != NULL_TREE)
|
return NULL;
|
return NULL;
|
break;
|
break;
|
|
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
if (TREE_OPERAND (op, 2) != NULL_TREE)
|
if (TREE_OPERAND (op, 2) != NULL_TREE)
|
return NULL;
|
return NULL;
|
break;
|
break;
|
|
|
default:;
|
default:;
|
}
|
}
|
op = TREE_OPERAND (op, 0);
|
op = TREE_OPERAND (op, 0);
|
}
|
}
|
|
|
return op;
|
return op;
|
}
|
}
|
|
|
/* Return true if T is a gimple invariant address. */
|
/* Return true if T is a gimple invariant address. */
|
|
|
bool
|
bool
|
is_gimple_invariant_address (const_tree t)
|
is_gimple_invariant_address (const_tree t)
|
{
|
{
|
const_tree op;
|
const_tree op;
|
|
|
if (TREE_CODE (t) != ADDR_EXPR)
|
if (TREE_CODE (t) != ADDR_EXPR)
|
return false;
|
return false;
|
|
|
op = strip_invariant_refs (TREE_OPERAND (t, 0));
|
op = strip_invariant_refs (TREE_OPERAND (t, 0));
|
|
|
return op && (CONSTANT_CLASS_P (op) || decl_address_invariant_p (op));
|
return op && (CONSTANT_CLASS_P (op) || decl_address_invariant_p (op));
|
}
|
}
|
|
|
/* Return true if T is a gimple invariant address at IPA level
|
/* Return true if T is a gimple invariant address at IPA level
|
(so addresses of variables on stack are not allowed). */
|
(so addresses of variables on stack are not allowed). */
|
|
|
bool
|
bool
|
is_gimple_ip_invariant_address (const_tree t)
|
is_gimple_ip_invariant_address (const_tree t)
|
{
|
{
|
const_tree op;
|
const_tree op;
|
|
|
if (TREE_CODE (t) != ADDR_EXPR)
|
if (TREE_CODE (t) != ADDR_EXPR)
|
return false;
|
return false;
|
|
|
op = strip_invariant_refs (TREE_OPERAND (t, 0));
|
op = strip_invariant_refs (TREE_OPERAND (t, 0));
|
|
|
return op && (CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op));
|
return op && (CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op));
|
}
|
}
|
|
|
/* Return true if T is a GIMPLE minimal invariant. It's a restricted
|
/* Return true if T is a GIMPLE minimal invariant. It's a restricted
|
form of function invariant. */
|
form of function invariant. */
|
|
|
bool
|
bool
|
is_gimple_min_invariant (const_tree t)
|
is_gimple_min_invariant (const_tree t)
|
{
|
{
|
if (TREE_CODE (t) == ADDR_EXPR)
|
if (TREE_CODE (t) == ADDR_EXPR)
|
return is_gimple_invariant_address (t);
|
return is_gimple_invariant_address (t);
|
|
|
return is_gimple_constant (t);
|
return is_gimple_constant (t);
|
}
|
}
|
|
|
/* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
|
/* Return true if T is a GIMPLE interprocedural invariant. It's a restricted
|
form of gimple minimal invariant. */
|
form of gimple minimal invariant. */
|
|
|
bool
|
bool
|
is_gimple_ip_invariant (const_tree t)
|
is_gimple_ip_invariant (const_tree t)
|
{
|
{
|
if (TREE_CODE (t) == ADDR_EXPR)
|
if (TREE_CODE (t) == ADDR_EXPR)
|
return is_gimple_ip_invariant_address (t);
|
return is_gimple_ip_invariant_address (t);
|
|
|
return is_gimple_constant (t);
|
return is_gimple_constant (t);
|
}
|
}
|
|
|
/* Return true if T looks like a valid GIMPLE statement. */
|
/* Return true if T looks like a valid GIMPLE statement. */
|
|
|
bool
|
bool
|
is_gimple_stmt (tree t)
|
is_gimple_stmt (tree t)
|
{
|
{
|
const enum tree_code code = TREE_CODE (t);
|
const enum tree_code code = TREE_CODE (t);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case NOP_EXPR:
|
case NOP_EXPR:
|
/* The only valid NOP_EXPR is the empty statement. */
|
/* The only valid NOP_EXPR is the empty statement. */
|
return IS_EMPTY_STMT (t);
|
return IS_EMPTY_STMT (t);
|
|
|
case BIND_EXPR:
|
case BIND_EXPR:
|
case COND_EXPR:
|
case COND_EXPR:
|
/* These are only valid if they're void. */
|
/* These are only valid if they're void. */
|
return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
|
return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
|
|
|
case SWITCH_EXPR:
|
case SWITCH_EXPR:
|
case GOTO_EXPR:
|
case GOTO_EXPR:
|
case RETURN_EXPR:
|
case RETURN_EXPR:
|
case LABEL_EXPR:
|
case LABEL_EXPR:
|
case CASE_LABEL_EXPR:
|
case CASE_LABEL_EXPR:
|
case TRY_CATCH_EXPR:
|
case TRY_CATCH_EXPR:
|
case TRY_FINALLY_EXPR:
|
case TRY_FINALLY_EXPR:
|
case EH_FILTER_EXPR:
|
case EH_FILTER_EXPR:
|
case CATCH_EXPR:
|
case CATCH_EXPR:
|
case ASM_EXPR:
|
case ASM_EXPR:
|
case STATEMENT_LIST:
|
case STATEMENT_LIST:
|
case OMP_PARALLEL:
|
case OMP_PARALLEL:
|
case OMP_FOR:
|
case OMP_FOR:
|
case OMP_SECTIONS:
|
case OMP_SECTIONS:
|
case OMP_SECTION:
|
case OMP_SECTION:
|
case OMP_SINGLE:
|
case OMP_SINGLE:
|
case OMP_MASTER:
|
case OMP_MASTER:
|
case OMP_ORDERED:
|
case OMP_ORDERED:
|
case OMP_CRITICAL:
|
case OMP_CRITICAL:
|
case OMP_TASK:
|
case OMP_TASK:
|
/* These are always void. */
|
/* These are always void. */
|
return true;
|
return true;
|
|
|
case CALL_EXPR:
|
case CALL_EXPR:
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
case PREDICT_EXPR:
|
case PREDICT_EXPR:
|
/* These are valid regardless of their type. */
|
/* These are valid regardless of their type. */
|
return true;
|
return true;
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Return true if T is a variable. */
|
/* Return true if T is a variable. */
|
|
|
bool
|
bool
|
is_gimple_variable (tree t)
|
is_gimple_variable (tree t)
|
{
|
{
|
return (TREE_CODE (t) == VAR_DECL
|
return (TREE_CODE (t) == VAR_DECL
|
|| TREE_CODE (t) == PARM_DECL
|
|| TREE_CODE (t) == PARM_DECL
|
|| TREE_CODE (t) == RESULT_DECL
|
|| TREE_CODE (t) == RESULT_DECL
|
|| TREE_CODE (t) == SSA_NAME);
|
|| TREE_CODE (t) == SSA_NAME);
|
}
|
}
|
|
|
/* Return true if T is a GIMPLE identifier (something with an address). */
|
/* Return true if T is a GIMPLE identifier (something with an address). */
|
|
|
bool
|
bool
|
is_gimple_id (tree t)
|
is_gimple_id (tree t)
|
{
|
{
|
return (is_gimple_variable (t)
|
return (is_gimple_variable (t)
|
|| TREE_CODE (t) == FUNCTION_DECL
|
|| TREE_CODE (t) == FUNCTION_DECL
|
|| TREE_CODE (t) == LABEL_DECL
|
|| TREE_CODE (t) == LABEL_DECL
|
|| TREE_CODE (t) == CONST_DECL
|
|| TREE_CODE (t) == CONST_DECL
|
/* Allow string constants, since they are addressable. */
|
/* Allow string constants, since they are addressable. */
|
|| TREE_CODE (t) == STRING_CST);
|
|| TREE_CODE (t) == STRING_CST);
|
}
|
}
|
|
|
/* Return true if TYPE is a suitable type for a scalar register variable. */
|
/* Return true if TYPE is a suitable type for a scalar register variable. */
|
|
|
bool
|
bool
|
is_gimple_reg_type (tree type)
|
is_gimple_reg_type (tree type)
|
{
|
{
|
return !AGGREGATE_TYPE_P (type);
|
return !AGGREGATE_TYPE_P (type);
|
}
|
}
|
|
|
/* Return true if T is a non-aggregate register variable. */
|
/* Return true if T is a non-aggregate register variable. */
|
|
|
bool
|
bool
|
is_gimple_reg (tree t)
|
is_gimple_reg (tree t)
|
{
|
{
|
if (TREE_CODE (t) == SSA_NAME)
|
if (TREE_CODE (t) == SSA_NAME)
|
t = SSA_NAME_VAR (t);
|
t = SSA_NAME_VAR (t);
|
|
|
if (!is_gimple_variable (t))
|
if (!is_gimple_variable (t))
|
return false;
|
return false;
|
|
|
if (!is_gimple_reg_type (TREE_TYPE (t)))
|
if (!is_gimple_reg_type (TREE_TYPE (t)))
|
return false;
|
return false;
|
|
|
/* A volatile decl is not acceptable because we can't reuse it as
|
/* A volatile decl is not acceptable because we can't reuse it as
|
needed. We need to copy it into a temp first. */
|
needed. We need to copy it into a temp first. */
|
if (TREE_THIS_VOLATILE (t))
|
if (TREE_THIS_VOLATILE (t))
|
return false;
|
return false;
|
|
|
/* We define "registers" as things that can be renamed as needed,
|
/* We define "registers" as things that can be renamed as needed,
|
which with our infrastructure does not apply to memory. */
|
which with our infrastructure does not apply to memory. */
|
if (needs_to_live_in_memory (t))
|
if (needs_to_live_in_memory (t))
|
return false;
|
return false;
|
|
|
/* Hard register variables are an interesting case. For those that
|
/* Hard register variables are an interesting case. For those that
|
are call-clobbered, we don't know where all the calls are, since
|
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
|
we don't (want to) take into account which operations will turn
|
into libcalls at the rtl level. For those that are call-saved,
|
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
|
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
|
global hard registers, nor do we examine ASM_CLOBBERS at the tree
|
level, and so miss variable changes that might imply. All around,
|
level, and so miss variable changes that might imply. All around,
|
it seems safest to not do too much optimization with these at the
|
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
|
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. */
|
clean this up, as there we've got all the appropriate bits exposed. */
|
if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
|
if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
|
return false;
|
return false;
|
|
|
/* Complex and vector values must have been put into SSA-like form.
|
/* Complex and vector values must have been put into SSA-like form.
|
That is, no assignments to the individual components. */
|
That is, no assignments to the individual components. */
|
if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
|
if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
|
|| TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
|
|| TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
|
return DECL_GIMPLE_REG_P (t);
|
return DECL_GIMPLE_REG_P (t);
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
|
|
/* Return true if T is a GIMPLE variable whose address is not needed. */
|
/* Return true if T is a GIMPLE variable whose address is not needed. */
|
|
|
bool
|
bool
|
is_gimple_non_addressable (tree t)
|
is_gimple_non_addressable (tree t)
|
{
|
{
|
if (TREE_CODE (t) == SSA_NAME)
|
if (TREE_CODE (t) == SSA_NAME)
|
t = SSA_NAME_VAR (t);
|
t = SSA_NAME_VAR (t);
|
|
|
return (is_gimple_variable (t) && ! needs_to_live_in_memory (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. */
|
/* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */
|
|
|
bool
|
bool
|
is_gimple_val (tree t)
|
is_gimple_val (tree t)
|
{
|
{
|
/* Make loads from volatiles and memory vars explicit. */
|
/* Make loads from volatiles and memory vars explicit. */
|
if (is_gimple_variable (t)
|
if (is_gimple_variable (t)
|
&& is_gimple_reg_type (TREE_TYPE (t))
|
&& is_gimple_reg_type (TREE_TYPE (t))
|
&& !is_gimple_reg (t))
|
&& !is_gimple_reg (t))
|
return false;
|
return false;
|
|
|
return (is_gimple_variable (t) || is_gimple_min_invariant (t));
|
return (is_gimple_variable (t) || is_gimple_min_invariant (t));
|
}
|
}
|
|
|
/* Similarly, but accept hard registers as inputs to asm statements. */
|
/* Similarly, but accept hard registers as inputs to asm statements. */
|
|
|
bool
|
bool
|
is_gimple_asm_val (tree t)
|
is_gimple_asm_val (tree t)
|
{
|
{
|
if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
|
if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
|
return true;
|
return true;
|
|
|
return is_gimple_val (t);
|
return is_gimple_val (t);
|
}
|
}
|
|
|
/* Return true if T is a GIMPLE minimal lvalue. */
|
/* Return true if T is a GIMPLE minimal lvalue. */
|
|
|
bool
|
bool
|
is_gimple_min_lval (tree t)
|
is_gimple_min_lval (tree t)
|
{
|
{
|
if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
|
if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
|
return false;
|
return false;
|
return (is_gimple_id (t) || TREE_CODE (t) == INDIRECT_REF);
|
return (is_gimple_id (t) || TREE_CODE (t) == INDIRECT_REF);
|
}
|
}
|
|
|
/* Return true if T is a typecast operation. */
|
/* Return true if T is a typecast operation. */
|
|
|
bool
|
bool
|
is_gimple_cast (tree t)
|
is_gimple_cast (tree t)
|
{
|
{
|
return (CONVERT_EXPR_P (t)
|
return (CONVERT_EXPR_P (t)
|
|| TREE_CODE (t) == FIX_TRUNC_EXPR);
|
|| TREE_CODE (t) == FIX_TRUNC_EXPR);
|
}
|
}
|
|
|
/* Return true if T is a valid function operand of a CALL_EXPR. */
|
/* Return true if T is a valid function operand of a CALL_EXPR. */
|
|
|
bool
|
bool
|
is_gimple_call_addr (tree t)
|
is_gimple_call_addr (tree t)
|
{
|
{
|
return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
|
return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
|
}
|
}
|
|
|
/* If T makes a function call, return the corresponding CALL_EXPR operand.
|
/* If T makes a function call, return the corresponding CALL_EXPR operand.
|
Otherwise, return NULL_TREE. */
|
Otherwise, return NULL_TREE. */
|
|
|
tree
|
tree
|
get_call_expr_in (tree t)
|
get_call_expr_in (tree t)
|
{
|
{
|
if (TREE_CODE (t) == MODIFY_EXPR)
|
if (TREE_CODE (t) == MODIFY_EXPR)
|
t = TREE_OPERAND (t, 1);
|
t = TREE_OPERAND (t, 1);
|
if (TREE_CODE (t) == WITH_SIZE_EXPR)
|
if (TREE_CODE (t) == WITH_SIZE_EXPR)
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
if (TREE_CODE (t) == CALL_EXPR)
|
if (TREE_CODE (t) == CALL_EXPR)
|
return t;
|
return t;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
|
|
/* Given a memory reference expression T, return its base address.
|
/* Given a memory reference expression T, return its base address.
|
The base address of a memory reference expression is the main
|
The base address of a memory reference expression is the main
|
object being referenced. For instance, the base address for
|
object being referenced. For instance, the base address for
|
'array[i].fld[j]' is 'array'. You can think of this as stripping
|
'array[i].fld[j]' is 'array'. You can think of this as stripping
|
away the offset part from a memory address.
|
away the offset part from a memory address.
|
|
|
This function calls handled_component_p to strip away all the inner
|
This function calls handled_component_p to strip away all the inner
|
parts of the memory reference until it reaches the base object. */
|
parts of the memory reference until it reaches the base object. */
|
|
|
tree
|
tree
|
get_base_address (tree t)
|
get_base_address (tree t)
|
{
|
{
|
while (handled_component_p (t))
|
while (handled_component_p (t))
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
|
|
if (SSA_VAR_P (t)
|
if (SSA_VAR_P (t)
|
|| TREE_CODE (t) == STRING_CST
|
|| TREE_CODE (t) == STRING_CST
|
|| TREE_CODE (t) == CONSTRUCTOR
|
|| TREE_CODE (t) == CONSTRUCTOR
|
|| INDIRECT_REF_P (t))
|
|| INDIRECT_REF_P (t))
|
return t;
|
return t;
|
else
|
else
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
void
|
void
|
recalculate_side_effects (tree t)
|
recalculate_side_effects (tree t)
|
{
|
{
|
enum tree_code code = TREE_CODE (t);
|
enum tree_code code = TREE_CODE (t);
|
int len = TREE_OPERAND_LENGTH (t);
|
int len = TREE_OPERAND_LENGTH (t);
|
int i;
|
int i;
|
|
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_expression:
|
case tcc_expression:
|
switch (code)
|
switch (code)
|
{
|
{
|
case INIT_EXPR:
|
case INIT_EXPR:
|
case MODIFY_EXPR:
|
case MODIFY_EXPR:
|
case VA_ARG_EXPR:
|
case VA_ARG_EXPR:
|
case PREDECREMENT_EXPR:
|
case PREDECREMENT_EXPR:
|
case PREINCREMENT_EXPR:
|
case PREINCREMENT_EXPR:
|
case POSTDECREMENT_EXPR:
|
case POSTDECREMENT_EXPR:
|
case POSTINCREMENT_EXPR:
|
case POSTINCREMENT_EXPR:
|
/* All of these have side-effects, no matter what their
|
/* All of these have side-effects, no matter what their
|
operands are. */
|
operands are. */
|
return;
|
return;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
/* Fall through. */
|
/* Fall through. */
|
|
|
case tcc_comparison: /* a comparison expression */
|
case tcc_comparison: /* a comparison expression */
|
case tcc_unary: /* a unary arithmetic expression */
|
case tcc_unary: /* a unary arithmetic expression */
|
case tcc_binary: /* a binary arithmetic expression */
|
case tcc_binary: /* a binary arithmetic expression */
|
case tcc_reference: /* a reference */
|
case tcc_reference: /* a reference */
|
case tcc_vl_exp: /* a function call */
|
case tcc_vl_exp: /* a function call */
|
TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
|
TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
|
for (i = 0; i < len; ++i)
|
for (i = 0; i < len; ++i)
|
{
|
{
|
tree op = TREE_OPERAND (t, i);
|
tree op = TREE_OPERAND (t, i);
|
if (op && TREE_SIDE_EFFECTS (op))
|
if (op && TREE_SIDE_EFFECTS (op))
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_SIDE_EFFECTS (t) = 1;
|
}
|
}
|
break;
|
break;
|
|
|
case tcc_constant:
|
case tcc_constant:
|
/* No side-effects. */
|
/* No side-effects. */
|
return;
|
return;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
|
/* Canonicalize a tree T for use in a COND_EXPR as conditional. Returns
|
a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
|
a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
|
we failed to create one. */
|
we failed to create one. */
|
|
|
tree
|
tree
|
canonicalize_cond_expr_cond (tree t)
|
canonicalize_cond_expr_cond (tree t)
|
{
|
{
|
/* Strip conversions around boolean operations. */
|
/* Strip conversions around boolean operations. */
|
if (CONVERT_EXPR_P (t)
|
if (CONVERT_EXPR_P (t)
|
&& truth_value_p (TREE_CODE (TREE_OPERAND (t, 0))))
|
&& truth_value_p (TREE_CODE (TREE_OPERAND (t, 0))))
|
t = TREE_OPERAND (t, 0);
|
t = TREE_OPERAND (t, 0);
|
|
|
/* For (bool)x use x != 0. */
|
/* For (bool)x use x != 0. */
|
if (CONVERT_EXPR_P (t)
|
if (CONVERT_EXPR_P (t)
|
&& TREE_CODE (TREE_TYPE (t)) == BOOLEAN_TYPE)
|
&& TREE_CODE (TREE_TYPE (t)) == BOOLEAN_TYPE)
|
{
|
{
|
tree top0 = TREE_OPERAND (t, 0);
|
tree top0 = TREE_OPERAND (t, 0);
|
t = build2 (NE_EXPR, TREE_TYPE (t),
|
t = build2 (NE_EXPR, TREE_TYPE (t),
|
top0, build_int_cst (TREE_TYPE (top0), 0));
|
top0, build_int_cst (TREE_TYPE (top0), 0));
|
}
|
}
|
/* For !x use x == 0. */
|
/* For !x use x == 0. */
|
else if (TREE_CODE (t) == TRUTH_NOT_EXPR)
|
else if (TREE_CODE (t) == TRUTH_NOT_EXPR)
|
{
|
{
|
tree top0 = TREE_OPERAND (t, 0);
|
tree top0 = TREE_OPERAND (t, 0);
|
t = build2 (EQ_EXPR, TREE_TYPE (t),
|
t = build2 (EQ_EXPR, TREE_TYPE (t),
|
top0, build_int_cst (TREE_TYPE (top0), 0));
|
top0, build_int_cst (TREE_TYPE (top0), 0));
|
}
|
}
|
/* For cmp ? 1 : 0 use cmp. */
|
/* For cmp ? 1 : 0 use cmp. */
|
else if (TREE_CODE (t) == COND_EXPR
|
else if (TREE_CODE (t) == COND_EXPR
|
&& COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
|
&& COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
|
&& integer_onep (TREE_OPERAND (t, 1))
|
&& integer_onep (TREE_OPERAND (t, 1))
|
&& integer_zerop (TREE_OPERAND (t, 2)))
|
&& integer_zerop (TREE_OPERAND (t, 2)))
|
{
|
{
|
tree top0 = TREE_OPERAND (t, 0);
|
tree top0 = TREE_OPERAND (t, 0);
|
t = build2 (TREE_CODE (top0), TREE_TYPE (t),
|
t = build2 (TREE_CODE (top0), TREE_TYPE (t),
|
TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
|
TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
|
}
|
}
|
|
|
if (is_gimple_condexpr (t))
|
if (is_gimple_condexpr (t))
|
return t;
|
return t;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
|
/* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
|
the positions marked by the set ARGS_TO_SKIP. */
|
the positions marked by the set ARGS_TO_SKIP. */
|
|
|
gimple
|
gimple
|
gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
|
gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
|
{
|
{
|
int i;
|
int i;
|
tree fn = gimple_call_fn (stmt);
|
tree fn = gimple_call_fn (stmt);
|
int nargs = gimple_call_num_args (stmt);
|
int nargs = gimple_call_num_args (stmt);
|
VEC(tree, heap) *vargs = VEC_alloc (tree, heap, nargs);
|
VEC(tree, heap) *vargs = VEC_alloc (tree, heap, nargs);
|
gimple new_stmt;
|
gimple new_stmt;
|
|
|
for (i = 0; i < nargs; i++)
|
for (i = 0; i < nargs; i++)
|
if (!bitmap_bit_p (args_to_skip, i))
|
if (!bitmap_bit_p (args_to_skip, i))
|
VEC_quick_push (tree, vargs, gimple_call_arg (stmt, i));
|
VEC_quick_push (tree, vargs, gimple_call_arg (stmt, i));
|
|
|
new_stmt = gimple_build_call_vec (fn, vargs);
|
new_stmt = gimple_build_call_vec (fn, vargs);
|
VEC_free (tree, heap, vargs);
|
VEC_free (tree, heap, vargs);
|
if (gimple_call_lhs (stmt))
|
if (gimple_call_lhs (stmt))
|
gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
|
gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
|
|
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
gimple_set_vdef (new_stmt, gimple_vdef (stmt));
|
|
|
gimple_set_block (new_stmt, gimple_block (stmt));
|
gimple_set_block (new_stmt, gimple_block (stmt));
|
if (gimple_has_location (stmt))
|
if (gimple_has_location (stmt))
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
gimple_set_location (new_stmt, gimple_location (stmt));
|
gimple_call_copy_flags (new_stmt, stmt);
|
gimple_call_copy_flags (new_stmt, stmt);
|
gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
|
gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
|
|
|
gimple_set_modified (new_stmt, true);
|
gimple_set_modified (new_stmt, true);
|
|
|
return new_stmt;
|
return new_stmt;
|
}
|
}
|
|
|
|
|
static hashval_t gimple_type_hash (const void *);
|
static hashval_t gimple_type_hash (const void *);
|
|
|
/* Structure used to maintain a cache of some type pairs compared by
|
/* Structure used to maintain a cache of some type pairs compared by
|
gimple_types_compatible_p when comparing aggregate types. There are
|
gimple_types_compatible_p when comparing aggregate types. There are
|
four possible values for SAME_P:
|
four possible values for SAME_P:
|
|
|
-2: The pair (T1, T2) has just been inserted in the table.
|
-2: The pair (T1, T2) has just been inserted in the table.
|
-1: The pair (T1, T2) is currently being compared.
|
-1: The pair (T1, T2) is currently being compared.
|
0: T1 and T2 are different types.
|
0: T1 and T2 are different types.
|
1: T1 and T2 are the same type.
|
1: T1 and T2 are the same type.
|
|
|
This table is only used when comparing aggregate types to avoid
|
This table is only used when comparing aggregate types to avoid
|
infinite recursion due to self-referential types. */
|
infinite recursion due to self-referential types. */
|
struct type_pair_d
|
struct type_pair_d
|
{
|
{
|
unsigned int uid1;
|
unsigned int uid1;
|
unsigned int uid2;
|
unsigned int uid2;
|
int same_p;
|
int same_p;
|
};
|
};
|
typedef struct type_pair_d *type_pair_t;
|
typedef struct type_pair_d *type_pair_t;
|
|
|
/* Return a hash value for the type pair pointed-to by P. */
|
/* Return a hash value for the type pair pointed-to by P. */
|
|
|
static hashval_t
|
static hashval_t
|
type_pair_hash (const void *p)
|
type_pair_hash (const void *p)
|
{
|
{
|
const struct type_pair_d *pair = (const struct type_pair_d *) p;
|
const struct type_pair_d *pair = (const struct type_pair_d *) p;
|
hashval_t val1 = pair->uid1;
|
hashval_t val1 = pair->uid1;
|
hashval_t val2 = pair->uid2;
|
hashval_t val2 = pair->uid2;
|
return (iterative_hash_hashval_t (val2, val1)
|
return (iterative_hash_hashval_t (val2, val1)
|
^ iterative_hash_hashval_t (val1, val2));
|
^ iterative_hash_hashval_t (val1, val2));
|
}
|
}
|
|
|
/* Compare two type pairs pointed-to by P1 and P2. */
|
/* Compare two type pairs pointed-to by P1 and P2. */
|
|
|
static int
|
static int
|
type_pair_eq (const void *p1, const void *p2)
|
type_pair_eq (const void *p1, const void *p2)
|
{
|
{
|
const struct type_pair_d *pair1 = (const struct type_pair_d *) p1;
|
const struct type_pair_d *pair1 = (const struct type_pair_d *) p1;
|
const struct type_pair_d *pair2 = (const struct type_pair_d *) p2;
|
const struct type_pair_d *pair2 = (const struct type_pair_d *) p2;
|
return ((pair1->uid1 == pair2->uid1 && pair1->uid2 == pair2->uid2)
|
return ((pair1->uid1 == pair2->uid1 && pair1->uid2 == pair2->uid2)
|
|| (pair1->uid1 == pair2->uid2 && pair1->uid2 == pair2->uid1));
|
|| (pair1->uid1 == pair2->uid2 && pair1->uid2 == pair2->uid1));
|
}
|
}
|
|
|
/* Lookup the pair of types T1 and T2 in *VISITED_P. Insert a new
|
/* Lookup the pair of types T1 and T2 in *VISITED_P. Insert a new
|
entry if none existed. */
|
entry if none existed. */
|
|
|
static type_pair_t
|
static type_pair_t
|
lookup_type_pair (tree t1, tree t2, htab_t *visited_p, struct obstack *ob_p)
|
lookup_type_pair (tree t1, tree t2, htab_t *visited_p, struct obstack *ob_p)
|
{
|
{
|
struct type_pair_d pair;
|
struct type_pair_d pair;
|
type_pair_t p;
|
type_pair_t p;
|
void **slot;
|
void **slot;
|
|
|
if (*visited_p == NULL)
|
if (*visited_p == NULL)
|
{
|
{
|
*visited_p = htab_create (251, type_pair_hash, type_pair_eq, NULL);
|
*visited_p = htab_create (251, type_pair_hash, type_pair_eq, NULL);
|
gcc_obstack_init (ob_p);
|
gcc_obstack_init (ob_p);
|
}
|
}
|
|
|
pair.uid1 = TYPE_UID (t1);
|
pair.uid1 = TYPE_UID (t1);
|
pair.uid2 = TYPE_UID (t2);
|
pair.uid2 = TYPE_UID (t2);
|
slot = htab_find_slot (*visited_p, &pair, INSERT);
|
slot = htab_find_slot (*visited_p, &pair, INSERT);
|
|
|
if (*slot)
|
if (*slot)
|
p = *((type_pair_t *) slot);
|
p = *((type_pair_t *) slot);
|
else
|
else
|
{
|
{
|
p = XOBNEW (ob_p, struct type_pair_d);
|
p = XOBNEW (ob_p, struct type_pair_d);
|
p->uid1 = TYPE_UID (t1);
|
p->uid1 = TYPE_UID (t1);
|
p->uid2 = TYPE_UID (t2);
|
p->uid2 = TYPE_UID (t2);
|
p->same_p = -2;
|
p->same_p = -2;
|
*slot = (void *) p;
|
*slot = (void *) p;
|
}
|
}
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
|
|
/* Return true if T1 and T2 have the same name. If FOR_COMPLETION_P is
|
/* Return true if T1 and T2 have the same name. If FOR_COMPLETION_P is
|
true then if any type has no name return false, otherwise return
|
true then if any type has no name return false, otherwise return
|
true if both types have no names. */
|
true if both types have no names. */
|
|
|
static bool
|
static bool
|
compare_type_names_p (tree t1, tree t2, bool for_completion_p)
|
compare_type_names_p (tree t1, tree t2, bool for_completion_p)
|
{
|
{
|
tree name1 = TYPE_NAME (t1);
|
tree name1 = TYPE_NAME (t1);
|
tree name2 = TYPE_NAME (t2);
|
tree name2 = TYPE_NAME (t2);
|
|
|
/* Consider anonymous types all unique for completion. */
|
/* Consider anonymous types all unique for completion. */
|
if (for_completion_p
|
if (for_completion_p
|
&& (!name1 || !name2))
|
&& (!name1 || !name2))
|
return false;
|
return false;
|
|
|
if (name1 && TREE_CODE (name1) == TYPE_DECL)
|
if (name1 && TREE_CODE (name1) == TYPE_DECL)
|
{
|
{
|
name1 = DECL_NAME (name1);
|
name1 = DECL_NAME (name1);
|
if (for_completion_p
|
if (for_completion_p
|
&& !name1)
|
&& !name1)
|
return false;
|
return false;
|
}
|
}
|
gcc_assert (!name1 || TREE_CODE (name1) == IDENTIFIER_NODE);
|
gcc_assert (!name1 || TREE_CODE (name1) == IDENTIFIER_NODE);
|
|
|
if (name2 && TREE_CODE (name2) == TYPE_DECL)
|
if (name2 && TREE_CODE (name2) == TYPE_DECL)
|
{
|
{
|
name2 = DECL_NAME (name2);
|
name2 = DECL_NAME (name2);
|
if (for_completion_p
|
if (for_completion_p
|
&& !name2)
|
&& !name2)
|
return false;
|
return false;
|
}
|
}
|
gcc_assert (!name2 || TREE_CODE (name2) == IDENTIFIER_NODE);
|
gcc_assert (!name2 || TREE_CODE (name2) == IDENTIFIER_NODE);
|
|
|
/* Identifiers can be compared with pointer equality rather
|
/* Identifiers can be compared with pointer equality rather
|
than a string comparison. */
|
than a string comparison. */
|
if (name1 == name2)
|
if (name1 == name2)
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if the field decls F1 and F2 are at the same offset. */
|
/* Return true if the field decls F1 and F2 are at the same offset. */
|
|
|
bool
|
bool
|
compare_field_offset (tree f1, tree f2)
|
compare_field_offset (tree f1, tree f2)
|
{
|
{
|
if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
|
if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
|
return (operand_equal_p (DECL_FIELD_OFFSET (f1),
|
return (operand_equal_p (DECL_FIELD_OFFSET (f1),
|
DECL_FIELD_OFFSET (f2), 0)
|
DECL_FIELD_OFFSET (f2), 0)
|
&& tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
|
&& tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
|
DECL_FIELD_BIT_OFFSET (f2)));
|
DECL_FIELD_BIT_OFFSET (f2)));
|
|
|
/* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
|
/* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
|
should be, so handle differing ones specially by decomposing
|
should be, so handle differing ones specially by decomposing
|
the offset into a byte and bit offset manually. */
|
the offset into a byte and bit offset manually. */
|
if (host_integerp (DECL_FIELD_OFFSET (f1), 0)
|
if (host_integerp (DECL_FIELD_OFFSET (f1), 0)
|
&& host_integerp (DECL_FIELD_OFFSET (f2), 0))
|
&& host_integerp (DECL_FIELD_OFFSET (f2), 0))
|
{
|
{
|
unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
|
unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
|
unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
|
unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
|
bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
|
bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
|
byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
|
byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
|
+ bit_offset1 / BITS_PER_UNIT);
|
+ bit_offset1 / BITS_PER_UNIT);
|
bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
|
bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
|
byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
|
byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
|
+ bit_offset2 / BITS_PER_UNIT);
|
+ bit_offset2 / BITS_PER_UNIT);
|
if (byte_offset1 != byte_offset2)
|
if (byte_offset1 != byte_offset2)
|
return false;
|
return false;
|
return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
|
return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
|
}
|
}
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return 1 iff T1 and T2 are structurally identical.
|
/* Return 1 iff T1 and T2 are structurally identical.
|
Otherwise, return 0. */
|
Otherwise, return 0. */
|
|
|
static int
|
static int
|
gimple_types_compatible_p (tree t1, tree t2)
|
gimple_types_compatible_p (tree t1, tree t2)
|
{
|
{
|
type_pair_t p = NULL;
|
type_pair_t p = NULL;
|
|
|
/* Check first for the obvious case of pointer identity. */
|
/* Check first for the obvious case of pointer identity. */
|
if (t1 == t2)
|
if (t1 == t2)
|
return 1;
|
return 1;
|
|
|
/* Check that we have two types to compare. */
|
/* Check that we have two types to compare. */
|
if (t1 == NULL_TREE || t2 == NULL_TREE)
|
if (t1 == NULL_TREE || t2 == NULL_TREE)
|
return 0;
|
return 0;
|
|
|
/* Can't be the same type if the types don't have the same code. */
|
/* Can't be the same type if the types don't have the same code. */
|
if (TREE_CODE (t1) != TREE_CODE (t2))
|
if (TREE_CODE (t1) != TREE_CODE (t2))
|
return 0;
|
return 0;
|
|
|
/* Can't be the same type if they have different CV qualifiers. */
|
/* Can't be the same type if they have different CV qualifiers. */
|
if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
|
if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
|
return 0;
|
return 0;
|
|
|
/* Void types are always the same. */
|
/* Void types are always the same. */
|
if (TREE_CODE (t1) == VOID_TYPE)
|
if (TREE_CODE (t1) == VOID_TYPE)
|
return 1;
|
return 1;
|
|
|
/* For numerical types do some simple checks before doing three
|
/* For numerical types do some simple checks before doing three
|
hashtable queries. */
|
hashtable queries. */
|
if (INTEGRAL_TYPE_P (t1)
|
if (INTEGRAL_TYPE_P (t1)
|
|| SCALAR_FLOAT_TYPE_P (t1)
|
|| SCALAR_FLOAT_TYPE_P (t1)
|
|| FIXED_POINT_TYPE_P (t1)
|
|| FIXED_POINT_TYPE_P (t1)
|
|| TREE_CODE (t1) == VECTOR_TYPE
|
|| TREE_CODE (t1) == VECTOR_TYPE
|
|| TREE_CODE (t1) == COMPLEX_TYPE
|
|| TREE_CODE (t1) == COMPLEX_TYPE
|
|| TREE_CODE (t1) == OFFSET_TYPE)
|
|| TREE_CODE (t1) == OFFSET_TYPE)
|
{
|
{
|
/* Can't be the same type if they have different alignment,
|
/* Can't be the same type if they have different alignment,
|
sign, precision or mode. */
|
sign, precision or mode. */
|
if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
|
if (TYPE_ALIGN (t1) != TYPE_ALIGN (t2)
|
|| TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
|
|| TYPE_PRECISION (t1) != TYPE_PRECISION (t2)
|
|| TYPE_MODE (t1) != TYPE_MODE (t2)
|
|| TYPE_MODE (t1) != TYPE_MODE (t2)
|
|| TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
|
|| TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2))
|
return 0;
|
return 0;
|
|
|
if (TREE_CODE (t1) == INTEGER_TYPE
|
if (TREE_CODE (t1) == INTEGER_TYPE
|
&& (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
|
&& (TYPE_IS_SIZETYPE (t1) != TYPE_IS_SIZETYPE (t2)
|
|| TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
|
|| TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)))
|
return 0;
|
return 0;
|
|
|
/* That's all we need to check for float and fixed-point types. */
|
/* That's all we need to check for float and fixed-point types. */
|
if (SCALAR_FLOAT_TYPE_P (t1)
|
if (SCALAR_FLOAT_TYPE_P (t1)
|
|| FIXED_POINT_TYPE_P (t1))
|
|| FIXED_POINT_TYPE_P (t1))
|
return 1;
|
return 1;
|
|
|
/* Perform cheap tail-recursion for vector and complex types. */
|
/* Perform cheap tail-recursion for vector and complex types. */
|
if (TREE_CODE (t1) == VECTOR_TYPE
|
if (TREE_CODE (t1) == VECTOR_TYPE
|
|| TREE_CODE (t1) == COMPLEX_TYPE)
|
|| TREE_CODE (t1) == COMPLEX_TYPE)
|
return gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2));
|
return gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2));
|
|
|
/* For integral types fall thru to more complex checks. */
|
/* For integral types fall thru to more complex checks. */
|
}
|
}
|
|
|
/* If the hash values of t1 and t2 are different the types can't
|
/* If the hash values of t1 and t2 are different the types can't
|
possibly be the same. This helps keeping the type-pair hashtable
|
possibly be the same. This helps keeping the type-pair hashtable
|
small, only tracking comparisons for hash collisions. */
|
small, only tracking comparisons for hash collisions. */
|
if (gimple_type_hash (t1) != gimple_type_hash (t2))
|
if (gimple_type_hash (t1) != gimple_type_hash (t2))
|
return 0;
|
return 0;
|
|
|
/* If we've visited this type pair before (in the case of aggregates
|
/* If we've visited this type pair before (in the case of aggregates
|
with self-referential types), and we made a decision, return it. */
|
with self-referential types), and we made a decision, return it. */
|
p = lookup_type_pair (t1, t2, >c_visited, >c_ob);
|
p = lookup_type_pair (t1, t2, >c_visited, >c_ob);
|
if (p->same_p == 0 || p->same_p == 1)
|
if (p->same_p == 0 || p->same_p == 1)
|
{
|
{
|
/* We have already decided whether T1 and T2 are the
|
/* We have already decided whether T1 and T2 are the
|
same, return the cached result. */
|
same, return the cached result. */
|
return p->same_p == 1;
|
return p->same_p == 1;
|
}
|
}
|
else if (p->same_p == -1)
|
else if (p->same_p == -1)
|
{
|
{
|
/* We are currently comparing this pair of types, assume
|
/* We are currently comparing this pair of types, assume
|
that they are the same and let the caller decide. */
|
that they are the same and let the caller decide. */
|
return 1;
|
return 1;
|
}
|
}
|
|
|
gcc_assert (p->same_p == -2);
|
gcc_assert (p->same_p == -2);
|
|
|
/* Mark the (T1, T2) comparison in progress. */
|
/* Mark the (T1, T2) comparison in progress. */
|
p->same_p = -1;
|
p->same_p = -1;
|
|
|
/* If their attributes are not the same they can't be the same type. */
|
/* If their attributes are not the same they can't be the same type. */
|
if (!attribute_list_equal (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)))
|
if (!attribute_list_equal (TYPE_ATTRIBUTES (t1), TYPE_ATTRIBUTES (t2)))
|
goto different_types;
|
goto different_types;
|
|
|
/* Do type-specific comparisons. */
|
/* Do type-specific comparisons. */
|
switch (TREE_CODE (t1))
|
switch (TREE_CODE (t1))
|
{
|
{
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
/* Array types are the same if the element types are the same and
|
/* Array types are the same if the element types are the same and
|
the number of elements are the same. */
|
the number of elements are the same. */
|
if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
|
if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
|
|| TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
|
|| TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2)
|
|| TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
|
|| TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2))
|
goto different_types;
|
goto different_types;
|
else
|
else
|
{
|
{
|
tree i1 = TYPE_DOMAIN (t1);
|
tree i1 = TYPE_DOMAIN (t1);
|
tree i2 = TYPE_DOMAIN (t2);
|
tree i2 = TYPE_DOMAIN (t2);
|
|
|
/* For an incomplete external array, the type domain can be
|
/* For an incomplete external array, the type domain can be
|
NULL_TREE. Check this condition also. */
|
NULL_TREE. Check this condition also. */
|
if (i1 == NULL_TREE && i2 == NULL_TREE)
|
if (i1 == NULL_TREE && i2 == NULL_TREE)
|
goto same_types;
|
goto same_types;
|
else if (i1 == NULL_TREE || i2 == NULL_TREE)
|
else if (i1 == NULL_TREE || i2 == NULL_TREE)
|
goto different_types;
|
goto different_types;
|
/* If for a complete array type the possibly gimplified sizes
|
/* If for a complete array type the possibly gimplified sizes
|
are different the types are different. */
|
are different the types are different. */
|
else if (((TYPE_SIZE (i1) != NULL) ^ (TYPE_SIZE (i2) != NULL))
|
else if (((TYPE_SIZE (i1) != NULL) ^ (TYPE_SIZE (i2) != NULL))
|
|| (TYPE_SIZE (i1)
|
|| (TYPE_SIZE (i1)
|
&& TYPE_SIZE (i2)
|
&& TYPE_SIZE (i2)
|
&& !operand_equal_p (TYPE_SIZE (i1), TYPE_SIZE (i2), 0)))
|
&& !operand_equal_p (TYPE_SIZE (i1), TYPE_SIZE (i2), 0)))
|
goto different_types;
|
goto different_types;
|
else
|
else
|
{
|
{
|
tree min1 = TYPE_MIN_VALUE (i1);
|
tree min1 = TYPE_MIN_VALUE (i1);
|
tree min2 = TYPE_MIN_VALUE (i2);
|
tree min2 = TYPE_MIN_VALUE (i2);
|
tree max1 = TYPE_MAX_VALUE (i1);
|
tree max1 = TYPE_MAX_VALUE (i1);
|
tree max2 = TYPE_MAX_VALUE (i2);
|
tree max2 = TYPE_MAX_VALUE (i2);
|
|
|
/* The minimum/maximum values have to be the same. */
|
/* The minimum/maximum values have to be the same. */
|
if ((min1 == min2
|
if ((min1 == min2
|
|| (min1 && min2 && operand_equal_p (min1, min2, 0)))
|
|| (min1 && min2 && operand_equal_p (min1, min2, 0)))
|
&& (max1 == max2
|
&& (max1 == max2
|
|| (max1 && max2 && operand_equal_p (max1, max2, 0))))
|
|| (max1 && max2 && operand_equal_p (max1, max2, 0))))
|
goto same_types;
|
goto same_types;
|
else
|
else
|
goto different_types;
|
goto different_types;
|
}
|
}
|
}
|
}
|
|
|
case METHOD_TYPE:
|
case METHOD_TYPE:
|
/* Method types should belong to the same class. */
|
/* Method types should belong to the same class. */
|
if (!gimple_types_compatible_p (TYPE_METHOD_BASETYPE (t1),
|
if (!gimple_types_compatible_p (TYPE_METHOD_BASETYPE (t1),
|
TYPE_METHOD_BASETYPE (t2)))
|
TYPE_METHOD_BASETYPE (t2)))
|
goto different_types;
|
goto different_types;
|
|
|
/* Fallthru */
|
/* Fallthru */
|
|
|
case FUNCTION_TYPE:
|
case FUNCTION_TYPE:
|
/* Function types are the same if the return type and arguments types
|
/* Function types are the same if the return type and arguments types
|
are the same. */
|
are the same. */
|
if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
goto different_types;
|
goto different_types;
|
else
|
else
|
{
|
{
|
if (!targetm.comp_type_attributes (t1, t2))
|
if (!targetm.comp_type_attributes (t1, t2))
|
goto different_types;
|
goto different_types;
|
|
|
if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
|
if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2))
|
goto same_types;
|
goto same_types;
|
else
|
else
|
{
|
{
|
tree parms1, parms2;
|
tree parms1, parms2;
|
|
|
for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
|
for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2);
|
parms1 && parms2;
|
parms1 && parms2;
|
parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
|
parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2))
|
{
|
{
|
if (!gimple_types_compatible_p (TREE_VALUE (parms1),
|
if (!gimple_types_compatible_p (TREE_VALUE (parms1),
|
TREE_VALUE (parms2)))
|
TREE_VALUE (parms2)))
|
goto different_types;
|
goto different_types;
|
}
|
}
|
|
|
if (parms1 || parms2)
|
if (parms1 || parms2)
|
goto different_types;
|
goto different_types;
|
|
|
goto same_types;
|
goto same_types;
|
}
|
}
|
}
|
}
|
|
|
case OFFSET_TYPE:
|
case OFFSET_TYPE:
|
{
|
{
|
if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
|
if (!gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2))
|
|| !gimple_types_compatible_p (TYPE_OFFSET_BASETYPE (t1),
|
|| !gimple_types_compatible_p (TYPE_OFFSET_BASETYPE (t1),
|
TYPE_OFFSET_BASETYPE (t2)))
|
TYPE_OFFSET_BASETYPE (t2)))
|
goto different_types;
|
goto different_types;
|
|
|
goto same_types;
|
goto same_types;
|
}
|
}
|
|
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
{
|
{
|
/* If the two pointers have different ref-all attributes,
|
/* If the two pointers have different ref-all attributes,
|
they can't be the same type. */
|
they can't be the same type. */
|
if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
|
if (TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
|
goto different_types;
|
goto different_types;
|
|
|
/* If one pointer points to an incomplete type variant of
|
/* If one pointer points to an incomplete type variant of
|
the other pointed-to type they are the same. */
|
the other pointed-to type they are the same. */
|
if (TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2))
|
if (TREE_CODE (TREE_TYPE (t1)) == TREE_CODE (TREE_TYPE (t2))
|
&& RECORD_OR_UNION_TYPE_P (TREE_TYPE (t1))
|
&& RECORD_OR_UNION_TYPE_P (TREE_TYPE (t1))
|
&& (!COMPLETE_TYPE_P (TREE_TYPE (t1))
|
&& (!COMPLETE_TYPE_P (TREE_TYPE (t1))
|
|| !COMPLETE_TYPE_P (TREE_TYPE (t2)))
|
|| !COMPLETE_TYPE_P (TREE_TYPE (t2)))
|
&& TYPE_QUALS (TREE_TYPE (t1)) == TYPE_QUALS (TREE_TYPE (t2))
|
&& TYPE_QUALS (TREE_TYPE (t1)) == TYPE_QUALS (TREE_TYPE (t2))
|
&& compare_type_names_p (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
|
&& compare_type_names_p (TYPE_MAIN_VARIANT (TREE_TYPE (t1)),
|
TYPE_MAIN_VARIANT (TREE_TYPE (t2)), true))
|
TYPE_MAIN_VARIANT (TREE_TYPE (t2)), true))
|
{
|
{
|
/* Replace the pointed-to incomplete type with the
|
/* Replace the pointed-to incomplete type with the
|
complete one.
|
complete one.
|
??? This simple name-based merging causes at least some
|
??? This simple name-based merging causes at least some
|
of the ICEs in canonicalizing FIELD_DECLs during stmt
|
of the ICEs in canonicalizing FIELD_DECLs during stmt
|
read. For example in GCC we have two different struct deps
|
read. For example in GCC we have two different struct deps
|
and we mismatch the use in struct cpp_reader in sched-int.h
|
and we mismatch the use in struct cpp_reader in sched-int.h
|
vs. mkdeps.c. Of course the whole exercise is for TBAA
|
vs. mkdeps.c. Of course the whole exercise is for TBAA
|
with structs which contain pointers to incomplete types
|
with structs which contain pointers to incomplete types
|
in one unit and to complete ones in another. So we
|
in one unit and to complete ones in another. So we
|
probably should merge these types only with more context. */
|
probably should merge these types only with more context. */
|
if (COMPLETE_TYPE_P (TREE_TYPE (t2)))
|
if (COMPLETE_TYPE_P (TREE_TYPE (t2)))
|
TREE_TYPE (t1) = TREE_TYPE (t2);
|
TREE_TYPE (t1) = TREE_TYPE (t2);
|
else
|
else
|
TREE_TYPE (t2) = TREE_TYPE (t1);
|
TREE_TYPE (t2) = TREE_TYPE (t1);
|
goto same_types;
|
goto same_types;
|
}
|
}
|
|
|
/* Otherwise, pointer and reference types are the same if the
|
/* Otherwise, pointer and reference types are the same if the
|
pointed-to types are the same. */
|
pointed-to types are the same. */
|
if (gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
if (gimple_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
|
goto same_types;
|
goto same_types;
|
|
|
goto different_types;
|
goto different_types;
|
}
|
}
|
|
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
case BOOLEAN_TYPE:
|
case BOOLEAN_TYPE:
|
{
|
{
|
tree min1 = TYPE_MIN_VALUE (t1);
|
tree min1 = TYPE_MIN_VALUE (t1);
|
tree max1 = TYPE_MAX_VALUE (t1);
|
tree max1 = TYPE_MAX_VALUE (t1);
|
tree min2 = TYPE_MIN_VALUE (t2);
|
tree min2 = TYPE_MIN_VALUE (t2);
|
tree max2 = TYPE_MAX_VALUE (t2);
|
tree max2 = TYPE_MAX_VALUE (t2);
|
bool min_equal_p = false;
|
bool min_equal_p = false;
|
bool max_equal_p = false;
|
bool max_equal_p = false;
|
|
|
/* If either type has a minimum value, the other type must
|
/* If either type has a minimum value, the other type must
|
have the same. */
|
have the same. */
|
if (min1 == NULL_TREE && min2 == NULL_TREE)
|
if (min1 == NULL_TREE && min2 == NULL_TREE)
|
min_equal_p = true;
|
min_equal_p = true;
|
else if (min1 && min2 && operand_equal_p (min1, min2, 0))
|
else if (min1 && min2 && operand_equal_p (min1, min2, 0))
|
min_equal_p = true;
|
min_equal_p = true;
|
|
|
/* Likewise, if either type has a maximum value, the other
|
/* Likewise, if either type has a maximum value, the other
|
type must have the same. */
|
type must have the same. */
|
if (max1 == NULL_TREE && max2 == NULL_TREE)
|
if (max1 == NULL_TREE && max2 == NULL_TREE)
|
max_equal_p = true;
|
max_equal_p = true;
|
else if (max1 && max2 && operand_equal_p (max1, max2, 0))
|
else if (max1 && max2 && operand_equal_p (max1, max2, 0))
|
max_equal_p = true;
|
max_equal_p = true;
|
|
|
if (!min_equal_p || !max_equal_p)
|
if (!min_equal_p || !max_equal_p)
|
goto different_types;
|
goto different_types;
|
|
|
goto same_types;
|
goto same_types;
|
}
|
}
|
|
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
{
|
{
|
/* FIXME lto, we cannot check bounds on enumeral types because
|
/* FIXME lto, we cannot check bounds on enumeral types because
|
different front ends will produce different values.
|
different front ends will produce different values.
|
In C, enumeral types are integers, while in C++ each element
|
In C, enumeral types are integers, while in C++ each element
|
will have its own symbolic value. We should decide how enums
|
will have its own symbolic value. We should decide how enums
|
are to be represented in GIMPLE and have each front end lower
|
are to be represented in GIMPLE and have each front end lower
|
to that. */
|
to that. */
|
tree v1, v2;
|
tree v1, v2;
|
|
|
/* For enumeral types, all the values must be the same. */
|
/* For enumeral types, all the values must be the same. */
|
if (TYPE_VALUES (t1) == TYPE_VALUES (t2))
|
if (TYPE_VALUES (t1) == TYPE_VALUES (t2))
|
goto same_types;
|
goto same_types;
|
|
|
for (v1 = TYPE_VALUES (t1), v2 = TYPE_VALUES (t2);
|
for (v1 = TYPE_VALUES (t1), v2 = TYPE_VALUES (t2);
|
v1 && v2;
|
v1 && v2;
|
v1 = TREE_CHAIN (v1), v2 = TREE_CHAIN (v2))
|
v1 = TREE_CHAIN (v1), v2 = TREE_CHAIN (v2))
|
{
|
{
|
tree c1 = TREE_VALUE (v1);
|
tree c1 = TREE_VALUE (v1);
|
tree c2 = TREE_VALUE (v2);
|
tree c2 = TREE_VALUE (v2);
|
|
|
if (TREE_CODE (c1) == CONST_DECL)
|
if (TREE_CODE (c1) == CONST_DECL)
|
c1 = DECL_INITIAL (c1);
|
c1 = DECL_INITIAL (c1);
|
|
|
if (TREE_CODE (c2) == CONST_DECL)
|
if (TREE_CODE (c2) == CONST_DECL)
|
c2 = DECL_INITIAL (c2);
|
c2 = DECL_INITIAL (c2);
|
|
|
if (tree_int_cst_equal (c1, c2) != 1)
|
if (tree_int_cst_equal (c1, c2) != 1)
|
goto different_types;
|
goto different_types;
|
}
|
}
|
|
|
/* If one enumeration has more values than the other, they
|
/* If one enumeration has more values than the other, they
|
are not the same. */
|
are not the same. */
|
if (v1 || v2)
|
if (v1 || v2)
|
goto different_types;
|
goto different_types;
|
|
|
goto same_types;
|
goto same_types;
|
}
|
}
|
|
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
{
|
{
|
tree f1, f2;
|
tree f1, f2;
|
|
|
/* If one type requires structural equality checks and the
|
/* If one type requires structural equality checks and the
|
other doesn't, do not merge the types. */
|
other doesn't, do not merge the types. */
|
if (TYPE_STRUCTURAL_EQUALITY_P (t1)
|
if (TYPE_STRUCTURAL_EQUALITY_P (t1)
|
!= TYPE_STRUCTURAL_EQUALITY_P (t2))
|
!= TYPE_STRUCTURAL_EQUALITY_P (t2))
|
goto different_types;
|
goto different_types;
|
|
|
/* The struct tags shall compare equal. */
|
/* The struct tags shall compare equal. */
|
if (!compare_type_names_p (TYPE_MAIN_VARIANT (t1),
|
if (!compare_type_names_p (TYPE_MAIN_VARIANT (t1),
|
TYPE_MAIN_VARIANT (t2), false))
|
TYPE_MAIN_VARIANT (t2), false))
|
goto different_types;
|
goto different_types;
|
|
|
/* For aggregate types, all the fields must be the same. */
|
/* For aggregate types, all the fields must be the same. */
|
for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
|
for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2);
|
f1 && f2;
|
f1 && f2;
|
f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
|
f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2))
|
{
|
{
|
/* The fields must have the same name, offset and type. */
|
/* The fields must have the same name, offset and type. */
|
if (DECL_NAME (f1) != DECL_NAME (f2)
|
if (DECL_NAME (f1) != DECL_NAME (f2)
|
|| DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
|
|| DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2)
|
|| !compare_field_offset (f1, f2)
|
|| !compare_field_offset (f1, f2)
|
|| !gimple_types_compatible_p (TREE_TYPE (f1),
|
|| !gimple_types_compatible_p (TREE_TYPE (f1),
|
TREE_TYPE (f2)))
|
TREE_TYPE (f2)))
|
goto different_types;
|
goto different_types;
|
}
|
}
|
|
|
/* If one aggregate has more fields than the other, they
|
/* If one aggregate has more fields than the other, they
|
are not the same. */
|
are not the same. */
|
if (f1 || f2)
|
if (f1 || f2)
|
goto different_types;
|
goto different_types;
|
|
|
goto same_types;
|
goto same_types;
|
}
|
}
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Common exit path for types that are not compatible. */
|
/* Common exit path for types that are not compatible. */
|
different_types:
|
different_types:
|
p->same_p = 0;
|
p->same_p = 0;
|
return 0;
|
return 0;
|
|
|
/* Common exit path for types that are compatible. */
|
/* Common exit path for types that are compatible. */
|
same_types:
|
same_types:
|
p->same_p = 1;
|
p->same_p = 1;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
|
|
|
|
/* Per pointer state for the SCC finding. The on_sccstack flag
|
/* Per pointer state for the SCC finding. The on_sccstack flag
|
is not strictly required, it is true when there is no hash value
|
is not strictly required, it is true when there is no hash value
|
recorded for the type and false otherwise. But querying that
|
recorded for the type and false otherwise. But querying that
|
is slower. */
|
is slower. */
|
|
|
struct sccs
|
struct sccs
|
{
|
{
|
unsigned int dfsnum;
|
unsigned int dfsnum;
|
unsigned int low;
|
unsigned int low;
|
bool on_sccstack;
|
bool on_sccstack;
|
hashval_t hash;
|
hashval_t hash;
|
};
|
};
|
|
|
static unsigned int next_dfs_num;
|
static unsigned int next_dfs_num;
|
|
|
static hashval_t
|
static hashval_t
|
iterative_hash_gimple_type (tree, hashval_t, VEC(tree, heap) **,
|
iterative_hash_gimple_type (tree, hashval_t, VEC(tree, heap) **,
|
struct pointer_map_t *, struct obstack *);
|
struct pointer_map_t *, struct obstack *);
|
|
|
/* DFS visit the edge from the callers type with state *STATE to T.
|
/* DFS visit the edge from the callers type with state *STATE to T.
|
Update the callers type hash V with the hash for T if it is not part
|
Update the callers type hash V with the hash for T if it is not part
|
of the SCC containing the callers type and return it.
|
of the SCC containing the callers type and return it.
|
SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done. */
|
SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done. */
|
|
|
static hashval_t
|
static hashval_t
|
visit (tree t, struct sccs *state, hashval_t v,
|
visit (tree t, struct sccs *state, hashval_t v,
|
VEC (tree, heap) **sccstack,
|
VEC (tree, heap) **sccstack,
|
struct pointer_map_t *sccstate,
|
struct pointer_map_t *sccstate,
|
struct obstack *sccstate_obstack)
|
struct obstack *sccstate_obstack)
|
{
|
{
|
struct sccs *cstate = NULL;
|
struct sccs *cstate = NULL;
|
void **slot;
|
void **slot;
|
|
|
/* If there is a hash value recorded for this type then it can't
|
/* If there is a hash value recorded for this type then it can't
|
possibly be part of our parent SCC. Simply mix in its hash. */
|
possibly be part of our parent SCC. Simply mix in its hash. */
|
if ((slot = pointer_map_contains (type_hash_cache, t)))
|
if ((slot = pointer_map_contains (type_hash_cache, t)))
|
return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, v);
|
return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, v);
|
|
|
if ((slot = pointer_map_contains (sccstate, t)) != NULL)
|
if ((slot = pointer_map_contains (sccstate, t)) != NULL)
|
cstate = (struct sccs *)*slot;
|
cstate = (struct sccs *)*slot;
|
if (!cstate)
|
if (!cstate)
|
{
|
{
|
hashval_t tem;
|
hashval_t tem;
|
/* Not yet visited. DFS recurse. */
|
/* Not yet visited. DFS recurse. */
|
tem = iterative_hash_gimple_type (t, v,
|
tem = iterative_hash_gimple_type (t, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
if (!cstate)
|
if (!cstate)
|
cstate = (struct sccs *)* pointer_map_contains (sccstate, t);
|
cstate = (struct sccs *)* pointer_map_contains (sccstate, t);
|
state->low = MIN (state->low, cstate->low);
|
state->low = MIN (state->low, cstate->low);
|
/* If the type is no longer on the SCC stack and thus is not part
|
/* If the type is no longer on the SCC stack and thus is not part
|
of the parents SCC mix in its hash value. Otherwise we will
|
of the parents SCC mix in its hash value. Otherwise we will
|
ignore the type for hashing purposes and return the unaltered
|
ignore the type for hashing purposes and return the unaltered
|
hash value. */
|
hash value. */
|
if (!cstate->on_sccstack)
|
if (!cstate->on_sccstack)
|
return tem;
|
return tem;
|
}
|
}
|
if (cstate->dfsnum < state->dfsnum
|
if (cstate->dfsnum < state->dfsnum
|
&& cstate->on_sccstack)
|
&& cstate->on_sccstack)
|
state->low = MIN (cstate->dfsnum, state->low);
|
state->low = MIN (cstate->dfsnum, state->low);
|
|
|
/* We are part of our parents SCC, skip this type during hashing
|
/* We are part of our parents SCC, skip this type during hashing
|
and return the unaltered hash value. */
|
and return the unaltered hash value. */
|
return v;
|
return v;
|
}
|
}
|
|
|
/* Hash NAME with the previous hash value V and return it. */
|
/* Hash NAME with the previous hash value V and return it. */
|
|
|
static hashval_t
|
static hashval_t
|
iterative_hash_name (tree name, hashval_t v)
|
iterative_hash_name (tree name, hashval_t v)
|
{
|
{
|
if (!name)
|
if (!name)
|
return v;
|
return v;
|
if (TREE_CODE (name) == TYPE_DECL)
|
if (TREE_CODE (name) == TYPE_DECL)
|
name = DECL_NAME (name);
|
name = DECL_NAME (name);
|
if (!name)
|
if (!name)
|
return v;
|
return v;
|
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
|
gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE);
|
return iterative_hash_object (IDENTIFIER_HASH_VALUE (name), v);
|
return iterative_hash_object (IDENTIFIER_HASH_VALUE (name), v);
|
}
|
}
|
|
|
/* Returning a hash value for gimple type TYPE combined with VAL.
|
/* Returning a hash value for gimple type TYPE combined with VAL.
|
SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.
|
SCCSTACK, SCCSTATE and SCCSTATE_OBSTACK are state for the DFS walk done.
|
|
|
To hash a type we end up hashing in types that are reachable.
|
To hash a type we end up hashing in types that are reachable.
|
Through pointers we can end up with cycles which messes up the
|
Through pointers we can end up with cycles which messes up the
|
required property that we need to compute the same hash value
|
required property that we need to compute the same hash value
|
for structurally equivalent types. To avoid this we have to
|
for structurally equivalent types. To avoid this we have to
|
hash all types in a cycle (the SCC) in a commutative way. The
|
hash all types in a cycle (the SCC) in a commutative way. The
|
easiest way is to not mix in the hashes of the SCC members at
|
easiest way is to not mix in the hashes of the SCC members at
|
all. To make this work we have to delay setting the hash
|
all. To make this work we have to delay setting the hash
|
values of the SCC until it is complete. */
|
values of the SCC until it is complete. */
|
|
|
static hashval_t
|
static hashval_t
|
iterative_hash_gimple_type (tree type, hashval_t val,
|
iterative_hash_gimple_type (tree type, hashval_t val,
|
VEC(tree, heap) **sccstack,
|
VEC(tree, heap) **sccstack,
|
struct pointer_map_t *sccstate,
|
struct pointer_map_t *sccstate,
|
struct obstack *sccstate_obstack)
|
struct obstack *sccstate_obstack)
|
{
|
{
|
hashval_t v;
|
hashval_t v;
|
void **slot;
|
void **slot;
|
struct sccs *state;
|
struct sccs *state;
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
/* Not visited during this DFS walk nor during previous walks. */
|
/* Not visited during this DFS walk nor during previous walks. */
|
gcc_assert (!pointer_map_contains (type_hash_cache, type)
|
gcc_assert (!pointer_map_contains (type_hash_cache, type)
|
&& !pointer_map_contains (sccstate, type));
|
&& !pointer_map_contains (sccstate, type));
|
#endif
|
#endif
|
state = XOBNEW (sccstate_obstack, struct sccs);
|
state = XOBNEW (sccstate_obstack, struct sccs);
|
*pointer_map_insert (sccstate, type) = state;
|
*pointer_map_insert (sccstate, type) = state;
|
|
|
VEC_safe_push (tree, heap, *sccstack, type);
|
VEC_safe_push (tree, heap, *sccstack, type);
|
state->dfsnum = next_dfs_num++;
|
state->dfsnum = next_dfs_num++;
|
state->low = state->dfsnum;
|
state->low = state->dfsnum;
|
state->on_sccstack = true;
|
state->on_sccstack = true;
|
|
|
/* Combine a few common features of types so that types are grouped into
|
/* Combine a few common features of types so that types are grouped into
|
smaller sets; when searching for existing matching types to merge,
|
smaller sets; when searching for existing matching types to merge,
|
only existing types having the same features as the new type will be
|
only existing types having the same features as the new type will be
|
checked. */
|
checked. */
|
v = iterative_hash_hashval_t (TREE_CODE (type), 0);
|
v = iterative_hash_hashval_t (TREE_CODE (type), 0);
|
v = iterative_hash_hashval_t (TYPE_QUALS (type), v);
|
v = iterative_hash_hashval_t (TYPE_QUALS (type), v);
|
v = iterative_hash_hashval_t (TREE_ADDRESSABLE (type), v);
|
v = iterative_hash_hashval_t (TREE_ADDRESSABLE (type), v);
|
|
|
/* Do not hash the types size as this will cause differences in
|
/* Do not hash the types size as this will cause differences in
|
hash values for the complete vs. the incomplete type variant. */
|
hash values for the complete vs. the incomplete type variant. */
|
|
|
/* Incorporate common features of numerical types. */
|
/* Incorporate common features of numerical types. */
|
if (INTEGRAL_TYPE_P (type)
|
if (INTEGRAL_TYPE_P (type)
|
|| SCALAR_FLOAT_TYPE_P (type)
|
|| SCALAR_FLOAT_TYPE_P (type)
|
|| FIXED_POINT_TYPE_P (type))
|
|| FIXED_POINT_TYPE_P (type))
|
{
|
{
|
v = iterative_hash_hashval_t (TYPE_PRECISION (type), v);
|
v = iterative_hash_hashval_t (TYPE_PRECISION (type), v);
|
v = iterative_hash_hashval_t (TYPE_MODE (type), v);
|
v = iterative_hash_hashval_t (TYPE_MODE (type), v);
|
v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
|
v = iterative_hash_hashval_t (TYPE_UNSIGNED (type), v);
|
}
|
}
|
|
|
/* For pointer and reference types, fold in information about the type
|
/* For pointer and reference types, fold in information about the type
|
pointed to but do not recurse into possibly incomplete types to
|
pointed to but do not recurse into possibly incomplete types to
|
avoid hash differences for complete vs. incomplete types. */
|
avoid hash differences for complete vs. incomplete types. */
|
if (POINTER_TYPE_P (type))
|
if (POINTER_TYPE_P (type))
|
{
|
{
|
if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
|
if (RECORD_OR_UNION_TYPE_P (TREE_TYPE (type)))
|
{
|
{
|
v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
|
v = iterative_hash_hashval_t (TREE_CODE (TREE_TYPE (type)), v);
|
v = iterative_hash_name
|
v = iterative_hash_name
|
(TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v);
|
(TYPE_NAME (TYPE_MAIN_VARIANT (TREE_TYPE (type))), v);
|
}
|
}
|
else
|
else
|
v = visit (TREE_TYPE (type), state, v,
|
v = visit (TREE_TYPE (type), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
}
|
}
|
|
|
/* For integer types hash the types min/max values and the string flag. */
|
/* For integer types hash the types min/max values and the string flag. */
|
if (TREE_CODE (type) == INTEGER_TYPE)
|
if (TREE_CODE (type) == INTEGER_TYPE)
|
{
|
{
|
/* OMP lowering can introduce error_mark_node in place of
|
/* OMP lowering can introduce error_mark_node in place of
|
random local decls in types. */
|
random local decls in types. */
|
if (TYPE_MIN_VALUE (type) != error_mark_node)
|
if (TYPE_MIN_VALUE (type) != error_mark_node)
|
v = iterative_hash_expr (TYPE_MIN_VALUE (type), v);
|
v = iterative_hash_expr (TYPE_MIN_VALUE (type), v);
|
if (TYPE_MAX_VALUE (type) != error_mark_node)
|
if (TYPE_MAX_VALUE (type) != error_mark_node)
|
v = iterative_hash_expr (TYPE_MAX_VALUE (type), v);
|
v = iterative_hash_expr (TYPE_MAX_VALUE (type), v);
|
v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
|
v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
|
}
|
}
|
|
|
/* For array types hash their domain and the string flag. */
|
/* For array types hash their domain and the string flag. */
|
if (TREE_CODE (type) == ARRAY_TYPE
|
if (TREE_CODE (type) == ARRAY_TYPE
|
&& TYPE_DOMAIN (type))
|
&& TYPE_DOMAIN (type))
|
{
|
{
|
v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
|
v = iterative_hash_hashval_t (TYPE_STRING_FLAG (type), v);
|
v = visit (TYPE_DOMAIN (type), state, v,
|
v = visit (TYPE_DOMAIN (type), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
}
|
}
|
|
|
/* Recurse for aggregates with a single element type. */
|
/* Recurse for aggregates with a single element type. */
|
if (TREE_CODE (type) == ARRAY_TYPE
|
if (TREE_CODE (type) == ARRAY_TYPE
|
|| TREE_CODE (type) == COMPLEX_TYPE
|
|| TREE_CODE (type) == COMPLEX_TYPE
|
|| TREE_CODE (type) == VECTOR_TYPE)
|
|| TREE_CODE (type) == VECTOR_TYPE)
|
v = visit (TREE_TYPE (type), state, v,
|
v = visit (TREE_TYPE (type), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
|
|
/* Incorporate function return and argument types. */
|
/* Incorporate function return and argument types. */
|
if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
|
if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
|
{
|
{
|
unsigned na;
|
unsigned na;
|
tree p;
|
tree p;
|
|
|
/* For method types also incorporate their parent class. */
|
/* For method types also incorporate their parent class. */
|
if (TREE_CODE (type) == METHOD_TYPE)
|
if (TREE_CODE (type) == METHOD_TYPE)
|
v = visit (TYPE_METHOD_BASETYPE (type), state, v,
|
v = visit (TYPE_METHOD_BASETYPE (type), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
|
|
v = visit (TREE_TYPE (type), state, v,
|
v = visit (TREE_TYPE (type), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
|
|
for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
|
for (p = TYPE_ARG_TYPES (type), na = 0; p; p = TREE_CHAIN (p))
|
{
|
{
|
v = visit (TREE_VALUE (p), state, v,
|
v = visit (TREE_VALUE (p), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
na++;
|
na++;
|
}
|
}
|
|
|
v = iterative_hash_hashval_t (na, v);
|
v = iterative_hash_hashval_t (na, v);
|
}
|
}
|
|
|
if (TREE_CODE (type) == RECORD_TYPE
|
if (TREE_CODE (type) == RECORD_TYPE
|
|| TREE_CODE (type) == UNION_TYPE
|
|| TREE_CODE (type) == UNION_TYPE
|
|| TREE_CODE (type) == QUAL_UNION_TYPE)
|
|| TREE_CODE (type) == QUAL_UNION_TYPE)
|
{
|
{
|
unsigned nf;
|
unsigned nf;
|
tree f;
|
tree f;
|
|
|
v = iterative_hash_name (TYPE_NAME (TYPE_MAIN_VARIANT (type)), v);
|
v = iterative_hash_name (TYPE_NAME (TYPE_MAIN_VARIANT (type)), v);
|
|
|
for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
|
for (f = TYPE_FIELDS (type), nf = 0; f; f = TREE_CHAIN (f))
|
{
|
{
|
v = iterative_hash_name (DECL_NAME (f), v);
|
v = iterative_hash_name (DECL_NAME (f), v);
|
v = visit (TREE_TYPE (f), state, v,
|
v = visit (TREE_TYPE (f), state, v,
|
sccstack, sccstate, sccstate_obstack);
|
sccstack, sccstate, sccstate_obstack);
|
nf++;
|
nf++;
|
}
|
}
|
|
|
v = iterative_hash_hashval_t (nf, v);
|
v = iterative_hash_hashval_t (nf, v);
|
}
|
}
|
|
|
/* Record hash for us. */
|
/* Record hash for us. */
|
state->hash = v;
|
state->hash = v;
|
|
|
/* See if we found an SCC. */
|
/* See if we found an SCC. */
|
if (state->low == state->dfsnum)
|
if (state->low == state->dfsnum)
|
{
|
{
|
tree x;
|
tree x;
|
|
|
/* Pop off the SCC and set its hash values. */
|
/* Pop off the SCC and set its hash values. */
|
do
|
do
|
{
|
{
|
struct sccs *cstate;
|
struct sccs *cstate;
|
x = VEC_pop (tree, *sccstack);
|
x = VEC_pop (tree, *sccstack);
|
gcc_assert (!pointer_map_contains (type_hash_cache, x));
|
gcc_assert (!pointer_map_contains (type_hash_cache, x));
|
cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
|
cstate = (struct sccs *)*pointer_map_contains (sccstate, x);
|
cstate->on_sccstack = false;
|
cstate->on_sccstack = false;
|
slot = pointer_map_insert (type_hash_cache, x);
|
slot = pointer_map_insert (type_hash_cache, x);
|
*slot = (void *) (size_t) cstate->hash;
|
*slot = (void *) (size_t) cstate->hash;
|
}
|
}
|
while (x != type);
|
while (x != type);
|
}
|
}
|
|
|
return iterative_hash_hashval_t (v, val);
|
return iterative_hash_hashval_t (v, val);
|
}
|
}
|
|
|
|
|
/* Returns a hash value for P (assumed to be a type). The hash value
|
/* Returns a hash value for P (assumed to be a type). The hash value
|
is computed using some distinguishing features of the type. Note
|
is computed using some distinguishing features of the type. Note
|
that we cannot use pointer hashing here as we may be dealing with
|
that we cannot use pointer hashing here as we may be dealing with
|
two distinct instances of the same type.
|
two distinct instances of the same type.
|
|
|
This function should produce the same hash value for two compatible
|
This function should produce the same hash value for two compatible
|
types according to gimple_types_compatible_p. */
|
types according to gimple_types_compatible_p. */
|
|
|
static hashval_t
|
static hashval_t
|
gimple_type_hash (const void *p)
|
gimple_type_hash (const void *p)
|
{
|
{
|
const_tree t = (const_tree) p;
|
const_tree t = (const_tree) p;
|
VEC(tree, heap) *sccstack = NULL;
|
VEC(tree, heap) *sccstack = NULL;
|
struct pointer_map_t *sccstate;
|
struct pointer_map_t *sccstate;
|
struct obstack sccstate_obstack;
|
struct obstack sccstate_obstack;
|
hashval_t val;
|
hashval_t val;
|
void **slot;
|
void **slot;
|
|
|
if (type_hash_cache == NULL)
|
if (type_hash_cache == NULL)
|
type_hash_cache = pointer_map_create ();
|
type_hash_cache = pointer_map_create ();
|
|
|
if ((slot = pointer_map_contains (type_hash_cache, p)) != NULL)
|
if ((slot = pointer_map_contains (type_hash_cache, p)) != NULL)
|
return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, 0);
|
return iterative_hash_hashval_t ((hashval_t) (size_t) *slot, 0);
|
|
|
/* Perform a DFS walk and pre-hash all reachable types. */
|
/* Perform a DFS walk and pre-hash all reachable types. */
|
next_dfs_num = 1;
|
next_dfs_num = 1;
|
sccstate = pointer_map_create ();
|
sccstate = pointer_map_create ();
|
gcc_obstack_init (&sccstate_obstack);
|
gcc_obstack_init (&sccstate_obstack);
|
val = iterative_hash_gimple_type (CONST_CAST_TREE (t), 0,
|
val = iterative_hash_gimple_type (CONST_CAST_TREE (t), 0,
|
&sccstack, sccstate, &sccstate_obstack);
|
&sccstack, sccstate, &sccstate_obstack);
|
VEC_free (tree, heap, sccstack);
|
VEC_free (tree, heap, sccstack);
|
pointer_map_destroy (sccstate);
|
pointer_map_destroy (sccstate);
|
obstack_free (&sccstate_obstack, NULL);
|
obstack_free (&sccstate_obstack, NULL);
|
|
|
return val;
|
return val;
|
}
|
}
|
|
|
|
|
/* Returns nonzero if P1 and P2 are equal. */
|
/* Returns nonzero if P1 and P2 are equal. */
|
|
|
static int
|
static int
|
gimple_type_eq (const void *p1, const void *p2)
|
gimple_type_eq (const void *p1, const void *p2)
|
{
|
{
|
const_tree t1 = (const_tree) p1;
|
const_tree t1 = (const_tree) p1;
|
const_tree t2 = (const_tree) p2;
|
const_tree t2 = (const_tree) p2;
|
return gimple_types_compatible_p (CONST_CAST_TREE (t1), CONST_CAST_TREE (t2));
|
return gimple_types_compatible_p (CONST_CAST_TREE (t1), CONST_CAST_TREE (t2));
|
}
|
}
|
|
|
|
|
/* Register type T in the global type table gimple_types.
|
/* Register type T in the global type table gimple_types.
|
If another type T', compatible with T, already existed in
|
If another type T', compatible with T, already existed in
|
gimple_types then return T', otherwise return T. This is used by
|
gimple_types then return T', otherwise return T. This is used by
|
LTO to merge identical types read from different TUs. */
|
LTO to merge identical types read from different TUs. */
|
|
|
tree
|
tree
|
gimple_register_type (tree t)
|
gimple_register_type (tree t)
|
{
|
{
|
void **slot;
|
void **slot;
|
|
|
gcc_assert (TYPE_P (t));
|
gcc_assert (TYPE_P (t));
|
|
|
/* Always register the main variant first. This is important so we
|
/* Always register the main variant first. This is important so we
|
pick up the non-typedef variants as canonical, otherwise we'll end
|
pick up the non-typedef variants as canonical, otherwise we'll end
|
up taking typedef ids for structure tags during comparison. */
|
up taking typedef ids for structure tags during comparison. */
|
if (TYPE_MAIN_VARIANT (t) != t)
|
if (TYPE_MAIN_VARIANT (t) != t)
|
gimple_register_type (TYPE_MAIN_VARIANT (t));
|
gimple_register_type (TYPE_MAIN_VARIANT (t));
|
|
|
if (gimple_types == NULL)
|
if (gimple_types == NULL)
|
gimple_types = htab_create (16381, gimple_type_hash, gimple_type_eq, 0);
|
gimple_types = htab_create (16381, gimple_type_hash, gimple_type_eq, 0);
|
|
|
slot = htab_find_slot (gimple_types, t, INSERT);
|
slot = htab_find_slot (gimple_types, t, INSERT);
|
if (*slot
|
if (*slot
|
&& *(tree *)slot != t)
|
&& *(tree *)slot != t)
|
{
|
{
|
tree new_type = (tree) *((tree *) slot);
|
tree new_type = (tree) *((tree *) slot);
|
|
|
/* Do not merge types with different addressability. */
|
/* Do not merge types with different addressability. */
|
gcc_assert (TREE_ADDRESSABLE (t) == TREE_ADDRESSABLE (new_type));
|
gcc_assert (TREE_ADDRESSABLE (t) == TREE_ADDRESSABLE (new_type));
|
|
|
/* If t is not its main variant then make t unreachable from its
|
/* If t is not its main variant then make t unreachable from its
|
main variant list. Otherwise we'd queue up a lot of duplicates
|
main variant list. Otherwise we'd queue up a lot of duplicates
|
there. */
|
there. */
|
if (t != TYPE_MAIN_VARIANT (t))
|
if (t != TYPE_MAIN_VARIANT (t))
|
{
|
{
|
tree tem = TYPE_MAIN_VARIANT (t);
|
tree tem = TYPE_MAIN_VARIANT (t);
|
while (tem && TYPE_NEXT_VARIANT (tem) != t)
|
while (tem && TYPE_NEXT_VARIANT (tem) != t)
|
tem = TYPE_NEXT_VARIANT (tem);
|
tem = TYPE_NEXT_VARIANT (tem);
|
if (tem)
|
if (tem)
|
TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
|
TYPE_NEXT_VARIANT (tem) = TYPE_NEXT_VARIANT (t);
|
TYPE_NEXT_VARIANT (t) = NULL_TREE;
|
TYPE_NEXT_VARIANT (t) = NULL_TREE;
|
}
|
}
|
|
|
/* If we are a pointer then remove us from the pointer-to or
|
/* If we are a pointer then remove us from the pointer-to or
|
reference-to chain. Otherwise we'd queue up a lot of duplicates
|
reference-to chain. Otherwise we'd queue up a lot of duplicates
|
there. */
|
there. */
|
if (TREE_CODE (t) == POINTER_TYPE)
|
if (TREE_CODE (t) == POINTER_TYPE)
|
{
|
{
|
if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
|
if (TYPE_POINTER_TO (TREE_TYPE (t)) == t)
|
TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
|
TYPE_POINTER_TO (TREE_TYPE (t)) = TYPE_NEXT_PTR_TO (t);
|
else
|
else
|
{
|
{
|
tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
|
tree tem = TYPE_POINTER_TO (TREE_TYPE (t));
|
while (tem && TYPE_NEXT_PTR_TO (tem) != t)
|
while (tem && TYPE_NEXT_PTR_TO (tem) != t)
|
tem = TYPE_NEXT_PTR_TO (tem);
|
tem = TYPE_NEXT_PTR_TO (tem);
|
if (tem)
|
if (tem)
|
TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
|
TYPE_NEXT_PTR_TO (tem) = TYPE_NEXT_PTR_TO (t);
|
}
|
}
|
TYPE_NEXT_PTR_TO (t) = NULL_TREE;
|
TYPE_NEXT_PTR_TO (t) = NULL_TREE;
|
}
|
}
|
else if (TREE_CODE (t) == REFERENCE_TYPE)
|
else if (TREE_CODE (t) == REFERENCE_TYPE)
|
{
|
{
|
if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
|
if (TYPE_REFERENCE_TO (TREE_TYPE (t)) == t)
|
TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
|
TYPE_REFERENCE_TO (TREE_TYPE (t)) = TYPE_NEXT_REF_TO (t);
|
else
|
else
|
{
|
{
|
tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
|
tree tem = TYPE_REFERENCE_TO (TREE_TYPE (t));
|
while (tem && TYPE_NEXT_REF_TO (tem) != t)
|
while (tem && TYPE_NEXT_REF_TO (tem) != t)
|
tem = TYPE_NEXT_REF_TO (tem);
|
tem = TYPE_NEXT_REF_TO (tem);
|
if (tem)
|
if (tem)
|
TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
|
TYPE_NEXT_REF_TO (tem) = TYPE_NEXT_REF_TO (t);
|
}
|
}
|
TYPE_NEXT_REF_TO (t) = NULL_TREE;
|
TYPE_NEXT_REF_TO (t) = NULL_TREE;
|
}
|
}
|
|
|
t = new_type;
|
t = new_type;
|
}
|
}
|
else
|
else
|
*slot = (void *) t;
|
*slot = (void *) t;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Show statistics on references to the global type table gimple_types. */
|
/* Show statistics on references to the global type table gimple_types. */
|
|
|
void
|
void
|
print_gimple_types_stats (void)
|
print_gimple_types_stats (void)
|
{
|
{
|
if (gimple_types)
|
if (gimple_types)
|
fprintf (stderr, "GIMPLE type table: size %ld, %ld elements, "
|
fprintf (stderr, "GIMPLE type table: size %ld, %ld elements, "
|
"%ld searches, %ld collisions (ratio: %f)\n",
|
"%ld searches, %ld collisions (ratio: %f)\n",
|
(long) htab_size (gimple_types),
|
(long) htab_size (gimple_types),
|
(long) htab_elements (gimple_types),
|
(long) htab_elements (gimple_types),
|
(long) gimple_types->searches,
|
(long) gimple_types->searches,
|
(long) gimple_types->collisions,
|
(long) gimple_types->collisions,
|
htab_collisions (gimple_types));
|
htab_collisions (gimple_types));
|
else
|
else
|
fprintf (stderr, "GIMPLE type table is empty\n");
|
fprintf (stderr, "GIMPLE type table is empty\n");
|
if (gtc_visited)
|
if (gtc_visited)
|
fprintf (stderr, "GIMPLE type comparison table: size %ld, %ld "
|
fprintf (stderr, "GIMPLE type comparison table: size %ld, %ld "
|
"elements, %ld searches, %ld collisions (ratio: %f)\n",
|
"elements, %ld searches, %ld collisions (ratio: %f)\n",
|
(long) htab_size (gtc_visited),
|
(long) htab_size (gtc_visited),
|
(long) htab_elements (gtc_visited),
|
(long) htab_elements (gtc_visited),
|
(long) gtc_visited->searches,
|
(long) gtc_visited->searches,
|
(long) gtc_visited->collisions,
|
(long) gtc_visited->collisions,
|
htab_collisions (gtc_visited));
|
htab_collisions (gtc_visited));
|
else
|
else
|
fprintf (stderr, "GIMPLE type comparison table is empty\n");
|
fprintf (stderr, "GIMPLE type comparison table is empty\n");
|
}
|
}
|
|
|
/* Free the gimple type hashtables used for LTO type merging. */
|
/* Free the gimple type hashtables used for LTO type merging. */
|
|
|
void
|
void
|
free_gimple_type_tables (void)
|
free_gimple_type_tables (void)
|
{
|
{
|
/* Last chance to print stats for the tables. */
|
/* Last chance to print stats for the tables. */
|
if (flag_lto_report)
|
if (flag_lto_report)
|
print_gimple_types_stats ();
|
print_gimple_types_stats ();
|
|
|
if (gimple_types)
|
if (gimple_types)
|
{
|
{
|
htab_delete (gimple_types);
|
htab_delete (gimple_types);
|
gimple_types = NULL;
|
gimple_types = NULL;
|
}
|
}
|
if (type_hash_cache)
|
if (type_hash_cache)
|
{
|
{
|
pointer_map_destroy (type_hash_cache);
|
pointer_map_destroy (type_hash_cache);
|
type_hash_cache = NULL;
|
type_hash_cache = NULL;
|
}
|
}
|
if (gtc_visited)
|
if (gtc_visited)
|
{
|
{
|
htab_delete (gtc_visited);
|
htab_delete (gtc_visited);
|
obstack_free (>c_ob, NULL);
|
obstack_free (>c_ob, NULL);
|
gtc_visited = NULL;
|
gtc_visited = NULL;
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Return a type the same as TYPE except unsigned or
|
/* Return a type the same as TYPE except unsigned or
|
signed according to UNSIGNEDP. */
|
signed according to UNSIGNEDP. */
|
|
|
static tree
|
static tree
|
gimple_signed_or_unsigned_type (bool unsignedp, tree type)
|
gimple_signed_or_unsigned_type (bool unsignedp, tree type)
|
{
|
{
|
tree type1;
|
tree type1;
|
|
|
type1 = TYPE_MAIN_VARIANT (type);
|
type1 = TYPE_MAIN_VARIANT (type);
|
if (type1 == signed_char_type_node
|
if (type1 == signed_char_type_node
|
|| type1 == char_type_node
|
|| type1 == char_type_node
|
|| type1 == unsigned_char_type_node)
|
|| type1 == unsigned_char_type_node)
|
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
|
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
|
if (type1 == integer_type_node || type1 == unsigned_type_node)
|
if (type1 == integer_type_node || type1 == unsigned_type_node)
|
return unsignedp ? unsigned_type_node : integer_type_node;
|
return unsignedp ? unsigned_type_node : integer_type_node;
|
if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
|
if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
|
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
|
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
|
if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
|
if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
|
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
if (type1 == long_long_integer_type_node
|
if (type1 == long_long_integer_type_node
|
|| type1 == long_long_unsigned_type_node)
|
|| type1 == long_long_unsigned_type_node)
|
return unsignedp
|
return unsignedp
|
? long_long_unsigned_type_node
|
? long_long_unsigned_type_node
|
: long_long_integer_type_node;
|
: long_long_integer_type_node;
|
#if HOST_BITS_PER_WIDE_INT >= 64
|
#if HOST_BITS_PER_WIDE_INT >= 64
|
if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
|
if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
|
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
|
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
|
#endif
|
#endif
|
if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
|
if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
|
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
|
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
|
if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
|
if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
|
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
|
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
|
if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
|
if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
|
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
|
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
|
if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
|
if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
|
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
|
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
|
|
|
#define GIMPLE_FIXED_TYPES(NAME) \
|
#define GIMPLE_FIXED_TYPES(NAME) \
|
if (type1 == short_ ## NAME ## _type_node \
|
if (type1 == short_ ## NAME ## _type_node \
|
|| type1 == unsigned_short_ ## NAME ## _type_node) \
|
|| type1 == unsigned_short_ ## NAME ## _type_node) \
|
return unsignedp ? unsigned_short_ ## NAME ## _type_node \
|
return unsignedp ? unsigned_short_ ## NAME ## _type_node \
|
: short_ ## NAME ## _type_node; \
|
: short_ ## NAME ## _type_node; \
|
if (type1 == NAME ## _type_node \
|
if (type1 == NAME ## _type_node \
|
|| type1 == unsigned_ ## NAME ## _type_node) \
|
|| type1 == unsigned_ ## NAME ## _type_node) \
|
return unsignedp ? unsigned_ ## NAME ## _type_node \
|
return unsignedp ? unsigned_ ## NAME ## _type_node \
|
: NAME ## _type_node; \
|
: NAME ## _type_node; \
|
if (type1 == long_ ## NAME ## _type_node \
|
if (type1 == long_ ## NAME ## _type_node \
|
|| type1 == unsigned_long_ ## NAME ## _type_node) \
|
|| type1 == unsigned_long_ ## NAME ## _type_node) \
|
return unsignedp ? unsigned_long_ ## NAME ## _type_node \
|
return unsignedp ? unsigned_long_ ## NAME ## _type_node \
|
: long_ ## NAME ## _type_node; \
|
: long_ ## NAME ## _type_node; \
|
if (type1 == long_long_ ## NAME ## _type_node \
|
if (type1 == long_long_ ## NAME ## _type_node \
|
|| type1 == unsigned_long_long_ ## NAME ## _type_node) \
|
|| type1 == unsigned_long_long_ ## NAME ## _type_node) \
|
return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
|
return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
|
: long_long_ ## NAME ## _type_node;
|
: long_long_ ## NAME ## _type_node;
|
|
|
#define GIMPLE_FIXED_MODE_TYPES(NAME) \
|
#define GIMPLE_FIXED_MODE_TYPES(NAME) \
|
if (type1 == NAME ## _type_node \
|
if (type1 == NAME ## _type_node \
|
|| type1 == u ## NAME ## _type_node) \
|
|| type1 == u ## NAME ## _type_node) \
|
return unsignedp ? u ## NAME ## _type_node \
|
return unsignedp ? u ## NAME ## _type_node \
|
: NAME ## _type_node;
|
: NAME ## _type_node;
|
|
|
#define GIMPLE_FIXED_TYPES_SAT(NAME) \
|
#define GIMPLE_FIXED_TYPES_SAT(NAME) \
|
if (type1 == sat_ ## short_ ## NAME ## _type_node \
|
if (type1 == sat_ ## short_ ## NAME ## _type_node \
|
|| type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
|
|| type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
|
return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
|
return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
|
: sat_ ## short_ ## NAME ## _type_node; \
|
: sat_ ## short_ ## NAME ## _type_node; \
|
if (type1 == sat_ ## NAME ## _type_node \
|
if (type1 == sat_ ## NAME ## _type_node \
|
|| type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
|
|| type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
|
return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
|
return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
|
: sat_ ## NAME ## _type_node; \
|
: sat_ ## NAME ## _type_node; \
|
if (type1 == sat_ ## long_ ## NAME ## _type_node \
|
if (type1 == sat_ ## long_ ## NAME ## _type_node \
|
|| type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
|
|| type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
|
return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
|
return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
|
: sat_ ## long_ ## NAME ## _type_node; \
|
: sat_ ## long_ ## NAME ## _type_node; \
|
if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
|
if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
|
|| type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
|
|| type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
|
return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
|
return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
|
: sat_ ## long_long_ ## NAME ## _type_node;
|
: sat_ ## long_long_ ## NAME ## _type_node;
|
|
|
#define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
|
#define GIMPLE_FIXED_MODE_TYPES_SAT(NAME) \
|
if (type1 == sat_ ## NAME ## _type_node \
|
if (type1 == sat_ ## NAME ## _type_node \
|
|| type1 == sat_ ## u ## NAME ## _type_node) \
|
|| type1 == sat_ ## u ## NAME ## _type_node) \
|
return unsignedp ? sat_ ## u ## NAME ## _type_node \
|
return unsignedp ? sat_ ## u ## NAME ## _type_node \
|
: sat_ ## NAME ## _type_node;
|
: sat_ ## NAME ## _type_node;
|
|
|
GIMPLE_FIXED_TYPES (fract);
|
GIMPLE_FIXED_TYPES (fract);
|
GIMPLE_FIXED_TYPES_SAT (fract);
|
GIMPLE_FIXED_TYPES_SAT (fract);
|
GIMPLE_FIXED_TYPES (accum);
|
GIMPLE_FIXED_TYPES (accum);
|
GIMPLE_FIXED_TYPES_SAT (accum);
|
GIMPLE_FIXED_TYPES_SAT (accum);
|
|
|
GIMPLE_FIXED_MODE_TYPES (qq);
|
GIMPLE_FIXED_MODE_TYPES (qq);
|
GIMPLE_FIXED_MODE_TYPES (hq);
|
GIMPLE_FIXED_MODE_TYPES (hq);
|
GIMPLE_FIXED_MODE_TYPES (sq);
|
GIMPLE_FIXED_MODE_TYPES (sq);
|
GIMPLE_FIXED_MODE_TYPES (dq);
|
GIMPLE_FIXED_MODE_TYPES (dq);
|
GIMPLE_FIXED_MODE_TYPES (tq);
|
GIMPLE_FIXED_MODE_TYPES (tq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (qq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (qq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (hq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (hq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (sq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (sq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (dq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (dq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (tq);
|
GIMPLE_FIXED_MODE_TYPES_SAT (tq);
|
GIMPLE_FIXED_MODE_TYPES (ha);
|
GIMPLE_FIXED_MODE_TYPES (ha);
|
GIMPLE_FIXED_MODE_TYPES (sa);
|
GIMPLE_FIXED_MODE_TYPES (sa);
|
GIMPLE_FIXED_MODE_TYPES (da);
|
GIMPLE_FIXED_MODE_TYPES (da);
|
GIMPLE_FIXED_MODE_TYPES (ta);
|
GIMPLE_FIXED_MODE_TYPES (ta);
|
GIMPLE_FIXED_MODE_TYPES_SAT (ha);
|
GIMPLE_FIXED_MODE_TYPES_SAT (ha);
|
GIMPLE_FIXED_MODE_TYPES_SAT (sa);
|
GIMPLE_FIXED_MODE_TYPES_SAT (sa);
|
GIMPLE_FIXED_MODE_TYPES_SAT (da);
|
GIMPLE_FIXED_MODE_TYPES_SAT (da);
|
GIMPLE_FIXED_MODE_TYPES_SAT (ta);
|
GIMPLE_FIXED_MODE_TYPES_SAT (ta);
|
|
|
/* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
|
/* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
|
the precision; they have precision set to match their range, but
|
the precision; they have precision set to match their range, but
|
may use a wider mode to match an ABI. If we change modes, we may
|
may use a wider mode to match an ABI. If we change modes, we may
|
wind up with bad conversions. For INTEGER_TYPEs in C, must check
|
wind up with bad conversions. For INTEGER_TYPEs in C, must check
|
the precision as well, so as to yield correct results for
|
the precision as well, so as to yield correct results for
|
bit-field types. C++ does not have these separate bit-field
|
bit-field types. C++ does not have these separate bit-field
|
types, and producing a signed or unsigned variant of an
|
types, and producing a signed or unsigned variant of an
|
ENUMERAL_TYPE may cause other problems as well. */
|
ENUMERAL_TYPE may cause other problems as well. */
|
if (!INTEGRAL_TYPE_P (type)
|
if (!INTEGRAL_TYPE_P (type)
|
|| TYPE_UNSIGNED (type) == unsignedp)
|
|| TYPE_UNSIGNED (type) == unsignedp)
|
return type;
|
return type;
|
|
|
#define TYPE_OK(node) \
|
#define TYPE_OK(node) \
|
(TYPE_MODE (type) == TYPE_MODE (node) \
|
(TYPE_MODE (type) == TYPE_MODE (node) \
|
&& TYPE_PRECISION (type) == TYPE_PRECISION (node))
|
&& TYPE_PRECISION (type) == TYPE_PRECISION (node))
|
if (TYPE_OK (signed_char_type_node))
|
if (TYPE_OK (signed_char_type_node))
|
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
|
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
|
if (TYPE_OK (integer_type_node))
|
if (TYPE_OK (integer_type_node))
|
return unsignedp ? unsigned_type_node : integer_type_node;
|
return unsignedp ? unsigned_type_node : integer_type_node;
|
if (TYPE_OK (short_integer_type_node))
|
if (TYPE_OK (short_integer_type_node))
|
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
|
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
|
if (TYPE_OK (long_integer_type_node))
|
if (TYPE_OK (long_integer_type_node))
|
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
if (TYPE_OK (long_long_integer_type_node))
|
if (TYPE_OK (long_long_integer_type_node))
|
return (unsignedp
|
return (unsignedp
|
? long_long_unsigned_type_node
|
? long_long_unsigned_type_node
|
: long_long_integer_type_node);
|
: long_long_integer_type_node);
|
|
|
#if HOST_BITS_PER_WIDE_INT >= 64
|
#if HOST_BITS_PER_WIDE_INT >= 64
|
if (TYPE_OK (intTI_type_node))
|
if (TYPE_OK (intTI_type_node))
|
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
|
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
|
#endif
|
#endif
|
if (TYPE_OK (intDI_type_node))
|
if (TYPE_OK (intDI_type_node))
|
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
|
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
|
if (TYPE_OK (intSI_type_node))
|
if (TYPE_OK (intSI_type_node))
|
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
|
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
|
if (TYPE_OK (intHI_type_node))
|
if (TYPE_OK (intHI_type_node))
|
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
|
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
|
if (TYPE_OK (intQI_type_node))
|
if (TYPE_OK (intQI_type_node))
|
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
|
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
|
|
|
#undef GIMPLE_FIXED_TYPES
|
#undef GIMPLE_FIXED_TYPES
|
#undef GIMPLE_FIXED_MODE_TYPES
|
#undef GIMPLE_FIXED_MODE_TYPES
|
#undef GIMPLE_FIXED_TYPES_SAT
|
#undef GIMPLE_FIXED_TYPES_SAT
|
#undef GIMPLE_FIXED_MODE_TYPES_SAT
|
#undef GIMPLE_FIXED_MODE_TYPES_SAT
|
#undef TYPE_OK
|
#undef TYPE_OK
|
|
|
return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
|
return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
|
}
|
}
|
|
|
|
|
/* Return an unsigned type the same as TYPE in other respects. */
|
/* Return an unsigned type the same as TYPE in other respects. */
|
|
|
tree
|
tree
|
gimple_unsigned_type (tree type)
|
gimple_unsigned_type (tree type)
|
{
|
{
|
return gimple_signed_or_unsigned_type (true, type);
|
return gimple_signed_or_unsigned_type (true, type);
|
}
|
}
|
|
|
|
|
/* Return a signed type the same as TYPE in other respects. */
|
/* Return a signed type the same as TYPE in other respects. */
|
|
|
tree
|
tree
|
gimple_signed_type (tree type)
|
gimple_signed_type (tree type)
|
{
|
{
|
return gimple_signed_or_unsigned_type (false, type);
|
return gimple_signed_or_unsigned_type (false, type);
|
}
|
}
|
|
|
|
|
/* Return the typed-based alias set for T, which may be an expression
|
/* Return the typed-based alias set for T, which may be an expression
|
or a type. Return -1 if we don't do anything special. */
|
or a type. Return -1 if we don't do anything special. */
|
|
|
alias_set_type
|
alias_set_type
|
gimple_get_alias_set (tree t)
|
gimple_get_alias_set (tree t)
|
{
|
{
|
tree u;
|
tree u;
|
|
|
/* Permit type-punning when accessing a union, provided the access
|
/* Permit type-punning when accessing a union, provided the access
|
is directly through the union. For example, this code does not
|
is directly through the union. For example, this code does not
|
permit taking the address of a union member and then storing
|
permit taking the address of a union member and then storing
|
through it. Even the type-punning allowed here is a GCC
|
through it. Even the type-punning allowed here is a GCC
|
extension, albeit a common and useful one; the C standard says
|
extension, albeit a common and useful one; the C standard says
|
that such accesses have implementation-defined behavior. */
|
that such accesses have implementation-defined behavior. */
|
for (u = t;
|
for (u = t;
|
TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
|
TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
|
u = TREE_OPERAND (u, 0))
|
u = TREE_OPERAND (u, 0))
|
if (TREE_CODE (u) == COMPONENT_REF
|
if (TREE_CODE (u) == COMPONENT_REF
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
|
return 0;
|
return 0;
|
|
|
/* That's all the expressions we handle specially. */
|
/* That's all the expressions we handle specially. */
|
if (!TYPE_P (t))
|
if (!TYPE_P (t))
|
return -1;
|
return -1;
|
|
|
/* For convenience, follow the C standard when dealing with
|
/* For convenience, follow the C standard when dealing with
|
character types. Any object may be accessed via an lvalue that
|
character types. Any object may be accessed via an lvalue that
|
has character type. */
|
has character type. */
|
if (t == char_type_node
|
if (t == char_type_node
|
|| t == signed_char_type_node
|
|| t == signed_char_type_node
|
|| t == unsigned_char_type_node)
|
|| t == unsigned_char_type_node)
|
return 0;
|
return 0;
|
|
|
/* Allow aliasing between signed and unsigned variants of the same
|
/* Allow aliasing between signed and unsigned variants of the same
|
type. We treat the signed variant as canonical. */
|
type. We treat the signed variant as canonical. */
|
if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
|
if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
|
{
|
{
|
tree t1 = gimple_signed_type (t);
|
tree t1 = gimple_signed_type (t);
|
|
|
/* t1 == t can happen for boolean nodes which are always unsigned. */
|
/* t1 == t can happen for boolean nodes which are always unsigned. */
|
if (t1 != t)
|
if (t1 != t)
|
return get_alias_set (t1);
|
return get_alias_set (t1);
|
}
|
}
|
else if (POINTER_TYPE_P (t))
|
else if (POINTER_TYPE_P (t))
|
{
|
{
|
/* From the common C and C++ langhook implementation:
|
/* From the common C and C++ langhook implementation:
|
|
|
Unfortunately, there is no canonical form of a pointer type.
|
Unfortunately, there is no canonical form of a pointer type.
|
In particular, if we have `typedef int I', then `int *', and
|
In particular, if we have `typedef int I', then `int *', and
|
`I *' are different types. So, we have to pick a canonical
|
`I *' are different types. So, we have to pick a canonical
|
representative. We do this below.
|
representative. We do this below.
|
|
|
Technically, this approach is actually more conservative that
|
Technically, this approach is actually more conservative that
|
it needs to be. In particular, `const int *' and `int *'
|
it needs to be. In particular, `const int *' and `int *'
|
should be in different alias sets, according to the C and C++
|
should be in different alias sets, according to the C and C++
|
standard, since their types are not the same, and so,
|
standard, since their types are not the same, and so,
|
technically, an `int **' and `const int **' cannot point at
|
technically, an `int **' and `const int **' cannot point at
|
the same thing.
|
the same thing.
|
|
|
But, the standard is wrong. In particular, this code is
|
But, the standard is wrong. In particular, this code is
|
legal C++:
|
legal C++:
|
|
|
int *ip;
|
int *ip;
|
int **ipp = &ip;
|
int **ipp = &ip;
|
const int* const* cipp = ipp;
|
const int* const* cipp = ipp;
|
And, it doesn't make sense for that to be legal unless you
|
And, it doesn't make sense for that to be legal unless you
|
can dereference IPP and CIPP. So, we ignore cv-qualifiers on
|
can dereference IPP and CIPP. So, we ignore cv-qualifiers on
|
the pointed-to types. This issue has been reported to the
|
the pointed-to types. This issue has been reported to the
|
C++ committee. */
|
C++ committee. */
|
|
|
/* In addition to the above canonicalization issue with LTO
|
/* In addition to the above canonicalization issue with LTO
|
we should also canonicalize `T (*)[]' to `T *' avoiding
|
we should also canonicalize `T (*)[]' to `T *' avoiding
|
alias issues with pointer-to element types and pointer-to
|
alias issues with pointer-to element types and pointer-to
|
array types.
|
array types.
|
|
|
Likewise we need to deal with the situation of incomplete
|
Likewise we need to deal with the situation of incomplete
|
pointed-to types and make `*(struct X **)&a' and
|
pointed-to types and make `*(struct X **)&a' and
|
`*(struct X {} **)&a' alias. Otherwise we will have to
|
`*(struct X {} **)&a' alias. Otherwise we will have to
|
guarantee that all pointer-to incomplete type variants
|
guarantee that all pointer-to incomplete type variants
|
will be replaced by pointer-to complete type variants if
|
will be replaced by pointer-to complete type variants if
|
they are available.
|
they are available.
|
|
|
With LTO the convenient situation of using `void *' to
|
With LTO the convenient situation of using `void *' to
|
access and store any pointer type will also become
|
access and store any pointer type will also become
|
more apparent (and `void *' is just another pointer-to
|
more apparent (and `void *' is just another pointer-to
|
incomplete type). Assigning alias-set zero to `void *'
|
incomplete type). Assigning alias-set zero to `void *'
|
and all pointer-to incomplete types is a not appealing
|
and all pointer-to incomplete types is a not appealing
|
solution. Assigning an effective alias-set zero only
|
solution. Assigning an effective alias-set zero only
|
affecting pointers might be - by recording proper subset
|
affecting pointers might be - by recording proper subset
|
relationships of all pointer alias-sets.
|
relationships of all pointer alias-sets.
|
|
|
Pointer-to function types are another grey area which
|
Pointer-to function types are another grey area which
|
needs caution. Globbing them all into one alias-set
|
needs caution. Globbing them all into one alias-set
|
or the above effective zero set would work. */
|
or the above effective zero set would work. */
|
|
|
/* For now just assign the same alias-set to all pointers.
|
/* For now just assign the same alias-set to all pointers.
|
That's simple and avoids all the above problems. */
|
That's simple and avoids all the above problems. */
|
if (t != ptr_type_node)
|
if (t != ptr_type_node)
|
return get_alias_set (ptr_type_node);
|
return get_alias_set (ptr_type_node);
|
}
|
}
|
|
|
return -1;
|
return -1;
|
}
|
}
|
|
|
|
|
/* Data structure used to count the number of dereferences to PTR
|
/* Data structure used to count the number of dereferences to PTR
|
inside an expression. */
|
inside an expression. */
|
struct count_ptr_d
|
struct count_ptr_d
|
{
|
{
|
tree ptr;
|
tree ptr;
|
unsigned num_stores;
|
unsigned num_stores;
|
unsigned num_loads;
|
unsigned num_loads;
|
};
|
};
|
|
|
/* Helper for count_uses_and_derefs. Called by walk_tree to look for
|
/* Helper for count_uses_and_derefs. Called by walk_tree to look for
|
(ALIGN/MISALIGNED_)INDIRECT_REF nodes for the pointer passed in DATA. */
|
(ALIGN/MISALIGNED_)INDIRECT_REF nodes for the pointer passed in DATA. */
|
|
|
static tree
|
static tree
|
count_ptr_derefs (tree *tp, int *walk_subtrees, void *data)
|
count_ptr_derefs (tree *tp, int *walk_subtrees, void *data)
|
{
|
{
|
struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
|
struct walk_stmt_info *wi_p = (struct walk_stmt_info *) data;
|
struct count_ptr_d *count_p = (struct count_ptr_d *) wi_p->info;
|
struct count_ptr_d *count_p = (struct count_ptr_d *) wi_p->info;
|
|
|
/* Do not walk inside ADDR_EXPR nodes. In the expression &ptr->fld,
|
/* Do not walk inside ADDR_EXPR nodes. In the expression &ptr->fld,
|
pointer 'ptr' is *not* dereferenced, it is simply used to compute
|
pointer 'ptr' is *not* dereferenced, it is simply used to compute
|
the address of 'fld' as 'ptr + offsetof(fld)'. */
|
the address of 'fld' as 'ptr + offsetof(fld)'. */
|
if (TREE_CODE (*tp) == ADDR_EXPR)
|
if (TREE_CODE (*tp) == ADDR_EXPR)
|
{
|
{
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
if (INDIRECT_REF_P (*tp) && TREE_OPERAND (*tp, 0) == count_p->ptr)
|
if (INDIRECT_REF_P (*tp) && TREE_OPERAND (*tp, 0) == count_p->ptr)
|
{
|
{
|
if (wi_p->is_lhs)
|
if (wi_p->is_lhs)
|
count_p->num_stores++;
|
count_p->num_stores++;
|
else
|
else
|
count_p->num_loads++;
|
count_p->num_loads++;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Count the number of direct and indirect uses for pointer PTR in
|
/* Count the number of direct and indirect uses for pointer PTR in
|
statement STMT. The number of direct uses is stored in
|
statement STMT. The number of direct uses is stored in
|
*NUM_USES_P. Indirect references are counted separately depending
|
*NUM_USES_P. Indirect references are counted separately depending
|
on whether they are store or load operations. The counts are
|
on whether they are store or load operations. The counts are
|
stored in *NUM_STORES_P and *NUM_LOADS_P. */
|
stored in *NUM_STORES_P and *NUM_LOADS_P. */
|
|
|
void
|
void
|
count_uses_and_derefs (tree ptr, gimple stmt, unsigned *num_uses_p,
|
count_uses_and_derefs (tree ptr, gimple stmt, unsigned *num_uses_p,
|
unsigned *num_loads_p, unsigned *num_stores_p)
|
unsigned *num_loads_p, unsigned *num_stores_p)
|
{
|
{
|
ssa_op_iter i;
|
ssa_op_iter i;
|
tree use;
|
tree use;
|
|
|
*num_uses_p = 0;
|
*num_uses_p = 0;
|
*num_loads_p = 0;
|
*num_loads_p = 0;
|
*num_stores_p = 0;
|
*num_stores_p = 0;
|
|
|
/* Find out the total number of uses of PTR in STMT. */
|
/* Find out the total number of uses of PTR in STMT. */
|
FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
|
FOR_EACH_SSA_TREE_OPERAND (use, stmt, i, SSA_OP_USE)
|
if (use == ptr)
|
if (use == ptr)
|
(*num_uses_p)++;
|
(*num_uses_p)++;
|
|
|
/* Now count the number of indirect references to PTR. This is
|
/* Now count the number of indirect references to PTR. This is
|
truly awful, but we don't have much choice. There are no parent
|
truly awful, but we don't have much choice. There are no parent
|
pointers inside INDIRECT_REFs, so an expression like
|
pointers inside INDIRECT_REFs, so an expression like
|
'*x_1 = foo (x_1, *x_1)' needs to be traversed piece by piece to
|
'*x_1 = foo (x_1, *x_1)' needs to be traversed piece by piece to
|
find all the indirect and direct uses of x_1 inside. The only
|
find all the indirect and direct uses of x_1 inside. The only
|
shortcut we can take is the fact that GIMPLE only allows
|
shortcut we can take is the fact that GIMPLE only allows
|
INDIRECT_REFs inside the expressions below. */
|
INDIRECT_REFs inside the expressions below. */
|
if (is_gimple_assign (stmt)
|
if (is_gimple_assign (stmt)
|
|| gimple_code (stmt) == GIMPLE_RETURN
|
|| gimple_code (stmt) == GIMPLE_RETURN
|
|| gimple_code (stmt) == GIMPLE_ASM
|
|| gimple_code (stmt) == GIMPLE_ASM
|
|| is_gimple_call (stmt))
|
|| is_gimple_call (stmt))
|
{
|
{
|
struct walk_stmt_info wi;
|
struct walk_stmt_info wi;
|
struct count_ptr_d count;
|
struct count_ptr_d count;
|
|
|
count.ptr = ptr;
|
count.ptr = ptr;
|
count.num_stores = 0;
|
count.num_stores = 0;
|
count.num_loads = 0;
|
count.num_loads = 0;
|
|
|
memset (&wi, 0, sizeof (wi));
|
memset (&wi, 0, sizeof (wi));
|
wi.info = &count;
|
wi.info = &count;
|
walk_gimple_op (stmt, count_ptr_derefs, &wi);
|
walk_gimple_op (stmt, count_ptr_derefs, &wi);
|
|
|
*num_stores_p = count.num_stores;
|
*num_stores_p = count.num_stores;
|
*num_loads_p = count.num_loads;
|
*num_loads_p = count.num_loads;
|
}
|
}
|
|
|
gcc_assert (*num_uses_p >= *num_loads_p + *num_stores_p);
|
gcc_assert (*num_uses_p >= *num_loads_p + *num_stores_p);
|
}
|
}
|
|
|
/* From a tree operand OP return the base of a load or store operation
|
/* From a tree operand OP return the base of a load or store operation
|
or NULL_TREE if OP is not a load or a store. */
|
or NULL_TREE if OP is not a load or a store. */
|
|
|
static tree
|
static tree
|
get_base_loadstore (tree op)
|
get_base_loadstore (tree op)
|
{
|
{
|
while (handled_component_p (op))
|
while (handled_component_p (op))
|
op = TREE_OPERAND (op, 0);
|
op = TREE_OPERAND (op, 0);
|
if (DECL_P (op)
|
if (DECL_P (op)
|
|| INDIRECT_REF_P (op)
|
|| INDIRECT_REF_P (op)
|
|| TREE_CODE (op) == TARGET_MEM_REF)
|
|| TREE_CODE (op) == TARGET_MEM_REF)
|
return op;
|
return op;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
|
/* For the statement STMT call the callbacks VISIT_LOAD, VISIT_STORE and
|
VISIT_ADDR if non-NULL on loads, store and address-taken operands
|
VISIT_ADDR if non-NULL on loads, store and address-taken operands
|
passing the STMT, the base of the operand and DATA to it. The base
|
passing the STMT, the base of the operand and DATA to it. The base
|
will be either a decl, an indirect reference (including TARGET_MEM_REF)
|
will be either a decl, an indirect reference (including TARGET_MEM_REF)
|
or the argument of an address expression.
|
or the argument of an address expression.
|
Returns the results of these callbacks or'ed. */
|
Returns the results of these callbacks or'ed. */
|
|
|
bool
|
bool
|
walk_stmt_load_store_addr_ops (gimple stmt, void *data,
|
walk_stmt_load_store_addr_ops (gimple stmt, void *data,
|
bool (*visit_load)(gimple, tree, void *),
|
bool (*visit_load)(gimple, tree, void *),
|
bool (*visit_store)(gimple, tree, void *),
|
bool (*visit_store)(gimple, tree, void *),
|
bool (*visit_addr)(gimple, tree, void *))
|
bool (*visit_addr)(gimple, tree, void *))
|
{
|
{
|
bool ret = false;
|
bool ret = false;
|
unsigned i;
|
unsigned i;
|
if (gimple_assign_single_p (stmt))
|
if (gimple_assign_single_p (stmt))
|
{
|
{
|
tree lhs, rhs;
|
tree lhs, rhs;
|
if (visit_store)
|
if (visit_store)
|
{
|
{
|
lhs = get_base_loadstore (gimple_assign_lhs (stmt));
|
lhs = get_base_loadstore (gimple_assign_lhs (stmt));
|
if (lhs)
|
if (lhs)
|
ret |= visit_store (stmt, lhs, data);
|
ret |= visit_store (stmt, lhs, data);
|
}
|
}
|
rhs = gimple_assign_rhs1 (stmt);
|
rhs = gimple_assign_rhs1 (stmt);
|
while (handled_component_p (rhs))
|
while (handled_component_p (rhs))
|
rhs = TREE_OPERAND (rhs, 0);
|
rhs = TREE_OPERAND (rhs, 0);
|
if (visit_addr)
|
if (visit_addr)
|
{
|
{
|
if (TREE_CODE (rhs) == ADDR_EXPR)
|
if (TREE_CODE (rhs) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
|
else if (TREE_CODE (rhs) == TARGET_MEM_REF
|
else if (TREE_CODE (rhs) == TARGET_MEM_REF
|
&& TMR_BASE (rhs) != NULL_TREE
|
&& TMR_BASE (rhs) != NULL_TREE
|
&& TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
|
&& TREE_CODE (TMR_BASE (rhs)) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (rhs), 0), data);
|
else if (TREE_CODE (rhs) == OBJ_TYPE_REF
|
else if (TREE_CODE (rhs) == OBJ_TYPE_REF
|
&& TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
|
&& TREE_CODE (OBJ_TYPE_REF_OBJECT (rhs)) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
|
ret |= visit_addr (stmt, TREE_OPERAND (OBJ_TYPE_REF_OBJECT (rhs),
|
0), data);
|
0), data);
|
lhs = gimple_assign_lhs (stmt);
|
lhs = gimple_assign_lhs (stmt);
|
if (TREE_CODE (lhs) == TARGET_MEM_REF
|
if (TREE_CODE (lhs) == TARGET_MEM_REF
|
&& TMR_BASE (lhs) != NULL_TREE
|
&& TMR_BASE (lhs) != NULL_TREE
|
&& TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
|
&& TREE_CODE (TMR_BASE (lhs)) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (TMR_BASE (lhs), 0), data);
|
}
|
}
|
if (visit_load)
|
if (visit_load)
|
{
|
{
|
rhs = get_base_loadstore (rhs);
|
rhs = get_base_loadstore (rhs);
|
if (rhs)
|
if (rhs)
|
ret |= visit_load (stmt, rhs, data);
|
ret |= visit_load (stmt, rhs, data);
|
}
|
}
|
}
|
}
|
else if (visit_addr
|
else if (visit_addr
|
&& (is_gimple_assign (stmt)
|
&& (is_gimple_assign (stmt)
|
|| gimple_code (stmt) == GIMPLE_COND))
|
|| gimple_code (stmt) == GIMPLE_COND))
|
{
|
{
|
for (i = 0; i < gimple_num_ops (stmt); ++i)
|
for (i = 0; i < gimple_num_ops (stmt); ++i)
|
if (gimple_op (stmt, i)
|
if (gimple_op (stmt, i)
|
&& TREE_CODE (gimple_op (stmt, i)) == ADDR_EXPR)
|
&& TREE_CODE (gimple_op (stmt, i)) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (gimple_op (stmt, i), 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (gimple_op (stmt, i), 0), data);
|
}
|
}
|
else if (is_gimple_call (stmt))
|
else if (is_gimple_call (stmt))
|
{
|
{
|
if (visit_store)
|
if (visit_store)
|
{
|
{
|
tree lhs = gimple_call_lhs (stmt);
|
tree lhs = gimple_call_lhs (stmt);
|
if (lhs)
|
if (lhs)
|
{
|
{
|
lhs = get_base_loadstore (lhs);
|
lhs = get_base_loadstore (lhs);
|
if (lhs)
|
if (lhs)
|
ret |= visit_store (stmt, lhs, data);
|
ret |= visit_store (stmt, lhs, data);
|
}
|
}
|
}
|
}
|
if (visit_load || visit_addr)
|
if (visit_load || visit_addr)
|
for (i = 0; i < gimple_call_num_args (stmt); ++i)
|
for (i = 0; i < gimple_call_num_args (stmt); ++i)
|
{
|
{
|
tree rhs = gimple_call_arg (stmt, i);
|
tree rhs = gimple_call_arg (stmt, i);
|
if (visit_addr
|
if (visit_addr
|
&& TREE_CODE (rhs) == ADDR_EXPR)
|
&& TREE_CODE (rhs) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (rhs, 0), data);
|
else if (visit_load)
|
else if (visit_load)
|
{
|
{
|
rhs = get_base_loadstore (rhs);
|
rhs = get_base_loadstore (rhs);
|
if (rhs)
|
if (rhs)
|
ret |= visit_load (stmt, rhs, data);
|
ret |= visit_load (stmt, rhs, data);
|
}
|
}
|
}
|
}
|
if (visit_addr
|
if (visit_addr
|
&& gimple_call_chain (stmt)
|
&& gimple_call_chain (stmt)
|
&& TREE_CODE (gimple_call_chain (stmt)) == ADDR_EXPR)
|
&& TREE_CODE (gimple_call_chain (stmt)) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (stmt), 0),
|
ret |= visit_addr (stmt, TREE_OPERAND (gimple_call_chain (stmt), 0),
|
data);
|
data);
|
if (visit_addr
|
if (visit_addr
|
&& gimple_call_return_slot_opt_p (stmt)
|
&& gimple_call_return_slot_opt_p (stmt)
|
&& gimple_call_lhs (stmt) != NULL_TREE
|
&& gimple_call_lhs (stmt) != NULL_TREE
|
&& TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
|
&& TREE_ADDRESSABLE (TREE_TYPE (gimple_call_lhs (stmt))))
|
ret |= visit_addr (stmt, gimple_call_lhs (stmt), data);
|
ret |= visit_addr (stmt, gimple_call_lhs (stmt), data);
|
}
|
}
|
else if (gimple_code (stmt) == GIMPLE_ASM)
|
else if (gimple_code (stmt) == GIMPLE_ASM)
|
{
|
{
|
unsigned noutputs;
|
unsigned noutputs;
|
const char *constraint;
|
const char *constraint;
|
const char **oconstraints;
|
const char **oconstraints;
|
bool allows_mem, allows_reg, is_inout;
|
bool allows_mem, allows_reg, is_inout;
|
noutputs = gimple_asm_noutputs (stmt);
|
noutputs = gimple_asm_noutputs (stmt);
|
oconstraints = XALLOCAVEC (const char *, noutputs);
|
oconstraints = XALLOCAVEC (const char *, noutputs);
|
if (visit_store || visit_addr)
|
if (visit_store || visit_addr)
|
for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
|
for (i = 0; i < gimple_asm_noutputs (stmt); ++i)
|
{
|
{
|
tree link = gimple_asm_output_op (stmt, i);
|
tree link = gimple_asm_output_op (stmt, i);
|
tree op = get_base_loadstore (TREE_VALUE (link));
|
tree op = get_base_loadstore (TREE_VALUE (link));
|
if (op && visit_store)
|
if (op && visit_store)
|
ret |= visit_store (stmt, op, data);
|
ret |= visit_store (stmt, op, data);
|
if (visit_addr)
|
if (visit_addr)
|
{
|
{
|
constraint = TREE_STRING_POINTER
|
constraint = TREE_STRING_POINTER
|
(TREE_VALUE (TREE_PURPOSE (link)));
|
(TREE_VALUE (TREE_PURPOSE (link)));
|
oconstraints[i] = constraint;
|
oconstraints[i] = constraint;
|
parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
|
parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
|
&allows_reg, &is_inout);
|
&allows_reg, &is_inout);
|
if (op && !allows_reg && allows_mem)
|
if (op && !allows_reg && allows_mem)
|
ret |= visit_addr (stmt, op, data);
|
ret |= visit_addr (stmt, op, data);
|
}
|
}
|
}
|
}
|
if (visit_load || visit_addr)
|
if (visit_load || visit_addr)
|
for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
|
for (i = 0; i < gimple_asm_ninputs (stmt); ++i)
|
{
|
{
|
tree link = gimple_asm_input_op (stmt, i);
|
tree link = gimple_asm_input_op (stmt, i);
|
tree op = TREE_VALUE (link);
|
tree op = TREE_VALUE (link);
|
if (visit_addr
|
if (visit_addr
|
&& TREE_CODE (op) == ADDR_EXPR)
|
&& TREE_CODE (op) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
|
else if (visit_load || visit_addr)
|
else if (visit_load || visit_addr)
|
{
|
{
|
op = get_base_loadstore (op);
|
op = get_base_loadstore (op);
|
if (op)
|
if (op)
|
{
|
{
|
if (visit_load)
|
if (visit_load)
|
ret |= visit_load (stmt, op, data);
|
ret |= visit_load (stmt, op, data);
|
if (visit_addr)
|
if (visit_addr)
|
{
|
{
|
constraint = TREE_STRING_POINTER
|
constraint = TREE_STRING_POINTER
|
(TREE_VALUE (TREE_PURPOSE (link)));
|
(TREE_VALUE (TREE_PURPOSE (link)));
|
parse_input_constraint (&constraint, 0, 0, noutputs,
|
parse_input_constraint (&constraint, 0, 0, noutputs,
|
0, oconstraints,
|
0, oconstraints,
|
&allows_mem, &allows_reg);
|
&allows_mem, &allows_reg);
|
if (!allows_reg && allows_mem)
|
if (!allows_reg && allows_mem)
|
ret |= visit_addr (stmt, op, data);
|
ret |= visit_addr (stmt, op, data);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (gimple_code (stmt) == GIMPLE_RETURN)
|
else if (gimple_code (stmt) == GIMPLE_RETURN)
|
{
|
{
|
tree op = gimple_return_retval (stmt);
|
tree op = gimple_return_retval (stmt);
|
if (op)
|
if (op)
|
{
|
{
|
if (visit_addr
|
if (visit_addr
|
&& TREE_CODE (op) == ADDR_EXPR)
|
&& TREE_CODE (op) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
|
else if (visit_load)
|
else if (visit_load)
|
{
|
{
|
op = get_base_loadstore (op);
|
op = get_base_loadstore (op);
|
if (op)
|
if (op)
|
ret |= visit_load (stmt, op, data);
|
ret |= visit_load (stmt, op, data);
|
}
|
}
|
}
|
}
|
}
|
}
|
else if (visit_addr
|
else if (visit_addr
|
&& gimple_code (stmt) == GIMPLE_PHI)
|
&& gimple_code (stmt) == GIMPLE_PHI)
|
{
|
{
|
for (i = 0; i < gimple_phi_num_args (stmt); ++i)
|
for (i = 0; i < gimple_phi_num_args (stmt); ++i)
|
{
|
{
|
tree op = PHI_ARG_DEF (stmt, i);
|
tree op = PHI_ARG_DEF (stmt, i);
|
if (TREE_CODE (op) == ADDR_EXPR)
|
if (TREE_CODE (op) == ADDR_EXPR)
|
ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
|
ret |= visit_addr (stmt, TREE_OPERAND (op, 0), data);
|
}
|
}
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP
|
/* Like walk_stmt_load_store_addr_ops but with NULL visit_addr. IPA-CP
|
should make a faster clone for this case. */
|
should make a faster clone for this case. */
|
|
|
bool
|
bool
|
walk_stmt_load_store_ops (gimple stmt, void *data,
|
walk_stmt_load_store_ops (gimple stmt, void *data,
|
bool (*visit_load)(gimple, tree, void *),
|
bool (*visit_load)(gimple, tree, void *),
|
bool (*visit_store)(gimple, tree, void *))
|
bool (*visit_store)(gimple, tree, void *))
|
{
|
{
|
return walk_stmt_load_store_addr_ops (stmt, data,
|
return walk_stmt_load_store_addr_ops (stmt, data,
|
visit_load, visit_store, NULL);
|
visit_load, visit_store, NULL);
|
}
|
}
|
|
|
/* Helper for gimple_ior_addresses_taken_1. */
|
/* Helper for gimple_ior_addresses_taken_1. */
|
|
|
static bool
|
static bool
|
gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED,
|
gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED,
|
tree addr, void *data)
|
tree addr, void *data)
|
{
|
{
|
bitmap addresses_taken = (bitmap)data;
|
bitmap addresses_taken = (bitmap)data;
|
while (handled_component_p (addr))
|
while (handled_component_p (addr))
|
addr = TREE_OPERAND (addr, 0);
|
addr = TREE_OPERAND (addr, 0);
|
if (DECL_P (addr))
|
if (DECL_P (addr))
|
{
|
{
|
bitmap_set_bit (addresses_taken, DECL_UID (addr));
|
bitmap_set_bit (addresses_taken, DECL_UID (addr));
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Set the bit for the uid of all decls that have their address taken
|
/* Set the bit for the uid of all decls that have their address taken
|
in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
|
in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
|
were any in this stmt. */
|
were any in this stmt. */
|
|
|
bool
|
bool
|
gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
|
gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
|
{
|
{
|
return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
|
return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
|
gimple_ior_addresses_taken_1);
|
gimple_ior_addresses_taken_1);
|
}
|
}
|
|
|
|
|
/* Return a printable name for symbol DECL. */
|
/* Return a printable name for symbol DECL. */
|
|
|
const char *
|
const char *
|
gimple_decl_printable_name (tree decl, int verbosity)
|
gimple_decl_printable_name (tree decl, int verbosity)
|
{
|
{
|
if (!DECL_NAME (decl))
|
if (!DECL_NAME (decl))
|
return NULL;
|
return NULL;
|
|
|
if (DECL_ASSEMBLER_NAME_SET_P (decl))
|
if (DECL_ASSEMBLER_NAME_SET_P (decl))
|
{
|
{
|
const char *str, *mangled_str;
|
const char *str, *mangled_str;
|
int dmgl_opts = DMGL_NO_OPTS;
|
int dmgl_opts = DMGL_NO_OPTS;
|
|
|
if (verbosity >= 2)
|
if (verbosity >= 2)
|
{
|
{
|
dmgl_opts = DMGL_VERBOSE
|
dmgl_opts = DMGL_VERBOSE
|
| DMGL_ANSI
|
| DMGL_ANSI
|
| DMGL_GNU_V3
|
| DMGL_GNU_V3
|
| DMGL_RET_POSTFIX;
|
| DMGL_RET_POSTFIX;
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
if (TREE_CODE (decl) == FUNCTION_DECL)
|
dmgl_opts |= DMGL_PARAMS;
|
dmgl_opts |= DMGL_PARAMS;
|
}
|
}
|
|
|
mangled_str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
mangled_str = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
|
str = cplus_demangle_v3 (mangled_str, dmgl_opts);
|
str = cplus_demangle_v3 (mangled_str, dmgl_opts);
|
return (str) ? str : mangled_str;
|
return (str) ? str : mangled_str;
|
}
|
}
|
|
|
return IDENTIFIER_POINTER (DECL_NAME (decl));
|
return IDENTIFIER_POINTER (DECL_NAME (decl));
|
}
|
}
|
|
|
|
|
/* Fold a OBJ_TYPE_REF expression to the address of a function.
|
/* Fold a OBJ_TYPE_REF expression to the address of a function.
|
KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). Adapted
|
KNOWN_TYPE carries the true type of OBJ_TYPE_REF_OBJECT(REF). Adapted
|
from cp_fold_obj_type_ref, but it tolerates types with no binfo
|
from cp_fold_obj_type_ref, but it tolerates types with no binfo
|
data. */
|
data. */
|
|
|
tree
|
tree
|
gimple_fold_obj_type_ref (tree ref, tree known_type)
|
gimple_fold_obj_type_ref (tree ref, tree known_type)
|
{
|
{
|
HOST_WIDE_INT index;
|
HOST_WIDE_INT index;
|
HOST_WIDE_INT i;
|
HOST_WIDE_INT i;
|
tree v;
|
tree v;
|
tree fndecl;
|
tree fndecl;
|
|
|
if (TYPE_BINFO (known_type) == NULL_TREE)
|
if (TYPE_BINFO (known_type) == NULL_TREE)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
|
v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
|
index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
|
index = tree_low_cst (OBJ_TYPE_REF_TOKEN (ref), 1);
|
i = 0;
|
i = 0;
|
while (i != index)
|
while (i != index)
|
{
|
{
|
i += (TARGET_VTABLE_USES_DESCRIPTORS
|
i += (TARGET_VTABLE_USES_DESCRIPTORS
|
? TARGET_VTABLE_USES_DESCRIPTORS : 1);
|
? TARGET_VTABLE_USES_DESCRIPTORS : 1);
|
v = TREE_CHAIN (v);
|
v = TREE_CHAIN (v);
|
}
|
}
|
|
|
fndecl = TREE_VALUE (v);
|
fndecl = TREE_VALUE (v);
|
|
|
#ifdef ENABLE_CHECKING
|
#ifdef ENABLE_CHECKING
|
gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
|
gcc_assert (tree_int_cst_equal (OBJ_TYPE_REF_TOKEN (ref),
|
DECL_VINDEX (fndecl)));
|
DECL_VINDEX (fndecl)));
|
#endif
|
#endif
|
|
|
cgraph_node (fndecl)->local.vtable_method = true;
|
cgraph_node (fndecl)->local.vtable_method = true;
|
|
|
return build_fold_addr_expr (fndecl);
|
return build_fold_addr_expr (fndecl);
|
}
|
}
|
|
|
#include "gt-gimple.h"
|
#include "gt-gimple.h"
|
|
|
