/* Language-independent node constructors for parse phase of GNU compiler.
|
/* Language-independent node constructors for parse phase of GNU compiler.
|
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
|
1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
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/>. */
|
|
|
/* This file contains the low level primitives for operating on tree nodes,
|
/* This file contains the low level primitives for operating on tree nodes,
|
including allocation, list operations, interning of identifiers,
|
including allocation, list operations, interning of identifiers,
|
construction of data type nodes and statement nodes,
|
construction of data type nodes and statement nodes,
|
and construction of type conversion nodes. It also contains
|
and construction of type conversion nodes. It also contains
|
tables index by tree code that describe how to take apart
|
tables index by tree code that describe how to take apart
|
nodes of that code.
|
nodes of that code.
|
|
|
It is intended to be language-independent, but occasionally
|
It is intended to be language-independent, but occasionally
|
calls language-dependent routines defined (for C) in typecheck.c. */
|
calls language-dependent routines defined (for C) in typecheck.c. */
|
|
|
#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 "flags.h"
|
#include "flags.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "real.h"
|
#include "real.h"
|
#include "tm_p.h"
|
#include "tm_p.h"
|
#include "function.h"
|
#include "function.h"
|
#include "obstack.h"
|
#include "obstack.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "output.h"
|
#include "output.h"
|
#include "target.h"
|
#include "target.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "tree-iterator.h"
|
#include "tree-iterator.h"
|
#include "basic-block.h"
|
#include "basic-block.h"
|
#include "tree-flow.h"
|
#include "tree-flow.h"
|
#include "params.h"
|
#include "params.h"
|
#include "pointer-set.h"
|
#include "pointer-set.h"
|
|
|
/* Each tree code class has an associated string representation.
|
/* Each tree code class has an associated string representation.
|
These must correspond to the tree_code_class entries. */
|
These must correspond to the tree_code_class entries. */
|
|
|
const char *const tree_code_class_strings[] =
|
const char *const tree_code_class_strings[] =
|
{
|
{
|
"exceptional",
|
"exceptional",
|
"constant",
|
"constant",
|
"type",
|
"type",
|
"declaration",
|
"declaration",
|
"reference",
|
"reference",
|
"comparison",
|
"comparison",
|
"unary",
|
"unary",
|
"binary",
|
"binary",
|
"statement",
|
"statement",
|
"expression",
|
"expression",
|
};
|
};
|
|
|
/* obstack.[ch] explicitly declined to prototype this. */
|
/* obstack.[ch] explicitly declined to prototype this. */
|
extern int _obstack_allocated_p (struct obstack *h, void *obj);
|
extern int _obstack_allocated_p (struct obstack *h, void *obj);
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
/* Statistics-gathering stuff. */
|
/* Statistics-gathering stuff. */
|
|
|
int tree_node_counts[(int) all_kinds];
|
int tree_node_counts[(int) all_kinds];
|
int tree_node_sizes[(int) all_kinds];
|
int tree_node_sizes[(int) all_kinds];
|
|
|
/* Keep in sync with tree.h:enum tree_node_kind. */
|
/* Keep in sync with tree.h:enum tree_node_kind. */
|
static const char * const tree_node_kind_names[] = {
|
static const char * const tree_node_kind_names[] = {
|
"decls",
|
"decls",
|
"types",
|
"types",
|
"blocks",
|
"blocks",
|
"stmts",
|
"stmts",
|
"refs",
|
"refs",
|
"exprs",
|
"exprs",
|
"constants",
|
"constants",
|
"identifiers",
|
"identifiers",
|
"perm_tree_lists",
|
"perm_tree_lists",
|
"temp_tree_lists",
|
"temp_tree_lists",
|
"vecs",
|
"vecs",
|
"binfos",
|
"binfos",
|
"phi_nodes",
|
"phi_nodes",
|
"ssa names",
|
"ssa names",
|
"constructors",
|
"constructors",
|
"random kinds",
|
"random kinds",
|
"lang_decl kinds",
|
"lang_decl kinds",
|
"lang_type kinds",
|
"lang_type kinds",
|
"omp clauses"
|
"omp clauses"
|
};
|
};
|
#endif /* GATHER_STATISTICS */
|
#endif /* GATHER_STATISTICS */
|
|
|
/* Unique id for next decl created. */
|
/* Unique id for next decl created. */
|
static GTY(()) int next_decl_uid;
|
static GTY(()) int next_decl_uid;
|
/* Unique id for next type created. */
|
/* Unique id for next type created. */
|
static GTY(()) int next_type_uid = 1;
|
static GTY(()) int next_type_uid = 1;
|
|
|
/* Since we cannot rehash a type after it is in the table, we have to
|
/* Since we cannot rehash a type after it is in the table, we have to
|
keep the hash code. */
|
keep the hash code. */
|
|
|
struct type_hash GTY(())
|
struct type_hash GTY(())
|
{
|
{
|
unsigned long hash;
|
unsigned long hash;
|
tree type;
|
tree type;
|
};
|
};
|
|
|
/* Initial size of the hash table (rounded to next prime). */
|
/* Initial size of the hash table (rounded to next prime). */
|
#define TYPE_HASH_INITIAL_SIZE 1000
|
#define TYPE_HASH_INITIAL_SIZE 1000
|
|
|
/* Now here is the hash table. When recording a type, it is added to
|
/* Now here is the hash table. When recording a type, it is added to
|
the slot whose index is the hash code. Note that the hash table is
|
the slot whose index is the hash code. Note that the hash table is
|
used for several kinds of types (function types, array types and
|
used for several kinds of types (function types, array types and
|
array index range types, for now). While all these live in the
|
array index range types, for now). While all these live in the
|
same table, they are completely independent, and the hash code is
|
same table, they are completely independent, and the hash code is
|
computed differently for each of these. */
|
computed differently for each of these. */
|
|
|
static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
|
static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
|
htab_t type_hash_table;
|
htab_t type_hash_table;
|
|
|
/* Hash table and temporary node for larger integer const values. */
|
/* Hash table and temporary node for larger integer const values. */
|
static GTY (()) tree int_cst_node;
|
static GTY (()) tree int_cst_node;
|
static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
|
static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
|
htab_t int_cst_hash_table;
|
htab_t int_cst_hash_table;
|
|
|
/* General tree->tree mapping structure for use in hash tables. */
|
/* General tree->tree mapping structure for use in hash tables. */
|
|
|
|
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
|
htab_t debug_expr_for_decl;
|
htab_t debug_expr_for_decl;
|
|
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
|
htab_t value_expr_for_decl;
|
htab_t value_expr_for_decl;
|
|
|
static GTY ((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
|
static GTY ((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map)))
|
htab_t init_priority_for_decl;
|
htab_t init_priority_for_decl;
|
|
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
|
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
|
htab_t restrict_base_for_decl;
|
htab_t restrict_base_for_decl;
|
|
|
struct tree_int_map GTY(())
|
struct tree_int_map GTY(())
|
{
|
{
|
tree from;
|
tree from;
|
unsigned short to;
|
unsigned short to;
|
};
|
};
|
static unsigned int tree_int_map_hash (const void *);
|
static unsigned int tree_int_map_hash (const void *);
|
static int tree_int_map_eq (const void *, const void *);
|
static int tree_int_map_eq (const void *, const void *);
|
static int tree_int_map_marked_p (const void *);
|
static int tree_int_map_marked_p (const void *);
|
static void set_type_quals (tree, int);
|
static void set_type_quals (tree, int);
|
static int type_hash_eq (const void *, const void *);
|
static int type_hash_eq (const void *, const void *);
|
static hashval_t type_hash_hash (const void *);
|
static hashval_t type_hash_hash (const void *);
|
static hashval_t int_cst_hash_hash (const void *);
|
static hashval_t int_cst_hash_hash (const void *);
|
static int int_cst_hash_eq (const void *, const void *);
|
static int int_cst_hash_eq (const void *, const void *);
|
static void print_type_hash_statistics (void);
|
static void print_type_hash_statistics (void);
|
static void print_debug_expr_statistics (void);
|
static void print_debug_expr_statistics (void);
|
static void print_value_expr_statistics (void);
|
static void print_value_expr_statistics (void);
|
static int type_hash_marked_p (const void *);
|
static int type_hash_marked_p (const void *);
|
static unsigned int type_hash_list (tree, hashval_t);
|
static unsigned int type_hash_list (tree, hashval_t);
|
static unsigned int attribute_hash_list (tree, hashval_t);
|
static unsigned int attribute_hash_list (tree, hashval_t);
|
|
|
tree global_trees[TI_MAX];
|
tree global_trees[TI_MAX];
|
tree integer_types[itk_none];
|
tree integer_types[itk_none];
|
|
|
unsigned char tree_contains_struct[256][64];
|
unsigned char tree_contains_struct[256][64];
|
|
|
/* Number of operands for each OpenMP clause. */
|
/* Number of operands for each OpenMP clause. */
|
unsigned const char omp_clause_num_ops[] =
|
unsigned const char omp_clause_num_ops[] =
|
{
|
{
|
0, /* OMP_CLAUSE_ERROR */
|
0, /* OMP_CLAUSE_ERROR */
|
1, /* OMP_CLAUSE_PRIVATE */
|
1, /* OMP_CLAUSE_PRIVATE */
|
1, /* OMP_CLAUSE_SHARED */
|
1, /* OMP_CLAUSE_SHARED */
|
1, /* OMP_CLAUSE_FIRSTPRIVATE */
|
1, /* OMP_CLAUSE_FIRSTPRIVATE */
|
1, /* OMP_CLAUSE_LASTPRIVATE */
|
1, /* OMP_CLAUSE_LASTPRIVATE */
|
4, /* OMP_CLAUSE_REDUCTION */
|
4, /* OMP_CLAUSE_REDUCTION */
|
1, /* OMP_CLAUSE_COPYIN */
|
1, /* OMP_CLAUSE_COPYIN */
|
1, /* OMP_CLAUSE_COPYPRIVATE */
|
1, /* OMP_CLAUSE_COPYPRIVATE */
|
1, /* OMP_CLAUSE_IF */
|
1, /* OMP_CLAUSE_IF */
|
1, /* OMP_CLAUSE_NUM_THREADS */
|
1, /* OMP_CLAUSE_NUM_THREADS */
|
1, /* OMP_CLAUSE_SCHEDULE */
|
1, /* OMP_CLAUSE_SCHEDULE */
|
0, /* OMP_CLAUSE_NOWAIT */
|
0, /* OMP_CLAUSE_NOWAIT */
|
0, /* OMP_CLAUSE_ORDERED */
|
0, /* OMP_CLAUSE_ORDERED */
|
0 /* OMP_CLAUSE_DEFAULT */
|
0 /* OMP_CLAUSE_DEFAULT */
|
};
|
};
|
|
|
const char * const omp_clause_code_name[] =
|
const char * const omp_clause_code_name[] =
|
{
|
{
|
"error_clause",
|
"error_clause",
|
"private",
|
"private",
|
"shared",
|
"shared",
|
"firstprivate",
|
"firstprivate",
|
"lastprivate",
|
"lastprivate",
|
"reduction",
|
"reduction",
|
"copyin",
|
"copyin",
|
"copyprivate",
|
"copyprivate",
|
"if",
|
"if",
|
"num_threads",
|
"num_threads",
|
"schedule",
|
"schedule",
|
"nowait",
|
"nowait",
|
"ordered",
|
"ordered",
|
"default"
|
"default"
|
};
|
};
|
|
|
/* Init tree.c. */
|
/* Init tree.c. */
|
|
|
void
|
void
|
init_ttree (void)
|
init_ttree (void)
|
{
|
{
|
/* Initialize the hash table of types. */
|
/* Initialize the hash table of types. */
|
type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
|
type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
|
type_hash_eq, 0);
|
type_hash_eq, 0);
|
|
|
debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
|
debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
|
tree_map_eq, 0);
|
tree_map_eq, 0);
|
|
|
value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
|
value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
|
tree_map_eq, 0);
|
tree_map_eq, 0);
|
init_priority_for_decl = htab_create_ggc (512, tree_int_map_hash,
|
init_priority_for_decl = htab_create_ggc (512, tree_int_map_hash,
|
tree_int_map_eq, 0);
|
tree_int_map_eq, 0);
|
restrict_base_for_decl = htab_create_ggc (256, tree_map_hash,
|
restrict_base_for_decl = htab_create_ggc (256, tree_map_hash,
|
tree_map_eq, 0);
|
tree_map_eq, 0);
|
|
|
int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
|
int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
|
int_cst_hash_eq, NULL);
|
int_cst_hash_eq, NULL);
|
|
|
int_cst_node = make_node (INTEGER_CST);
|
int_cst_node = make_node (INTEGER_CST);
|
|
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON] = 1;
|
|
|
|
|
tree_contains_struct[CONST_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[CONST_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[PARM_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[PARM_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[RESULT_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[RESULT_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[LABEL_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[LABEL_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[FIELD_DECL][TS_DECL_COMMON] = 1;
|
tree_contains_struct[FIELD_DECL][TS_DECL_COMMON] = 1;
|
|
|
|
|
tree_contains_struct[CONST_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[CONST_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[PARM_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[PARM_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[RESULT_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[RESULT_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[LABEL_DECL][TS_DECL_WRTL] = 1;
|
tree_contains_struct[LABEL_DECL][TS_DECL_WRTL] = 1;
|
|
|
tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[STRUCT_FIELD_TAG][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[STRUCT_FIELD_TAG][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[NAME_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[NAME_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[SYMBOL_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
|
tree_contains_struct[SYMBOL_MEMORY_TAG][TS_DECL_MINIMAL] = 1;
|
|
|
tree_contains_struct[STRUCT_FIELD_TAG][TS_MEMORY_TAG] = 1;
|
tree_contains_struct[STRUCT_FIELD_TAG][TS_MEMORY_TAG] = 1;
|
tree_contains_struct[NAME_MEMORY_TAG][TS_MEMORY_TAG] = 1;
|
tree_contains_struct[NAME_MEMORY_TAG][TS_MEMORY_TAG] = 1;
|
tree_contains_struct[SYMBOL_MEMORY_TAG][TS_MEMORY_TAG] = 1;
|
tree_contains_struct[SYMBOL_MEMORY_TAG][TS_MEMORY_TAG] = 1;
|
|
|
tree_contains_struct[STRUCT_FIELD_TAG][TS_STRUCT_FIELD_TAG] = 1;
|
tree_contains_struct[STRUCT_FIELD_TAG][TS_STRUCT_FIELD_TAG] = 1;
|
|
|
tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS] = 1;
|
tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS] = 1;
|
|
|
tree_contains_struct[VAR_DECL][TS_VAR_DECL] = 1;
|
tree_contains_struct[VAR_DECL][TS_VAR_DECL] = 1;
|
tree_contains_struct[FIELD_DECL][TS_FIELD_DECL] = 1;
|
tree_contains_struct[FIELD_DECL][TS_FIELD_DECL] = 1;
|
tree_contains_struct[PARM_DECL][TS_PARM_DECL] = 1;
|
tree_contains_struct[PARM_DECL][TS_PARM_DECL] = 1;
|
tree_contains_struct[LABEL_DECL][TS_LABEL_DECL] = 1;
|
tree_contains_struct[LABEL_DECL][TS_LABEL_DECL] = 1;
|
tree_contains_struct[RESULT_DECL][TS_RESULT_DECL] = 1;
|
tree_contains_struct[RESULT_DECL][TS_RESULT_DECL] = 1;
|
tree_contains_struct[CONST_DECL][TS_CONST_DECL] = 1;
|
tree_contains_struct[CONST_DECL][TS_CONST_DECL] = 1;
|
tree_contains_struct[TYPE_DECL][TS_TYPE_DECL] = 1;
|
tree_contains_struct[TYPE_DECL][TS_TYPE_DECL] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL] = 1;
|
tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL] = 1;
|
|
|
lang_hooks.init_ts ();
|
lang_hooks.init_ts ();
|
}
|
}
|
|
|
|
|
/* The name of the object as the assembler will see it (but before any
|
/* The name of the object as the assembler will see it (but before any
|
translations made by ASM_OUTPUT_LABELREF). Often this is the same
|
translations made by ASM_OUTPUT_LABELREF). Often this is the same
|
as DECL_NAME. It is an IDENTIFIER_NODE. */
|
as DECL_NAME. It is an IDENTIFIER_NODE. */
|
tree
|
tree
|
decl_assembler_name (tree decl)
|
decl_assembler_name (tree decl)
|
{
|
{
|
if (!DECL_ASSEMBLER_NAME_SET_P (decl))
|
if (!DECL_ASSEMBLER_NAME_SET_P (decl))
|
lang_hooks.set_decl_assembler_name (decl);
|
lang_hooks.set_decl_assembler_name (decl);
|
return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
|
return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
|
}
|
}
|
|
|
/* Compute the number of bytes occupied by a tree with code CODE.
|
/* Compute the number of bytes occupied by a tree with code CODE.
|
This function cannot be used for TREE_VEC, PHI_NODE, or STRING_CST
|
This function cannot be used for TREE_VEC, PHI_NODE, or STRING_CST
|
codes, which are of variable length. */
|
codes, which are of variable length. */
|
size_t
|
size_t
|
tree_code_size (enum tree_code code)
|
tree_code_size (enum tree_code code)
|
{
|
{
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_declaration: /* A decl node */
|
case tcc_declaration: /* A decl node */
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case FIELD_DECL:
|
case FIELD_DECL:
|
return sizeof (struct tree_field_decl);
|
return sizeof (struct tree_field_decl);
|
case PARM_DECL:
|
case PARM_DECL:
|
return sizeof (struct tree_parm_decl);
|
return sizeof (struct tree_parm_decl);
|
case VAR_DECL:
|
case VAR_DECL:
|
return sizeof (struct tree_var_decl);
|
return sizeof (struct tree_var_decl);
|
case LABEL_DECL:
|
case LABEL_DECL:
|
return sizeof (struct tree_label_decl);
|
return sizeof (struct tree_label_decl);
|
case RESULT_DECL:
|
case RESULT_DECL:
|
return sizeof (struct tree_result_decl);
|
return sizeof (struct tree_result_decl);
|
case CONST_DECL:
|
case CONST_DECL:
|
return sizeof (struct tree_const_decl);
|
return sizeof (struct tree_const_decl);
|
case TYPE_DECL:
|
case TYPE_DECL:
|
return sizeof (struct tree_type_decl);
|
return sizeof (struct tree_type_decl);
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
return sizeof (struct tree_function_decl);
|
return sizeof (struct tree_function_decl);
|
case NAME_MEMORY_TAG:
|
case NAME_MEMORY_TAG:
|
case SYMBOL_MEMORY_TAG:
|
case SYMBOL_MEMORY_TAG:
|
return sizeof (struct tree_memory_tag);
|
return sizeof (struct tree_memory_tag);
|
case STRUCT_FIELD_TAG:
|
case STRUCT_FIELD_TAG:
|
return sizeof (struct tree_struct_field_tag);
|
return sizeof (struct tree_struct_field_tag);
|
default:
|
default:
|
return sizeof (struct tree_decl_non_common);
|
return sizeof (struct tree_decl_non_common);
|
}
|
}
|
}
|
}
|
|
|
case tcc_type: /* a type node */
|
case tcc_type: /* a type node */
|
return sizeof (struct tree_type);
|
return sizeof (struct tree_type);
|
|
|
case tcc_reference: /* a reference */
|
case tcc_reference: /* a reference */
|
case tcc_expression: /* an expression */
|
case tcc_expression: /* an expression */
|
case tcc_statement: /* an expression with side effects */
|
case tcc_statement: /* an expression with side effects */
|
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 */
|
return (sizeof (struct tree_exp)
|
return (sizeof (struct tree_exp)
|
+ (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
|
+ (TREE_CODE_LENGTH (code) - 1) * sizeof (char *));
|
|
|
case tcc_constant: /* a constant */
|
case tcc_constant: /* a constant */
|
switch (code)
|
switch (code)
|
{
|
{
|
case INTEGER_CST: return sizeof (struct tree_int_cst);
|
case INTEGER_CST: return sizeof (struct tree_int_cst);
|
case REAL_CST: return sizeof (struct tree_real_cst);
|
case REAL_CST: return sizeof (struct tree_real_cst);
|
case COMPLEX_CST: return sizeof (struct tree_complex);
|
case COMPLEX_CST: return sizeof (struct tree_complex);
|
case VECTOR_CST: return sizeof (struct tree_vector);
|
case VECTOR_CST: return sizeof (struct tree_vector);
|
case STRING_CST: gcc_unreachable ();
|
case STRING_CST: gcc_unreachable ();
|
default:
|
default:
|
return lang_hooks.tree_size (code);
|
return lang_hooks.tree_size (code);
|
}
|
}
|
|
|
case tcc_exceptional: /* something random, like an identifier. */
|
case tcc_exceptional: /* something random, like an identifier. */
|
switch (code)
|
switch (code)
|
{
|
{
|
case IDENTIFIER_NODE: return lang_hooks.identifier_size;
|
case IDENTIFIER_NODE: return lang_hooks.identifier_size;
|
case TREE_LIST: return sizeof (struct tree_list);
|
case TREE_LIST: return sizeof (struct tree_list);
|
|
|
case ERROR_MARK:
|
case ERROR_MARK:
|
case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
|
case PLACEHOLDER_EXPR: return sizeof (struct tree_common);
|
|
|
case TREE_VEC:
|
case TREE_VEC:
|
case OMP_CLAUSE:
|
case OMP_CLAUSE:
|
case PHI_NODE: gcc_unreachable ();
|
case PHI_NODE: gcc_unreachable ();
|
|
|
case SSA_NAME: return sizeof (struct tree_ssa_name);
|
case SSA_NAME: return sizeof (struct tree_ssa_name);
|
|
|
case STATEMENT_LIST: return sizeof (struct tree_statement_list);
|
case STATEMENT_LIST: return sizeof (struct tree_statement_list);
|
case BLOCK: return sizeof (struct tree_block);
|
case BLOCK: return sizeof (struct tree_block);
|
case VALUE_HANDLE: return sizeof (struct tree_value_handle);
|
case VALUE_HANDLE: return sizeof (struct tree_value_handle);
|
case CONSTRUCTOR: return sizeof (struct tree_constructor);
|
case CONSTRUCTOR: return sizeof (struct tree_constructor);
|
|
|
default:
|
default:
|
return lang_hooks.tree_size (code);
|
return lang_hooks.tree_size (code);
|
}
|
}
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Compute the number of bytes occupied by NODE. This routine only
|
/* Compute the number of bytes occupied by NODE. This routine only
|
looks at TREE_CODE, except for PHI_NODE and TREE_VEC nodes. */
|
looks at TREE_CODE, except for PHI_NODE and TREE_VEC nodes. */
|
size_t
|
size_t
|
tree_size (tree node)
|
tree_size (tree node)
|
{
|
{
|
enum tree_code code = TREE_CODE (node);
|
enum tree_code code = TREE_CODE (node);
|
switch (code)
|
switch (code)
|
{
|
{
|
case PHI_NODE:
|
case PHI_NODE:
|
return (sizeof (struct tree_phi_node)
|
return (sizeof (struct tree_phi_node)
|
+ (PHI_ARG_CAPACITY (node) - 1) * sizeof (struct phi_arg_d));
|
+ (PHI_ARG_CAPACITY (node) - 1) * sizeof (struct phi_arg_d));
|
|
|
case TREE_BINFO:
|
case TREE_BINFO:
|
return (offsetof (struct tree_binfo, base_binfos)
|
return (offsetof (struct tree_binfo, base_binfos)
|
+ VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
|
+ VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
|
|
|
case TREE_VEC:
|
case TREE_VEC:
|
return (sizeof (struct tree_vec)
|
return (sizeof (struct tree_vec)
|
+ (TREE_VEC_LENGTH (node) - 1) * sizeof(char *));
|
+ (TREE_VEC_LENGTH (node) - 1) * sizeof(char *));
|
|
|
case STRING_CST:
|
case STRING_CST:
|
return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
|
return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
|
|
|
case OMP_CLAUSE:
|
case OMP_CLAUSE:
|
return (sizeof (struct tree_omp_clause)
|
return (sizeof (struct tree_omp_clause)
|
+ (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
|
+ (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
|
* sizeof (tree));
|
* sizeof (tree));
|
|
|
default:
|
default:
|
return tree_code_size (code);
|
return tree_code_size (code);
|
}
|
}
|
}
|
}
|
|
|
/* Return a newly allocated node of code CODE. For decl and type
|
/* Return a newly allocated node of code CODE. For decl and type
|
nodes, some other fields are initialized. The rest of the node is
|
nodes, some other fields are initialized. The rest of the node is
|
initialized to zero. This function cannot be used for PHI_NODE,
|
initialized to zero. This function cannot be used for PHI_NODE,
|
TREE_VEC or OMP_CLAUSE nodes, which is enforced by asserts in
|
TREE_VEC or OMP_CLAUSE nodes, which is enforced by asserts in
|
tree_code_size.
|
tree_code_size.
|
|
|
Achoo! I got a code in the node. */
|
Achoo! I got a code in the node. */
|
|
|
tree
|
tree
|
make_node_stat (enum tree_code code MEM_STAT_DECL)
|
make_node_stat (enum tree_code code MEM_STAT_DECL)
|
{
|
{
|
tree t;
|
tree t;
|
enum tree_code_class type = TREE_CODE_CLASS (code);
|
enum tree_code_class type = TREE_CODE_CLASS (code);
|
size_t length = tree_code_size (code);
|
size_t length = tree_code_size (code);
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_kind kind;
|
tree_node_kind kind;
|
|
|
switch (type)
|
switch (type)
|
{
|
{
|
case tcc_declaration: /* A decl node */
|
case tcc_declaration: /* A decl node */
|
kind = d_kind;
|
kind = d_kind;
|
break;
|
break;
|
|
|
case tcc_type: /* a type node */
|
case tcc_type: /* a type node */
|
kind = t_kind;
|
kind = t_kind;
|
break;
|
break;
|
|
|
case tcc_statement: /* an expression with side effects */
|
case tcc_statement: /* an expression with side effects */
|
kind = s_kind;
|
kind = s_kind;
|
break;
|
break;
|
|
|
case tcc_reference: /* a reference */
|
case tcc_reference: /* a reference */
|
kind = r_kind;
|
kind = r_kind;
|
break;
|
break;
|
|
|
case tcc_expression: /* an expression */
|
case tcc_expression: /* an expression */
|
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 */
|
kind = e_kind;
|
kind = e_kind;
|
break;
|
break;
|
|
|
case tcc_constant: /* a constant */
|
case tcc_constant: /* a constant */
|
kind = c_kind;
|
kind = c_kind;
|
break;
|
break;
|
|
|
case tcc_exceptional: /* something random, like an identifier. */
|
case tcc_exceptional: /* something random, like an identifier. */
|
switch (code)
|
switch (code)
|
{
|
{
|
case IDENTIFIER_NODE:
|
case IDENTIFIER_NODE:
|
kind = id_kind;
|
kind = id_kind;
|
break;
|
break;
|
|
|
case TREE_VEC:
|
case TREE_VEC:
|
kind = vec_kind;
|
kind = vec_kind;
|
break;
|
break;
|
|
|
case TREE_BINFO:
|
case TREE_BINFO:
|
kind = binfo_kind;
|
kind = binfo_kind;
|
break;
|
break;
|
|
|
case PHI_NODE:
|
case PHI_NODE:
|
kind = phi_kind;
|
kind = phi_kind;
|
break;
|
break;
|
|
|
case SSA_NAME:
|
case SSA_NAME:
|
kind = ssa_name_kind;
|
kind = ssa_name_kind;
|
break;
|
break;
|
|
|
case BLOCK:
|
case BLOCK:
|
kind = b_kind;
|
kind = b_kind;
|
break;
|
break;
|
|
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
kind = constr_kind;
|
kind = constr_kind;
|
break;
|
break;
|
|
|
default:
|
default:
|
kind = x_kind;
|
kind = x_kind;
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
tree_node_counts[(int) kind]++;
|
tree_node_counts[(int) kind]++;
|
tree_node_sizes[(int) kind] += length;
|
tree_node_sizes[(int) kind] += length;
|
#endif
|
#endif
|
|
|
if (code == IDENTIFIER_NODE)
|
if (code == IDENTIFIER_NODE)
|
t = ggc_alloc_zone_pass_stat (length, &tree_id_zone);
|
t = ggc_alloc_zone_pass_stat (length, &tree_id_zone);
|
else
|
else
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
|
|
memset (t, 0, length);
|
memset (t, 0, length);
|
|
|
TREE_SET_CODE (t, code);
|
TREE_SET_CODE (t, code);
|
|
|
switch (type)
|
switch (type)
|
{
|
{
|
case tcc_statement:
|
case tcc_statement:
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_SIDE_EFFECTS (t) = 1;
|
break;
|
break;
|
|
|
case tcc_declaration:
|
case tcc_declaration:
|
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
|
if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS))
|
DECL_IN_SYSTEM_HEADER (t) = in_system_header;
|
DECL_IN_SYSTEM_HEADER (t) = in_system_header;
|
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
|
if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
|
{
|
{
|
if (code != FUNCTION_DECL)
|
if (code != FUNCTION_DECL)
|
DECL_ALIGN (t) = 1;
|
DECL_ALIGN (t) = 1;
|
DECL_USER_ALIGN (t) = 0;
|
DECL_USER_ALIGN (t) = 0;
|
/* We have not yet computed the alias set for this declaration. */
|
/* We have not yet computed the alias set for this declaration. */
|
DECL_POINTER_ALIAS_SET (t) = -1;
|
DECL_POINTER_ALIAS_SET (t) = -1;
|
}
|
}
|
DECL_SOURCE_LOCATION (t) = input_location;
|
DECL_SOURCE_LOCATION (t) = input_location;
|
DECL_UID (t) = next_decl_uid++;
|
DECL_UID (t) = next_decl_uid++;
|
|
|
break;
|
break;
|
|
|
case tcc_type:
|
case tcc_type:
|
TYPE_UID (t) = next_type_uid++;
|
TYPE_UID (t) = next_type_uid++;
|
TYPE_ALIGN (t) = BITS_PER_UNIT;
|
TYPE_ALIGN (t) = BITS_PER_UNIT;
|
TYPE_USER_ALIGN (t) = 0;
|
TYPE_USER_ALIGN (t) = 0;
|
TYPE_MAIN_VARIANT (t) = t;
|
TYPE_MAIN_VARIANT (t) = t;
|
|
|
/* Default to no attributes for type, but let target change that. */
|
/* Default to no attributes for type, but let target change that. */
|
TYPE_ATTRIBUTES (t) = NULL_TREE;
|
TYPE_ATTRIBUTES (t) = NULL_TREE;
|
targetm.set_default_type_attributes (t);
|
targetm.set_default_type_attributes (t);
|
|
|
/* We have not yet computed the alias set for this type. */
|
/* We have not yet computed the alias set for this type. */
|
TYPE_ALIAS_SET (t) = -1;
|
TYPE_ALIAS_SET (t) = -1;
|
break;
|
break;
|
|
|
case tcc_constant:
|
case tcc_constant:
|
TREE_CONSTANT (t) = 1;
|
TREE_CONSTANT (t) = 1;
|
TREE_INVARIANT (t) = 1;
|
TREE_INVARIANT (t) = 1;
|
break;
|
break;
|
|
|
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. */
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_SIDE_EFFECTS (t) = 1;
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
/* Other classes need no special treatment. */
|
/* Other classes need no special treatment. */
|
break;
|
break;
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return a new node with the same contents as NODE except that its
|
/* Return a new node with the same contents as NODE except that its
|
TREE_CHAIN is zero and it has a fresh uid. */
|
TREE_CHAIN is zero and it has a fresh uid. */
|
|
|
tree
|
tree
|
copy_node_stat (tree node MEM_STAT_DECL)
|
copy_node_stat (tree node MEM_STAT_DECL)
|
{
|
{
|
tree t;
|
tree t;
|
enum tree_code code = TREE_CODE (node);
|
enum tree_code code = TREE_CODE (node);
|
size_t length;
|
size_t length;
|
|
|
gcc_assert (code != STATEMENT_LIST);
|
gcc_assert (code != STATEMENT_LIST);
|
|
|
length = tree_size (node);
|
length = tree_size (node);
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
memcpy (t, node, length);
|
memcpy (t, node, length);
|
|
|
TREE_CHAIN (t) = 0;
|
TREE_CHAIN (t) = 0;
|
TREE_ASM_WRITTEN (t) = 0;
|
TREE_ASM_WRITTEN (t) = 0;
|
TREE_VISITED (t) = 0;
|
TREE_VISITED (t) = 0;
|
t->common.ann = 0;
|
t->common.ann = 0;
|
|
|
if (TREE_CODE_CLASS (code) == tcc_declaration)
|
if (TREE_CODE_CLASS (code) == tcc_declaration)
|
{
|
{
|
DECL_UID (t) = next_decl_uid++;
|
DECL_UID (t) = next_decl_uid++;
|
if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
|
if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
|
&& DECL_HAS_VALUE_EXPR_P (node))
|
&& DECL_HAS_VALUE_EXPR_P (node))
|
{
|
{
|
SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
|
SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
|
DECL_HAS_VALUE_EXPR_P (t) = 1;
|
DECL_HAS_VALUE_EXPR_P (t) = 1;
|
}
|
}
|
if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
|
if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
|
{
|
{
|
SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
|
SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
|
DECL_HAS_INIT_PRIORITY_P (t) = 1;
|
DECL_HAS_INIT_PRIORITY_P (t) = 1;
|
}
|
}
|
if (TREE_CODE (node) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (node))
|
if (TREE_CODE (node) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (node))
|
{
|
{
|
SET_DECL_RESTRICT_BASE (t, DECL_GET_RESTRICT_BASE (node));
|
SET_DECL_RESTRICT_BASE (t, DECL_GET_RESTRICT_BASE (node));
|
DECL_BASED_ON_RESTRICT_P (t) = 1;
|
DECL_BASED_ON_RESTRICT_P (t) = 1;
|
}
|
}
|
}
|
}
|
else if (TREE_CODE_CLASS (code) == tcc_type)
|
else if (TREE_CODE_CLASS (code) == tcc_type)
|
{
|
{
|
TYPE_UID (t) = next_type_uid++;
|
TYPE_UID (t) = next_type_uid++;
|
/* The following is so that the debug code for
|
/* The following is so that the debug code for
|
the copy is different from the original type.
|
the copy is different from the original type.
|
The two statements usually duplicate each other
|
The two statements usually duplicate each other
|
(because they clear fields of the same union),
|
(because they clear fields of the same union),
|
but the optimizer should catch that. */
|
but the optimizer should catch that. */
|
TYPE_SYMTAB_POINTER (t) = 0;
|
TYPE_SYMTAB_POINTER (t) = 0;
|
TYPE_SYMTAB_ADDRESS (t) = 0;
|
TYPE_SYMTAB_ADDRESS (t) = 0;
|
|
|
/* Do not copy the values cache. */
|
/* Do not copy the values cache. */
|
if (TYPE_CACHED_VALUES_P(t))
|
if (TYPE_CACHED_VALUES_P(t))
|
{
|
{
|
TYPE_CACHED_VALUES_P (t) = 0;
|
TYPE_CACHED_VALUES_P (t) = 0;
|
TYPE_CACHED_VALUES (t) = NULL_TREE;
|
TYPE_CACHED_VALUES (t) = NULL_TREE;
|
}
|
}
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
|
/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
|
For example, this can copy a list made of TREE_LIST nodes. */
|
For example, this can copy a list made of TREE_LIST nodes. */
|
|
|
tree
|
tree
|
copy_list (tree list)
|
copy_list (tree list)
|
{
|
{
|
tree head;
|
tree head;
|
tree prev, next;
|
tree prev, next;
|
|
|
if (list == 0)
|
if (list == 0)
|
return 0;
|
return 0;
|
|
|
head = prev = copy_node (list);
|
head = prev = copy_node (list);
|
next = TREE_CHAIN (list);
|
next = TREE_CHAIN (list);
|
while (next)
|
while (next)
|
{
|
{
|
TREE_CHAIN (prev) = copy_node (next);
|
TREE_CHAIN (prev) = copy_node (next);
|
prev = TREE_CHAIN (prev);
|
prev = TREE_CHAIN (prev);
|
next = TREE_CHAIN (next);
|
next = TREE_CHAIN (next);
|
}
|
}
|
return head;
|
return head;
|
}
|
}
|
|
|
|
|
/* Create an INT_CST node with a LOW value sign extended. */
|
/* Create an INT_CST node with a LOW value sign extended. */
|
|
|
tree
|
tree
|
build_int_cst (tree type, HOST_WIDE_INT low)
|
build_int_cst (tree type, HOST_WIDE_INT low)
|
{
|
{
|
return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
|
return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
|
}
|
}
|
|
|
/* Create an INT_CST node with a LOW value zero extended. */
|
/* Create an INT_CST node with a LOW value zero extended. */
|
|
|
tree
|
tree
|
build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
|
build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
|
{
|
{
|
return build_int_cst_wide (type, low, 0);
|
return build_int_cst_wide (type, low, 0);
|
}
|
}
|
|
|
/* Create an INT_CST node with a LOW value in TYPE. The value is sign extended
|
/* Create an INT_CST node with a LOW value in TYPE. The value is sign extended
|
if it is negative. This function is similar to build_int_cst, but
|
if it is negative. This function is similar to build_int_cst, but
|
the extra bits outside of the type precision are cleared. Constants
|
the extra bits outside of the type precision are cleared. Constants
|
with these extra bits may confuse the fold so that it detects overflows
|
with these extra bits may confuse the fold so that it detects overflows
|
even in cases when they do not occur, and in general should be avoided.
|
even in cases when they do not occur, and in general should be avoided.
|
We cannot however make this a default behavior of build_int_cst without
|
We cannot however make this a default behavior of build_int_cst without
|
more intrusive changes, since there are parts of gcc that rely on the extra
|
more intrusive changes, since there are parts of gcc that rely on the extra
|
precision of the integer constants. */
|
precision of the integer constants. */
|
|
|
tree
|
tree
|
build_int_cst_type (tree type, HOST_WIDE_INT low)
|
build_int_cst_type (tree type, HOST_WIDE_INT low)
|
{
|
{
|
unsigned HOST_WIDE_INT val = (unsigned HOST_WIDE_INT) low;
|
unsigned HOST_WIDE_INT val = (unsigned HOST_WIDE_INT) low;
|
unsigned HOST_WIDE_INT hi, mask;
|
unsigned HOST_WIDE_INT hi, mask;
|
unsigned bits;
|
unsigned bits;
|
bool signed_p;
|
bool signed_p;
|
bool negative;
|
bool negative;
|
|
|
if (!type)
|
if (!type)
|
type = integer_type_node;
|
type = integer_type_node;
|
|
|
bits = TYPE_PRECISION (type);
|
bits = TYPE_PRECISION (type);
|
signed_p = !TYPE_UNSIGNED (type);
|
signed_p = !TYPE_UNSIGNED (type);
|
|
|
if (bits >= HOST_BITS_PER_WIDE_INT)
|
if (bits >= HOST_BITS_PER_WIDE_INT)
|
negative = (low < 0);
|
negative = (low < 0);
|
else
|
else
|
{
|
{
|
/* If the sign bit is inside precision of LOW, use it to determine
|
/* If the sign bit is inside precision of LOW, use it to determine
|
the sign of the constant. */
|
the sign of the constant. */
|
negative = ((val >> (bits - 1)) & 1) != 0;
|
negative = ((val >> (bits - 1)) & 1) != 0;
|
|
|
/* Mask out the bits outside of the precision of the constant. */
|
/* Mask out the bits outside of the precision of the constant. */
|
mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1;
|
mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1;
|
|
|
if (signed_p && negative)
|
if (signed_p && negative)
|
val |= ~mask;
|
val |= ~mask;
|
else
|
else
|
val &= mask;
|
val &= mask;
|
}
|
}
|
|
|
/* Determine the high bits. */
|
/* Determine the high bits. */
|
hi = (negative ? ~(unsigned HOST_WIDE_INT) 0 : 0);
|
hi = (negative ? ~(unsigned HOST_WIDE_INT) 0 : 0);
|
|
|
/* For unsigned type we need to mask out the bits outside of the type
|
/* For unsigned type we need to mask out the bits outside of the type
|
precision. */
|
precision. */
|
if (!signed_p)
|
if (!signed_p)
|
{
|
{
|
if (bits <= HOST_BITS_PER_WIDE_INT)
|
if (bits <= HOST_BITS_PER_WIDE_INT)
|
hi = 0;
|
hi = 0;
|
else
|
else
|
{
|
{
|
bits -= HOST_BITS_PER_WIDE_INT;
|
bits -= HOST_BITS_PER_WIDE_INT;
|
mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1;
|
mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1;
|
hi &= mask;
|
hi &= mask;
|
}
|
}
|
}
|
}
|
|
|
return build_int_cst_wide (type, val, hi);
|
return build_int_cst_wide (type, val, hi);
|
}
|
}
|
|
|
/* These are the hash table functions for the hash table of INTEGER_CST
|
/* These are the hash table functions for the hash table of INTEGER_CST
|
nodes of a sizetype. */
|
nodes of a sizetype. */
|
|
|
/* Return the hash code code X, an INTEGER_CST. */
|
/* Return the hash code code X, an INTEGER_CST. */
|
|
|
static hashval_t
|
static hashval_t
|
int_cst_hash_hash (const void *x)
|
int_cst_hash_hash (const void *x)
|
{
|
{
|
tree t = (tree) x;
|
tree t = (tree) x;
|
|
|
return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
|
return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
|
^ htab_hash_pointer (TREE_TYPE (t)));
|
^ htab_hash_pointer (TREE_TYPE (t)));
|
}
|
}
|
|
|
/* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
|
/* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
|
is the same as that given by *Y, which is the same. */
|
is the same as that given by *Y, which is the same. */
|
|
|
static int
|
static int
|
int_cst_hash_eq (const void *x, const void *y)
|
int_cst_hash_eq (const void *x, const void *y)
|
{
|
{
|
tree xt = (tree) x;
|
tree xt = (tree) x;
|
tree yt = (tree) y;
|
tree yt = (tree) y;
|
|
|
return (TREE_TYPE (xt) == TREE_TYPE (yt)
|
return (TREE_TYPE (xt) == TREE_TYPE (yt)
|
&& TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
|
&& TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
|
&& TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
|
&& TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
|
}
|
}
|
|
|
/* Create an INT_CST node of TYPE and value HI:LOW. If TYPE is NULL,
|
/* Create an INT_CST node of TYPE and value HI:LOW. If TYPE is NULL,
|
integer_type_node is used. The returned node is always shared.
|
integer_type_node is used. The returned node is always shared.
|
For small integers we use a per-type vector cache, for larger ones
|
For small integers we use a per-type vector cache, for larger ones
|
we use a single hash table. */
|
we use a single hash table. */
|
|
|
tree
|
tree
|
build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
|
build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
|
{
|
{
|
tree t;
|
tree t;
|
int ix = -1;
|
int ix = -1;
|
int limit = 0;
|
int limit = 0;
|
|
|
if (!type)
|
if (!type)
|
type = integer_type_node;
|
type = integer_type_node;
|
|
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
/* Cache NULL pointer. */
|
/* Cache NULL pointer. */
|
if (!hi && !low)
|
if (!hi && !low)
|
{
|
{
|
limit = 1;
|
limit = 1;
|
ix = 0;
|
ix = 0;
|
}
|
}
|
break;
|
break;
|
|
|
case BOOLEAN_TYPE:
|
case BOOLEAN_TYPE:
|
/* Cache false or true. */
|
/* Cache false or true. */
|
limit = 2;
|
limit = 2;
|
if (!hi && low < 2)
|
if (!hi && low < 2)
|
ix = low;
|
ix = low;
|
break;
|
break;
|
|
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
case OFFSET_TYPE:
|
case OFFSET_TYPE:
|
if (TYPE_UNSIGNED (type))
|
if (TYPE_UNSIGNED (type))
|
{
|
{
|
/* Cache 0..N */
|
/* Cache 0..N */
|
limit = INTEGER_SHARE_LIMIT;
|
limit = INTEGER_SHARE_LIMIT;
|
if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
|
if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
|
ix = low;
|
ix = low;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Cache -1..N */
|
/* Cache -1..N */
|
limit = INTEGER_SHARE_LIMIT + 1;
|
limit = INTEGER_SHARE_LIMIT + 1;
|
if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
|
if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
|
ix = low + 1;
|
ix = low + 1;
|
else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
|
else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
|
ix = 0;
|
ix = 0;
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
if (ix >= 0)
|
if (ix >= 0)
|
{
|
{
|
/* Look for it in the type's vector of small shared ints. */
|
/* Look for it in the type's vector of small shared ints. */
|
if (!TYPE_CACHED_VALUES_P (type))
|
if (!TYPE_CACHED_VALUES_P (type))
|
{
|
{
|
TYPE_CACHED_VALUES_P (type) = 1;
|
TYPE_CACHED_VALUES_P (type) = 1;
|
TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
|
TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
|
}
|
}
|
|
|
t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
|
t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
|
if (t)
|
if (t)
|
{
|
{
|
/* Make sure no one is clobbering the shared constant. */
|
/* Make sure no one is clobbering the shared constant. */
|
gcc_assert (TREE_TYPE (t) == type);
|
gcc_assert (TREE_TYPE (t) == type);
|
gcc_assert (TREE_INT_CST_LOW (t) == low);
|
gcc_assert (TREE_INT_CST_LOW (t) == low);
|
gcc_assert (TREE_INT_CST_HIGH (t) == hi);
|
gcc_assert (TREE_INT_CST_HIGH (t) == hi);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Create a new shared int. */
|
/* Create a new shared int. */
|
t = make_node (INTEGER_CST);
|
t = make_node (INTEGER_CST);
|
|
|
TREE_INT_CST_LOW (t) = low;
|
TREE_INT_CST_LOW (t) = low;
|
TREE_INT_CST_HIGH (t) = hi;
|
TREE_INT_CST_HIGH (t) = hi;
|
TREE_TYPE (t) = type;
|
TREE_TYPE (t) = type;
|
|
|
TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
|
TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Use the cache of larger shared ints. */
|
/* Use the cache of larger shared ints. */
|
void **slot;
|
void **slot;
|
|
|
TREE_INT_CST_LOW (int_cst_node) = low;
|
TREE_INT_CST_LOW (int_cst_node) = low;
|
TREE_INT_CST_HIGH (int_cst_node) = hi;
|
TREE_INT_CST_HIGH (int_cst_node) = hi;
|
TREE_TYPE (int_cst_node) = type;
|
TREE_TYPE (int_cst_node) = type;
|
|
|
slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
|
slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
|
t = *slot;
|
t = *slot;
|
if (!t)
|
if (!t)
|
{
|
{
|
/* Insert this one into the hash table. */
|
/* Insert this one into the hash table. */
|
t = int_cst_node;
|
t = int_cst_node;
|
*slot = t;
|
*slot = t;
|
/* Make a new node for next time round. */
|
/* Make a new node for next time round. */
|
int_cst_node = make_node (INTEGER_CST);
|
int_cst_node = make_node (INTEGER_CST);
|
}
|
}
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Builds an integer constant in TYPE such that lowest BITS bits are ones
|
/* Builds an integer constant in TYPE such that lowest BITS bits are ones
|
and the rest are zeros. */
|
and the rest are zeros. */
|
|
|
tree
|
tree
|
build_low_bits_mask (tree type, unsigned bits)
|
build_low_bits_mask (tree type, unsigned bits)
|
{
|
{
|
unsigned HOST_WIDE_INT low;
|
unsigned HOST_WIDE_INT low;
|
HOST_WIDE_INT high;
|
HOST_WIDE_INT high;
|
unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
|
unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
|
|
|
gcc_assert (bits <= TYPE_PRECISION (type));
|
gcc_assert (bits <= TYPE_PRECISION (type));
|
|
|
if (bits == TYPE_PRECISION (type)
|
if (bits == TYPE_PRECISION (type)
|
&& !TYPE_UNSIGNED (type))
|
&& !TYPE_UNSIGNED (type))
|
{
|
{
|
/* Sign extended all-ones mask. */
|
/* Sign extended all-ones mask. */
|
low = all_ones;
|
low = all_ones;
|
high = -1;
|
high = -1;
|
}
|
}
|
else if (bits <= HOST_BITS_PER_WIDE_INT)
|
else if (bits <= HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
|
low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
|
high = 0;
|
high = 0;
|
}
|
}
|
else
|
else
|
{
|
{
|
bits -= HOST_BITS_PER_WIDE_INT;
|
bits -= HOST_BITS_PER_WIDE_INT;
|
low = all_ones;
|
low = all_ones;
|
high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
|
high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
|
}
|
}
|
|
|
return build_int_cst_wide (type, low, high);
|
return build_int_cst_wide (type, low, high);
|
}
|
}
|
|
|
/* Checks that X is integer constant that can be expressed in (unsigned)
|
/* Checks that X is integer constant that can be expressed in (unsigned)
|
HOST_WIDE_INT without loss of precision. */
|
HOST_WIDE_INT without loss of precision. */
|
|
|
bool
|
bool
|
cst_and_fits_in_hwi (tree x)
|
cst_and_fits_in_hwi (tree x)
|
{
|
{
|
if (TREE_CODE (x) != INTEGER_CST)
|
if (TREE_CODE (x) != INTEGER_CST)
|
return false;
|
return false;
|
|
|
if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
|
if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
|
return false;
|
return false;
|
|
|
return (TREE_INT_CST_HIGH (x) == 0
|
return (TREE_INT_CST_HIGH (x) == 0
|
|| TREE_INT_CST_HIGH (x) == -1);
|
|| TREE_INT_CST_HIGH (x) == -1);
|
}
|
}
|
|
|
/* Return a new VECTOR_CST node whose type is TYPE and whose values
|
/* Return a new VECTOR_CST node whose type is TYPE and whose values
|
are in a list pointed to by VALS. */
|
are in a list pointed to by VALS. */
|
|
|
tree
|
tree
|
build_vector (tree type, tree vals)
|
build_vector (tree type, tree vals)
|
{
|
{
|
tree v = make_node (VECTOR_CST);
|
tree v = make_node (VECTOR_CST);
|
int over1 = 0, over2 = 0;
|
int over1 = 0, over2 = 0;
|
tree link;
|
tree link;
|
|
|
TREE_VECTOR_CST_ELTS (v) = vals;
|
TREE_VECTOR_CST_ELTS (v) = vals;
|
TREE_TYPE (v) = type;
|
TREE_TYPE (v) = type;
|
|
|
/* Iterate through elements and check for overflow. */
|
/* Iterate through elements and check for overflow. */
|
for (link = vals; link; link = TREE_CHAIN (link))
|
for (link = vals; link; link = TREE_CHAIN (link))
|
{
|
{
|
tree value = TREE_VALUE (link);
|
tree value = TREE_VALUE (link);
|
|
|
/* Don't crash if we get an address constant. */
|
/* Don't crash if we get an address constant. */
|
if (!CONSTANT_CLASS_P (value))
|
if (!CONSTANT_CLASS_P (value))
|
continue;
|
continue;
|
|
|
over1 |= TREE_OVERFLOW (value);
|
over1 |= TREE_OVERFLOW (value);
|
over2 |= TREE_CONSTANT_OVERFLOW (value);
|
over2 |= TREE_CONSTANT_OVERFLOW (value);
|
}
|
}
|
|
|
TREE_OVERFLOW (v) = over1;
|
TREE_OVERFLOW (v) = over1;
|
TREE_CONSTANT_OVERFLOW (v) = over2;
|
TREE_CONSTANT_OVERFLOW (v) = over2;
|
|
|
return v;
|
return v;
|
}
|
}
|
|
|
/* Return a new VECTOR_CST node whose type is TYPE and whose values
|
/* Return a new VECTOR_CST node whose type is TYPE and whose values
|
are extracted from V, a vector of CONSTRUCTOR_ELT. */
|
are extracted from V, a vector of CONSTRUCTOR_ELT. */
|
|
|
tree
|
tree
|
build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
|
build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
|
{
|
{
|
tree list = NULL_TREE;
|
tree list = NULL_TREE;
|
unsigned HOST_WIDE_INT idx;
|
unsigned HOST_WIDE_INT idx;
|
tree value;
|
tree value;
|
|
|
FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
|
FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
|
list = tree_cons (NULL_TREE, value, list);
|
list = tree_cons (NULL_TREE, value, list);
|
return build_vector (type, nreverse (list));
|
return build_vector (type, nreverse (list));
|
}
|
}
|
|
|
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
|
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
|
are in the VEC pointed to by VALS. */
|
are in the VEC pointed to by VALS. */
|
tree
|
tree
|
build_constructor (tree type, VEC(constructor_elt,gc) *vals)
|
build_constructor (tree type, VEC(constructor_elt,gc) *vals)
|
{
|
{
|
tree c = make_node (CONSTRUCTOR);
|
tree c = make_node (CONSTRUCTOR);
|
TREE_TYPE (c) = type;
|
TREE_TYPE (c) = type;
|
CONSTRUCTOR_ELTS (c) = vals;
|
CONSTRUCTOR_ELTS (c) = vals;
|
return c;
|
return c;
|
}
|
}
|
|
|
/* Build a CONSTRUCTOR node made of a single initializer, with the specified
|
/* Build a CONSTRUCTOR node made of a single initializer, with the specified
|
INDEX and VALUE. */
|
INDEX and VALUE. */
|
tree
|
tree
|
build_constructor_single (tree type, tree index, tree value)
|
build_constructor_single (tree type, tree index, tree value)
|
{
|
{
|
VEC(constructor_elt,gc) *v;
|
VEC(constructor_elt,gc) *v;
|
constructor_elt *elt;
|
constructor_elt *elt;
|
tree t;
|
tree t;
|
|
|
v = VEC_alloc (constructor_elt, gc, 1);
|
v = VEC_alloc (constructor_elt, gc, 1);
|
elt = VEC_quick_push (constructor_elt, v, NULL);
|
elt = VEC_quick_push (constructor_elt, v, NULL);
|
elt->index = index;
|
elt->index = index;
|
elt->value = value;
|
elt->value = value;
|
|
|
t = build_constructor (type, v);
|
t = build_constructor (type, v);
|
TREE_CONSTANT (t) = TREE_CONSTANT (value);
|
TREE_CONSTANT (t) = TREE_CONSTANT (value);
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
|
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
|
are in a list pointed to by VALS. */
|
are in a list pointed to by VALS. */
|
tree
|
tree
|
build_constructor_from_list (tree type, tree vals)
|
build_constructor_from_list (tree type, tree vals)
|
{
|
{
|
tree t, val;
|
tree t, val;
|
VEC(constructor_elt,gc) *v = NULL;
|
VEC(constructor_elt,gc) *v = NULL;
|
bool constant_p = true;
|
bool constant_p = true;
|
|
|
if (vals)
|
if (vals)
|
{
|
{
|
v = VEC_alloc (constructor_elt, gc, list_length (vals));
|
v = VEC_alloc (constructor_elt, gc, list_length (vals));
|
for (t = vals; t; t = TREE_CHAIN (t))
|
for (t = vals; t; t = TREE_CHAIN (t))
|
{
|
{
|
constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
|
constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
|
val = TREE_VALUE (t);
|
val = TREE_VALUE (t);
|
elt->index = TREE_PURPOSE (t);
|
elt->index = TREE_PURPOSE (t);
|
elt->value = val;
|
elt->value = val;
|
if (!TREE_CONSTANT (val))
|
if (!TREE_CONSTANT (val))
|
constant_p = false;
|
constant_p = false;
|
}
|
}
|
}
|
}
|
|
|
t = build_constructor (type, v);
|
t = build_constructor (type, v);
|
TREE_CONSTANT (t) = constant_p;
|
TREE_CONSTANT (t) = constant_p;
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Return a new REAL_CST node whose type is TYPE and value is D. */
|
/* Return a new REAL_CST node whose type is TYPE and value is D. */
|
|
|
tree
|
tree
|
build_real (tree type, REAL_VALUE_TYPE d)
|
build_real (tree type, REAL_VALUE_TYPE d)
|
{
|
{
|
tree v;
|
tree v;
|
REAL_VALUE_TYPE *dp;
|
REAL_VALUE_TYPE *dp;
|
int overflow = 0;
|
int overflow = 0;
|
|
|
/* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
|
/* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
|
Consider doing it via real_convert now. */
|
Consider doing it via real_convert now. */
|
|
|
v = make_node (REAL_CST);
|
v = make_node (REAL_CST);
|
dp = ggc_alloc (sizeof (REAL_VALUE_TYPE));
|
dp = ggc_alloc (sizeof (REAL_VALUE_TYPE));
|
memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
|
memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
|
|
|
TREE_TYPE (v) = type;
|
TREE_TYPE (v) = type;
|
TREE_REAL_CST_PTR (v) = dp;
|
TREE_REAL_CST_PTR (v) = dp;
|
TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
|
TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
|
return v;
|
return v;
|
}
|
}
|
|
|
/* Return a new REAL_CST node whose type is TYPE
|
/* Return a new REAL_CST node whose type is TYPE
|
and whose value is the integer value of the INTEGER_CST node I. */
|
and whose value is the integer value of the INTEGER_CST node I. */
|
|
|
REAL_VALUE_TYPE
|
REAL_VALUE_TYPE
|
real_value_from_int_cst (tree type, tree i)
|
real_value_from_int_cst (tree type, tree i)
|
{
|
{
|
REAL_VALUE_TYPE d;
|
REAL_VALUE_TYPE d;
|
|
|
/* Clear all bits of the real value type so that we can later do
|
/* Clear all bits of the real value type so that we can later do
|
bitwise comparisons to see if two values are the same. */
|
bitwise comparisons to see if two values are the same. */
|
memset (&d, 0, sizeof d);
|
memset (&d, 0, sizeof d);
|
|
|
real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
|
real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
|
TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
|
TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
|
TYPE_UNSIGNED (TREE_TYPE (i)));
|
TYPE_UNSIGNED (TREE_TYPE (i)));
|
return d;
|
return d;
|
}
|
}
|
|
|
/* Given a tree representing an integer constant I, return a tree
|
/* Given a tree representing an integer constant I, return a tree
|
representing the same value as a floating-point constant of type TYPE. */
|
representing the same value as a floating-point constant of type TYPE. */
|
|
|
tree
|
tree
|
build_real_from_int_cst (tree type, tree i)
|
build_real_from_int_cst (tree type, tree i)
|
{
|
{
|
tree v;
|
tree v;
|
int overflow = TREE_OVERFLOW (i);
|
int overflow = TREE_OVERFLOW (i);
|
|
|
v = build_real (type, real_value_from_int_cst (type, i));
|
v = build_real (type, real_value_from_int_cst (type, i));
|
|
|
TREE_OVERFLOW (v) |= overflow;
|
TREE_OVERFLOW (v) |= overflow;
|
TREE_CONSTANT_OVERFLOW (v) |= overflow;
|
TREE_CONSTANT_OVERFLOW (v) |= overflow;
|
return v;
|
return v;
|
}
|
}
|
|
|
/* Return a newly constructed STRING_CST node whose value is
|
/* Return a newly constructed STRING_CST node whose value is
|
the LEN characters at STR.
|
the LEN characters at STR.
|
The TREE_TYPE is not initialized. */
|
The TREE_TYPE is not initialized. */
|
|
|
tree
|
tree
|
build_string (int len, const char *str)
|
build_string (int len, const char *str)
|
{
|
{
|
tree s;
|
tree s;
|
size_t length;
|
size_t length;
|
|
|
/* Do not waste bytes provided by padding of struct tree_string. */
|
/* Do not waste bytes provided by padding of struct tree_string. */
|
length = len + offsetof (struct tree_string, str) + 1;
|
length = len + offsetof (struct tree_string, str) + 1;
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_counts[(int) c_kind]++;
|
tree_node_counts[(int) c_kind]++;
|
tree_node_sizes[(int) c_kind] += length;
|
tree_node_sizes[(int) c_kind] += length;
|
#endif
|
#endif
|
|
|
s = ggc_alloc_tree (length);
|
s = ggc_alloc_tree (length);
|
|
|
memset (s, 0, sizeof (struct tree_common));
|
memset (s, 0, sizeof (struct tree_common));
|
TREE_SET_CODE (s, STRING_CST);
|
TREE_SET_CODE (s, STRING_CST);
|
TREE_CONSTANT (s) = 1;
|
TREE_CONSTANT (s) = 1;
|
TREE_INVARIANT (s) = 1;
|
TREE_INVARIANT (s) = 1;
|
TREE_STRING_LENGTH (s) = len;
|
TREE_STRING_LENGTH (s) = len;
|
memcpy ((char *) TREE_STRING_POINTER (s), str, len);
|
memcpy ((char *) TREE_STRING_POINTER (s), str, len);
|
((char *) TREE_STRING_POINTER (s))[len] = '\0';
|
((char *) TREE_STRING_POINTER (s))[len] = '\0';
|
|
|
return s;
|
return s;
|
}
|
}
|
|
|
/* Return a newly constructed COMPLEX_CST node whose value is
|
/* Return a newly constructed COMPLEX_CST node whose value is
|
specified by the real and imaginary parts REAL and IMAG.
|
specified by the real and imaginary parts REAL and IMAG.
|
Both REAL and IMAG should be constant nodes. TYPE, if specified,
|
Both REAL and IMAG should be constant nodes. TYPE, if specified,
|
will be the type of the COMPLEX_CST; otherwise a new type will be made. */
|
will be the type of the COMPLEX_CST; otherwise a new type will be made. */
|
|
|
tree
|
tree
|
build_complex (tree type, tree real, tree imag)
|
build_complex (tree type, tree real, tree imag)
|
{
|
{
|
tree t = make_node (COMPLEX_CST);
|
tree t = make_node (COMPLEX_CST);
|
|
|
TREE_REALPART (t) = real;
|
TREE_REALPART (t) = real;
|
TREE_IMAGPART (t) = imag;
|
TREE_IMAGPART (t) = imag;
|
TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
|
TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
|
TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
|
TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
|
TREE_CONSTANT_OVERFLOW (t)
|
TREE_CONSTANT_OVERFLOW (t)
|
= TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
|
= TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return a constant of arithmetic type TYPE which is the
|
/* Return a constant of arithmetic type TYPE which is the
|
multiplicative identity of the set TYPE. */
|
multiplicative identity of the set TYPE. */
|
|
|
tree
|
tree
|
build_one_cst (tree type)
|
build_one_cst (tree type)
|
{
|
{
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
|
case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
|
case POINTER_TYPE: case REFERENCE_TYPE:
|
case POINTER_TYPE: case REFERENCE_TYPE:
|
case OFFSET_TYPE:
|
case OFFSET_TYPE:
|
return build_int_cst (type, 1);
|
return build_int_cst (type, 1);
|
|
|
case REAL_TYPE:
|
case REAL_TYPE:
|
return build_real (type, dconst1);
|
return build_real (type, dconst1);
|
|
|
case VECTOR_TYPE:
|
case VECTOR_TYPE:
|
{
|
{
|
tree scalar, cst;
|
tree scalar, cst;
|
int i;
|
int i;
|
|
|
scalar = build_one_cst (TREE_TYPE (type));
|
scalar = build_one_cst (TREE_TYPE (type));
|
|
|
/* Create 'vect_cst_ = {cst,cst,...,cst}' */
|
/* Create 'vect_cst_ = {cst,cst,...,cst}' */
|
cst = NULL_TREE;
|
cst = NULL_TREE;
|
for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
|
for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
|
cst = tree_cons (NULL_TREE, scalar, cst);
|
cst = tree_cons (NULL_TREE, scalar, cst);
|
|
|
return build_vector (type, cst);
|
return build_vector (type, cst);
|
}
|
}
|
|
|
case COMPLEX_TYPE:
|
case COMPLEX_TYPE:
|
return build_complex (type,
|
return build_complex (type,
|
build_one_cst (TREE_TYPE (type)),
|
build_one_cst (TREE_TYPE (type)),
|
fold_convert (TREE_TYPE (type), integer_zero_node));
|
fold_convert (TREE_TYPE (type), integer_zero_node));
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Build a BINFO with LEN language slots. */
|
/* Build a BINFO with LEN language slots. */
|
|
|
tree
|
tree
|
make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
|
make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
|
{
|
{
|
tree t;
|
tree t;
|
size_t length = (offsetof (struct tree_binfo, base_binfos)
|
size_t length = (offsetof (struct tree_binfo, base_binfos)
|
+ VEC_embedded_size (tree, base_binfos));
|
+ VEC_embedded_size (tree, base_binfos));
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_counts[(int) binfo_kind]++;
|
tree_node_counts[(int) binfo_kind]++;
|
tree_node_sizes[(int) binfo_kind] += length;
|
tree_node_sizes[(int) binfo_kind] += length;
|
#endif
|
#endif
|
|
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
|
|
memset (t, 0, offsetof (struct tree_binfo, base_binfos));
|
memset (t, 0, offsetof (struct tree_binfo, base_binfos));
|
|
|
TREE_SET_CODE (t, TREE_BINFO);
|
TREE_SET_CODE (t, TREE_BINFO);
|
|
|
VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
|
VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Build a newly constructed TREE_VEC node of length LEN. */
|
/* Build a newly constructed TREE_VEC node of length LEN. */
|
|
|
tree
|
tree
|
make_tree_vec_stat (int len MEM_STAT_DECL)
|
make_tree_vec_stat (int len MEM_STAT_DECL)
|
{
|
{
|
tree t;
|
tree t;
|
int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
|
int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_counts[(int) vec_kind]++;
|
tree_node_counts[(int) vec_kind]++;
|
tree_node_sizes[(int) vec_kind] += length;
|
tree_node_sizes[(int) vec_kind] += length;
|
#endif
|
#endif
|
|
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
|
|
memset (t, 0, length);
|
memset (t, 0, length);
|
|
|
TREE_SET_CODE (t, TREE_VEC);
|
TREE_SET_CODE (t, TREE_VEC);
|
TREE_VEC_LENGTH (t) = len;
|
TREE_VEC_LENGTH (t) = len;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return 1 if EXPR is the integer constant zero or a complex constant
|
/* Return 1 if EXPR is the integer constant zero or a complex constant
|
of zero. */
|
of zero. */
|
|
|
int
|
int
|
integer_zerop (tree expr)
|
integer_zerop (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == INTEGER_CST
|
return ((TREE_CODE (expr) == INTEGER_CST
|
&& TREE_INT_CST_LOW (expr) == 0
|
&& TREE_INT_CST_LOW (expr) == 0
|
&& TREE_INT_CST_HIGH (expr) == 0)
|
&& TREE_INT_CST_HIGH (expr) == 0)
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& integer_zerop (TREE_REALPART (expr))
|
&& integer_zerop (TREE_REALPART (expr))
|
&& integer_zerop (TREE_IMAGPART (expr))));
|
&& integer_zerop (TREE_IMAGPART (expr))));
|
}
|
}
|
|
|
/* Return 1 if EXPR is the integer constant one or the corresponding
|
/* Return 1 if EXPR is the integer constant one or the corresponding
|
complex constant. */
|
complex constant. */
|
|
|
int
|
int
|
integer_onep (tree expr)
|
integer_onep (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == INTEGER_CST
|
return ((TREE_CODE (expr) == INTEGER_CST
|
&& TREE_INT_CST_LOW (expr) == 1
|
&& TREE_INT_CST_LOW (expr) == 1
|
&& TREE_INT_CST_HIGH (expr) == 0)
|
&& TREE_INT_CST_HIGH (expr) == 0)
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& integer_onep (TREE_REALPART (expr))
|
&& integer_onep (TREE_REALPART (expr))
|
&& integer_zerop (TREE_IMAGPART (expr))));
|
&& integer_zerop (TREE_IMAGPART (expr))));
|
}
|
}
|
|
|
/* Return 1 if EXPR is an integer containing all 1's in as much precision as
|
/* Return 1 if EXPR is an integer containing all 1's in as much precision as
|
it contains. Likewise for the corresponding complex constant. */
|
it contains. Likewise for the corresponding complex constant. */
|
|
|
int
|
int
|
integer_all_onesp (tree expr)
|
integer_all_onesp (tree expr)
|
{
|
{
|
int prec;
|
int prec;
|
int uns;
|
int uns;
|
|
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
if (TREE_CODE (expr) == COMPLEX_CST
|
if (TREE_CODE (expr) == COMPLEX_CST
|
&& integer_all_onesp (TREE_REALPART (expr))
|
&& integer_all_onesp (TREE_REALPART (expr))
|
&& integer_zerop (TREE_IMAGPART (expr)))
|
&& integer_zerop (TREE_IMAGPART (expr)))
|
return 1;
|
return 1;
|
|
|
else if (TREE_CODE (expr) != INTEGER_CST)
|
else if (TREE_CODE (expr) != INTEGER_CST)
|
return 0;
|
return 0;
|
|
|
uns = TYPE_UNSIGNED (TREE_TYPE (expr));
|
uns = TYPE_UNSIGNED (TREE_TYPE (expr));
|
if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
|
if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
|
&& TREE_INT_CST_HIGH (expr) == -1)
|
&& TREE_INT_CST_HIGH (expr) == -1)
|
return 1;
|
return 1;
|
if (!uns)
|
if (!uns)
|
return 0;
|
return 0;
|
|
|
/* Note that using TYPE_PRECISION here is wrong. We care about the
|
/* Note that using TYPE_PRECISION here is wrong. We care about the
|
actual bits, not the (arbitrary) range of the type. */
|
actual bits, not the (arbitrary) range of the type. */
|
prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
|
prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
|
if (prec >= HOST_BITS_PER_WIDE_INT)
|
if (prec >= HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
HOST_WIDE_INT high_value;
|
HOST_WIDE_INT high_value;
|
int shift_amount;
|
int shift_amount;
|
|
|
shift_amount = prec - HOST_BITS_PER_WIDE_INT;
|
shift_amount = prec - HOST_BITS_PER_WIDE_INT;
|
|
|
/* Can not handle precisions greater than twice the host int size. */
|
/* Can not handle precisions greater than twice the host int size. */
|
gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
|
gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
|
if (shift_amount == HOST_BITS_PER_WIDE_INT)
|
if (shift_amount == HOST_BITS_PER_WIDE_INT)
|
/* Shifting by the host word size is undefined according to the ANSI
|
/* Shifting by the host word size is undefined according to the ANSI
|
standard, so we must handle this as a special case. */
|
standard, so we must handle this as a special case. */
|
high_value = -1;
|
high_value = -1;
|
else
|
else
|
high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
|
high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
|
|
|
return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
|
return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
|
&& TREE_INT_CST_HIGH (expr) == high_value);
|
&& TREE_INT_CST_HIGH (expr) == high_value);
|
}
|
}
|
else
|
else
|
return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
|
return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
|
}
|
}
|
|
|
/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
|
/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
|
one bit on). */
|
one bit on). */
|
|
|
int
|
int
|
integer_pow2p (tree expr)
|
integer_pow2p (tree expr)
|
{
|
{
|
int prec;
|
int prec;
|
HOST_WIDE_INT high, low;
|
HOST_WIDE_INT high, low;
|
|
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
if (TREE_CODE (expr) == COMPLEX_CST
|
if (TREE_CODE (expr) == COMPLEX_CST
|
&& integer_pow2p (TREE_REALPART (expr))
|
&& integer_pow2p (TREE_REALPART (expr))
|
&& integer_zerop (TREE_IMAGPART (expr)))
|
&& integer_zerop (TREE_IMAGPART (expr)))
|
return 1;
|
return 1;
|
|
|
if (TREE_CODE (expr) != INTEGER_CST)
|
if (TREE_CODE (expr) != INTEGER_CST)
|
return 0;
|
return 0;
|
|
|
prec = (POINTER_TYPE_P (TREE_TYPE (expr))
|
prec = (POINTER_TYPE_P (TREE_TYPE (expr))
|
? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
|
? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
|
high = TREE_INT_CST_HIGH (expr);
|
high = TREE_INT_CST_HIGH (expr);
|
low = TREE_INT_CST_LOW (expr);
|
low = TREE_INT_CST_LOW (expr);
|
|
|
/* First clear all bits that are beyond the type's precision in case
|
/* First clear all bits that are beyond the type's precision in case
|
we've been sign extended. */
|
we've been sign extended. */
|
|
|
if (prec == 2 * HOST_BITS_PER_WIDE_INT)
|
if (prec == 2 * HOST_BITS_PER_WIDE_INT)
|
;
|
;
|
else if (prec > HOST_BITS_PER_WIDE_INT)
|
else if (prec > HOST_BITS_PER_WIDE_INT)
|
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
|
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
|
else
|
else
|
{
|
{
|
high = 0;
|
high = 0;
|
if (prec < HOST_BITS_PER_WIDE_INT)
|
if (prec < HOST_BITS_PER_WIDE_INT)
|
low &= ~((HOST_WIDE_INT) (-1) << prec);
|
low &= ~((HOST_WIDE_INT) (-1) << prec);
|
}
|
}
|
|
|
if (high == 0 && low == 0)
|
if (high == 0 && low == 0)
|
return 0;
|
return 0;
|
|
|
return ((high == 0 && (low & (low - 1)) == 0)
|
return ((high == 0 && (low & (low - 1)) == 0)
|
|| (low == 0 && (high & (high - 1)) == 0));
|
|| (low == 0 && (high & (high - 1)) == 0));
|
}
|
}
|
|
|
/* Return 1 if EXPR is an integer constant other than zero or a
|
/* Return 1 if EXPR is an integer constant other than zero or a
|
complex constant other than zero. */
|
complex constant other than zero. */
|
|
|
int
|
int
|
integer_nonzerop (tree expr)
|
integer_nonzerop (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == INTEGER_CST
|
return ((TREE_CODE (expr) == INTEGER_CST
|
&& (TREE_INT_CST_LOW (expr) != 0
|
&& (TREE_INT_CST_LOW (expr) != 0
|
|| TREE_INT_CST_HIGH (expr) != 0))
|
|| TREE_INT_CST_HIGH (expr) != 0))
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& (integer_nonzerop (TREE_REALPART (expr))
|
&& (integer_nonzerop (TREE_REALPART (expr))
|
|| integer_nonzerop (TREE_IMAGPART (expr)))));
|
|| integer_nonzerop (TREE_IMAGPART (expr)))));
|
}
|
}
|
|
|
/* Return the power of two represented by a tree node known to be a
|
/* Return the power of two represented by a tree node known to be a
|
power of two. */
|
power of two. */
|
|
|
int
|
int
|
tree_log2 (tree expr)
|
tree_log2 (tree expr)
|
{
|
{
|
int prec;
|
int prec;
|
HOST_WIDE_INT high, low;
|
HOST_WIDE_INT high, low;
|
|
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
if (TREE_CODE (expr) == COMPLEX_CST)
|
if (TREE_CODE (expr) == COMPLEX_CST)
|
return tree_log2 (TREE_REALPART (expr));
|
return tree_log2 (TREE_REALPART (expr));
|
|
|
prec = (POINTER_TYPE_P (TREE_TYPE (expr))
|
prec = (POINTER_TYPE_P (TREE_TYPE (expr))
|
? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
|
? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
|
|
|
high = TREE_INT_CST_HIGH (expr);
|
high = TREE_INT_CST_HIGH (expr);
|
low = TREE_INT_CST_LOW (expr);
|
low = TREE_INT_CST_LOW (expr);
|
|
|
/* First clear all bits that are beyond the type's precision in case
|
/* First clear all bits that are beyond the type's precision in case
|
we've been sign extended. */
|
we've been sign extended. */
|
|
|
if (prec == 2 * HOST_BITS_PER_WIDE_INT)
|
if (prec == 2 * HOST_BITS_PER_WIDE_INT)
|
;
|
;
|
else if (prec > HOST_BITS_PER_WIDE_INT)
|
else if (prec > HOST_BITS_PER_WIDE_INT)
|
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
|
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
|
else
|
else
|
{
|
{
|
high = 0;
|
high = 0;
|
if (prec < HOST_BITS_PER_WIDE_INT)
|
if (prec < HOST_BITS_PER_WIDE_INT)
|
low &= ~((HOST_WIDE_INT) (-1) << prec);
|
low &= ~((HOST_WIDE_INT) (-1) << prec);
|
}
|
}
|
|
|
return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
|
return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
|
: exact_log2 (low));
|
: exact_log2 (low));
|
}
|
}
|
|
|
/* Similar, but return the largest integer Y such that 2 ** Y is less
|
/* Similar, but return the largest integer Y such that 2 ** Y is less
|
than or equal to EXPR. */
|
than or equal to EXPR. */
|
|
|
int
|
int
|
tree_floor_log2 (tree expr)
|
tree_floor_log2 (tree expr)
|
{
|
{
|
int prec;
|
int prec;
|
HOST_WIDE_INT high, low;
|
HOST_WIDE_INT high, low;
|
|
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
if (TREE_CODE (expr) == COMPLEX_CST)
|
if (TREE_CODE (expr) == COMPLEX_CST)
|
return tree_log2 (TREE_REALPART (expr));
|
return tree_log2 (TREE_REALPART (expr));
|
|
|
prec = (POINTER_TYPE_P (TREE_TYPE (expr))
|
prec = (POINTER_TYPE_P (TREE_TYPE (expr))
|
? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
|
? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
|
|
|
high = TREE_INT_CST_HIGH (expr);
|
high = TREE_INT_CST_HIGH (expr);
|
low = TREE_INT_CST_LOW (expr);
|
low = TREE_INT_CST_LOW (expr);
|
|
|
/* First clear all bits that are beyond the type's precision in case
|
/* First clear all bits that are beyond the type's precision in case
|
we've been sign extended. Ignore if type's precision hasn't been set
|
we've been sign extended. Ignore if type's precision hasn't been set
|
since what we are doing is setting it. */
|
since what we are doing is setting it. */
|
|
|
if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
|
if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
|
;
|
;
|
else if (prec > HOST_BITS_PER_WIDE_INT)
|
else if (prec > HOST_BITS_PER_WIDE_INT)
|
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
|
high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
|
else
|
else
|
{
|
{
|
high = 0;
|
high = 0;
|
if (prec < HOST_BITS_PER_WIDE_INT)
|
if (prec < HOST_BITS_PER_WIDE_INT)
|
low &= ~((HOST_WIDE_INT) (-1) << prec);
|
low &= ~((HOST_WIDE_INT) (-1) << prec);
|
}
|
}
|
|
|
return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
|
return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
|
: floor_log2 (low));
|
: floor_log2 (low));
|
}
|
}
|
|
|
/* Return 1 if EXPR is the real constant zero. */
|
/* Return 1 if EXPR is the real constant zero. */
|
|
|
int
|
int
|
real_zerop (tree expr)
|
real_zerop (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == REAL_CST
|
return ((TREE_CODE (expr) == REAL_CST
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& real_zerop (TREE_REALPART (expr))
|
&& real_zerop (TREE_REALPART (expr))
|
&& real_zerop (TREE_IMAGPART (expr))));
|
&& real_zerop (TREE_IMAGPART (expr))));
|
}
|
}
|
|
|
/* Return 1 if EXPR is the real constant one in real or complex form. */
|
/* Return 1 if EXPR is the real constant one in real or complex form. */
|
|
|
int
|
int
|
real_onep (tree expr)
|
real_onep (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == REAL_CST
|
return ((TREE_CODE (expr) == REAL_CST
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& real_onep (TREE_REALPART (expr))
|
&& real_onep (TREE_REALPART (expr))
|
&& real_zerop (TREE_IMAGPART (expr))));
|
&& real_zerop (TREE_IMAGPART (expr))));
|
}
|
}
|
|
|
/* Return 1 if EXPR is the real constant two. */
|
/* Return 1 if EXPR is the real constant two. */
|
|
|
int
|
int
|
real_twop (tree expr)
|
real_twop (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == REAL_CST
|
return ((TREE_CODE (expr) == REAL_CST
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& real_twop (TREE_REALPART (expr))
|
&& real_twop (TREE_REALPART (expr))
|
&& real_zerop (TREE_IMAGPART (expr))));
|
&& real_zerop (TREE_IMAGPART (expr))));
|
}
|
}
|
|
|
/* Return 1 if EXPR is the real constant minus one. */
|
/* Return 1 if EXPR is the real constant minus one. */
|
|
|
int
|
int
|
real_minus_onep (tree expr)
|
real_minus_onep (tree expr)
|
{
|
{
|
STRIP_NOPS (expr);
|
STRIP_NOPS (expr);
|
|
|
return ((TREE_CODE (expr) == REAL_CST
|
return ((TREE_CODE (expr) == REAL_CST
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
|
&& REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
|| (TREE_CODE (expr) == COMPLEX_CST
|
&& real_minus_onep (TREE_REALPART (expr))
|
&& real_minus_onep (TREE_REALPART (expr))
|
&& real_zerop (TREE_IMAGPART (expr))));
|
&& real_zerop (TREE_IMAGPART (expr))));
|
}
|
}
|
|
|
/* Nonzero if EXP is a constant or a cast of a constant. */
|
/* Nonzero if EXP is a constant or a cast of a constant. */
|
|
|
int
|
int
|
really_constant_p (tree exp)
|
really_constant_p (tree exp)
|
{
|
{
|
/* This is not quite the same as STRIP_NOPS. It does more. */
|
/* This is not quite the same as STRIP_NOPS. It does more. */
|
while (TREE_CODE (exp) == NOP_EXPR
|
while (TREE_CODE (exp) == NOP_EXPR
|
|| TREE_CODE (exp) == CONVERT_EXPR
|
|| TREE_CODE (exp) == CONVERT_EXPR
|
|| TREE_CODE (exp) == NON_LVALUE_EXPR)
|
|| TREE_CODE (exp) == NON_LVALUE_EXPR)
|
exp = TREE_OPERAND (exp, 0);
|
exp = TREE_OPERAND (exp, 0);
|
return TREE_CONSTANT (exp);
|
return TREE_CONSTANT (exp);
|
}
|
}
|
|
|
/* Return first list element whose TREE_VALUE is ELEM.
|
/* Return first list element whose TREE_VALUE is ELEM.
|
Return 0 if ELEM is not in LIST. */
|
Return 0 if ELEM is not in LIST. */
|
|
|
tree
|
tree
|
value_member (tree elem, tree list)
|
value_member (tree elem, tree list)
|
{
|
{
|
while (list)
|
while (list)
|
{
|
{
|
if (elem == TREE_VALUE (list))
|
if (elem == TREE_VALUE (list))
|
return list;
|
return list;
|
list = TREE_CHAIN (list);
|
list = TREE_CHAIN (list);
|
}
|
}
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Return first list element whose TREE_PURPOSE is ELEM.
|
/* Return first list element whose TREE_PURPOSE is ELEM.
|
Return 0 if ELEM is not in LIST. */
|
Return 0 if ELEM is not in LIST. */
|
|
|
tree
|
tree
|
purpose_member (tree elem, tree list)
|
purpose_member (tree elem, tree list)
|
{
|
{
|
while (list)
|
while (list)
|
{
|
{
|
if (elem == TREE_PURPOSE (list))
|
if (elem == TREE_PURPOSE (list))
|
return list;
|
return list;
|
list = TREE_CHAIN (list);
|
list = TREE_CHAIN (list);
|
}
|
}
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Return nonzero if ELEM is part of the chain CHAIN. */
|
/* Return nonzero if ELEM is part of the chain CHAIN. */
|
|
|
int
|
int
|
chain_member (tree elem, tree chain)
|
chain_member (tree elem, tree chain)
|
{
|
{
|
while (chain)
|
while (chain)
|
{
|
{
|
if (elem == chain)
|
if (elem == chain)
|
return 1;
|
return 1;
|
chain = TREE_CHAIN (chain);
|
chain = TREE_CHAIN (chain);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return the length of a chain of nodes chained through TREE_CHAIN.
|
/* Return the length of a chain of nodes chained through TREE_CHAIN.
|
We expect a null pointer to mark the end of the chain.
|
We expect a null pointer to mark the end of the chain.
|
This is the Lisp primitive `length'. */
|
This is the Lisp primitive `length'. */
|
|
|
int
|
int
|
list_length (tree t)
|
list_length (tree t)
|
{
|
{
|
tree p = t;
|
tree p = t;
|
#ifdef ENABLE_TREE_CHECKING
|
#ifdef ENABLE_TREE_CHECKING
|
tree q = t;
|
tree q = t;
|
#endif
|
#endif
|
int len = 0;
|
int len = 0;
|
|
|
while (p)
|
while (p)
|
{
|
{
|
p = TREE_CHAIN (p);
|
p = TREE_CHAIN (p);
|
#ifdef ENABLE_TREE_CHECKING
|
#ifdef ENABLE_TREE_CHECKING
|
if (len % 2)
|
if (len % 2)
|
q = TREE_CHAIN (q);
|
q = TREE_CHAIN (q);
|
gcc_assert (p != q);
|
gcc_assert (p != q);
|
#endif
|
#endif
|
len++;
|
len++;
|
}
|
}
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
/* Returns the number of FIELD_DECLs in TYPE. */
|
/* Returns the number of FIELD_DECLs in TYPE. */
|
|
|
int
|
int
|
fields_length (tree type)
|
fields_length (tree type)
|
{
|
{
|
tree t = TYPE_FIELDS (type);
|
tree t = TYPE_FIELDS (type);
|
int count = 0;
|
int count = 0;
|
|
|
for (; t; t = TREE_CHAIN (t))
|
for (; t; t = TREE_CHAIN (t))
|
if (TREE_CODE (t) == FIELD_DECL)
|
if (TREE_CODE (t) == FIELD_DECL)
|
++count;
|
++count;
|
|
|
return count;
|
return count;
|
}
|
}
|
|
|
/* Concatenate two chains of nodes (chained through TREE_CHAIN)
|
/* Concatenate two chains of nodes (chained through TREE_CHAIN)
|
by modifying the last node in chain 1 to point to chain 2.
|
by modifying the last node in chain 1 to point to chain 2.
|
This is the Lisp primitive `nconc'. */
|
This is the Lisp primitive `nconc'. */
|
|
|
tree
|
tree
|
chainon (tree op1, tree op2)
|
chainon (tree op1, tree op2)
|
{
|
{
|
tree t1;
|
tree t1;
|
|
|
if (!op1)
|
if (!op1)
|
return op2;
|
return op2;
|
if (!op2)
|
if (!op2)
|
return op1;
|
return op1;
|
|
|
for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
|
for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
|
continue;
|
continue;
|
TREE_CHAIN (t1) = op2;
|
TREE_CHAIN (t1) = op2;
|
|
|
#ifdef ENABLE_TREE_CHECKING
|
#ifdef ENABLE_TREE_CHECKING
|
{
|
{
|
tree t2;
|
tree t2;
|
for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
|
for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
|
gcc_assert (t2 != t1);
|
gcc_assert (t2 != t1);
|
}
|
}
|
#endif
|
#endif
|
|
|
return op1;
|
return op1;
|
}
|
}
|
|
|
/* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
|
/* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
|
|
|
tree
|
tree
|
tree_last (tree chain)
|
tree_last (tree chain)
|
{
|
{
|
tree next;
|
tree next;
|
if (chain)
|
if (chain)
|
while ((next = TREE_CHAIN (chain)))
|
while ((next = TREE_CHAIN (chain)))
|
chain = next;
|
chain = next;
|
return chain;
|
return chain;
|
}
|
}
|
|
|
/* Reverse the order of elements in the chain T,
|
/* Reverse the order of elements in the chain T,
|
and return the new head of the chain (old last element). */
|
and return the new head of the chain (old last element). */
|
|
|
tree
|
tree
|
nreverse (tree t)
|
nreverse (tree t)
|
{
|
{
|
tree prev = 0, decl, next;
|
tree prev = 0, decl, next;
|
for (decl = t; decl; decl = next)
|
for (decl = t; decl; decl = next)
|
{
|
{
|
next = TREE_CHAIN (decl);
|
next = TREE_CHAIN (decl);
|
TREE_CHAIN (decl) = prev;
|
TREE_CHAIN (decl) = prev;
|
prev = decl;
|
prev = decl;
|
}
|
}
|
return prev;
|
return prev;
|
}
|
}
|
|
|
/* Return a newly created TREE_LIST node whose
|
/* Return a newly created TREE_LIST node whose
|
purpose and value fields are PARM and VALUE. */
|
purpose and value fields are PARM and VALUE. */
|
|
|
tree
|
tree
|
build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
|
build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
|
{
|
{
|
tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
|
tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
|
TREE_PURPOSE (t) = parm;
|
TREE_PURPOSE (t) = parm;
|
TREE_VALUE (t) = value;
|
TREE_VALUE (t) = value;
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return a newly created TREE_LIST node whose
|
/* Return a newly created TREE_LIST node whose
|
purpose and value fields are PURPOSE and VALUE
|
purpose and value fields are PURPOSE and VALUE
|
and whose TREE_CHAIN is CHAIN. */
|
and whose TREE_CHAIN is CHAIN. */
|
|
|
tree
|
tree
|
tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
|
tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
|
{
|
{
|
tree node;
|
tree node;
|
|
|
node = ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
|
node = ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
|
|
|
memset (node, 0, sizeof (struct tree_common));
|
memset (node, 0, sizeof (struct tree_common));
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_counts[(int) x_kind]++;
|
tree_node_counts[(int) x_kind]++;
|
tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
|
tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
|
#endif
|
#endif
|
|
|
TREE_SET_CODE (node, TREE_LIST);
|
TREE_SET_CODE (node, TREE_LIST);
|
TREE_CHAIN (node) = chain;
|
TREE_CHAIN (node) = chain;
|
TREE_PURPOSE (node) = purpose;
|
TREE_PURPOSE (node) = purpose;
|
TREE_VALUE (node) = value;
|
TREE_VALUE (node) = value;
|
return node;
|
return node;
|
}
|
}
|
|
|
|
|
/* Return the size nominally occupied by an object of type TYPE
|
/* Return the size nominally occupied by an object of type TYPE
|
when it resides in memory. The value is measured in units of bytes,
|
when it resides in memory. The value is measured in units of bytes,
|
and its data type is that normally used for type sizes
|
and its data type is that normally used for type sizes
|
(which is the first type created by make_signed_type or
|
(which is the first type created by make_signed_type or
|
make_unsigned_type). */
|
make_unsigned_type). */
|
|
|
tree
|
tree
|
size_in_bytes (tree type)
|
size_in_bytes (tree type)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
return integer_zero_node;
|
return integer_zero_node;
|
|
|
type = TYPE_MAIN_VARIANT (type);
|
type = TYPE_MAIN_VARIANT (type);
|
t = TYPE_SIZE_UNIT (type);
|
t = TYPE_SIZE_UNIT (type);
|
|
|
if (t == 0)
|
if (t == 0)
|
{
|
{
|
lang_hooks.types.incomplete_type_error (NULL_TREE, type);
|
lang_hooks.types.incomplete_type_error (NULL_TREE, type);
|
return size_zero_node;
|
return size_zero_node;
|
}
|
}
|
|
|
if (TREE_CODE (t) == INTEGER_CST)
|
if (TREE_CODE (t) == INTEGER_CST)
|
t = force_fit_type (t, 0, false, false);
|
t = force_fit_type (t, 0, false, false);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return the size of TYPE (in bytes) as a wide integer
|
/* Return the size of TYPE (in bytes) as a wide integer
|
or return -1 if the size can vary or is larger than an integer. */
|
or return -1 if the size can vary or is larger than an integer. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
int_size_in_bytes (tree type)
|
int_size_in_bytes (tree type)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
return 0;
|
return 0;
|
|
|
type = TYPE_MAIN_VARIANT (type);
|
type = TYPE_MAIN_VARIANT (type);
|
t = TYPE_SIZE_UNIT (type);
|
t = TYPE_SIZE_UNIT (type);
|
if (t == 0
|
if (t == 0
|
|| TREE_CODE (t) != INTEGER_CST
|
|| TREE_CODE (t) != INTEGER_CST
|
|| TREE_INT_CST_HIGH (t) != 0
|
|| TREE_INT_CST_HIGH (t) != 0
|
/* If the result would appear negative, it's too big to represent. */
|
/* If the result would appear negative, it's too big to represent. */
|
|| (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
|
|| (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
|
return -1;
|
return -1;
|
|
|
return TREE_INT_CST_LOW (t);
|
return TREE_INT_CST_LOW (t);
|
}
|
}
|
|
|
/* Return the maximum size of TYPE (in bytes) as a wide integer
|
/* Return the maximum size of TYPE (in bytes) as a wide integer
|
or return -1 if the size can vary or is larger than an integer. */
|
or return -1 if the size can vary or is larger than an integer. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
max_int_size_in_bytes (tree type)
|
max_int_size_in_bytes (tree type)
|
{
|
{
|
HOST_WIDE_INT size = -1;
|
HOST_WIDE_INT size = -1;
|
tree size_tree;
|
tree size_tree;
|
|
|
/* If this is an array type, check for a possible MAX_SIZE attached. */
|
/* If this is an array type, check for a possible MAX_SIZE attached. */
|
|
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
if (TREE_CODE (type) == ARRAY_TYPE)
|
{
|
{
|
size_tree = TYPE_ARRAY_MAX_SIZE (type);
|
size_tree = TYPE_ARRAY_MAX_SIZE (type);
|
|
|
if (size_tree && host_integerp (size_tree, 1))
|
if (size_tree && host_integerp (size_tree, 1))
|
size = tree_low_cst (size_tree, 1);
|
size = tree_low_cst (size_tree, 1);
|
}
|
}
|
|
|
/* If we still haven't been able to get a size, see if the language
|
/* If we still haven't been able to get a size, see if the language
|
can compute a maximum size. */
|
can compute a maximum size. */
|
|
|
if (size == -1)
|
if (size == -1)
|
{
|
{
|
size_tree = lang_hooks.types.max_size (type);
|
size_tree = lang_hooks.types.max_size (type);
|
|
|
if (size_tree && host_integerp (size_tree, 1))
|
if (size_tree && host_integerp (size_tree, 1))
|
size = tree_low_cst (size_tree, 1);
|
size = tree_low_cst (size_tree, 1);
|
}
|
}
|
|
|
return size;
|
return size;
|
}
|
}
|
|
|
/* Return the bit position of FIELD, in bits from the start of the record.
|
/* Return the bit position of FIELD, in bits from the start of the record.
|
This is a tree of type bitsizetype. */
|
This is a tree of type bitsizetype. */
|
|
|
tree
|
tree
|
bit_position (tree field)
|
bit_position (tree field)
|
{
|
{
|
return bit_from_pos (DECL_FIELD_OFFSET (field),
|
return bit_from_pos (DECL_FIELD_OFFSET (field),
|
DECL_FIELD_BIT_OFFSET (field));
|
DECL_FIELD_BIT_OFFSET (field));
|
}
|
}
|
|
|
/* Likewise, but return as an integer. It must be representable in
|
/* Likewise, but return as an integer. It must be representable in
|
that way (since it could be a signed value, we don't have the
|
that way (since it could be a signed value, we don't have the
|
option of returning -1 like int_size_in_byte can. */
|
option of returning -1 like int_size_in_byte can. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
int_bit_position (tree field)
|
int_bit_position (tree field)
|
{
|
{
|
return tree_low_cst (bit_position (field), 0);
|
return tree_low_cst (bit_position (field), 0);
|
}
|
}
|
|
|
/* Return the byte position of FIELD, in bytes from the start of the record.
|
/* Return the byte position of FIELD, in bytes from the start of the record.
|
This is a tree of type sizetype. */
|
This is a tree of type sizetype. */
|
|
|
tree
|
tree
|
byte_position (tree field)
|
byte_position (tree field)
|
{
|
{
|
return byte_from_pos (DECL_FIELD_OFFSET (field),
|
return byte_from_pos (DECL_FIELD_OFFSET (field),
|
DECL_FIELD_BIT_OFFSET (field));
|
DECL_FIELD_BIT_OFFSET (field));
|
}
|
}
|
|
|
/* Likewise, but return as an integer. It must be representable in
|
/* Likewise, but return as an integer. It must be representable in
|
that way (since it could be a signed value, we don't have the
|
that way (since it could be a signed value, we don't have the
|
option of returning -1 like int_size_in_byte can. */
|
option of returning -1 like int_size_in_byte can. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
int_byte_position (tree field)
|
int_byte_position (tree field)
|
{
|
{
|
return tree_low_cst (byte_position (field), 0);
|
return tree_low_cst (byte_position (field), 0);
|
}
|
}
|
|
|
/* Return the strictest alignment, in bits, that T is known to have. */
|
/* Return the strictest alignment, in bits, that T is known to have. */
|
|
|
unsigned int
|
unsigned int
|
expr_align (tree t)
|
expr_align (tree t)
|
{
|
{
|
unsigned int align0, align1;
|
unsigned int align0, align1;
|
|
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
|
case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
|
/* If we have conversions, we know that the alignment of the
|
/* If we have conversions, we know that the alignment of the
|
object must meet each of the alignments of the types. */
|
object must meet each of the alignments of the types. */
|
align0 = expr_align (TREE_OPERAND (t, 0));
|
align0 = expr_align (TREE_OPERAND (t, 0));
|
align1 = TYPE_ALIGN (TREE_TYPE (t));
|
align1 = TYPE_ALIGN (TREE_TYPE (t));
|
return MAX (align0, align1);
|
return MAX (align0, align1);
|
|
|
case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
|
case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
|
case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
|
case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
|
case CLEANUP_POINT_EXPR:
|
case CLEANUP_POINT_EXPR:
|
/* These don't change the alignment of an object. */
|
/* These don't change the alignment of an object. */
|
return expr_align (TREE_OPERAND (t, 0));
|
return expr_align (TREE_OPERAND (t, 0));
|
|
|
case COND_EXPR:
|
case COND_EXPR:
|
/* The best we can do is say that the alignment is the least aligned
|
/* The best we can do is say that the alignment is the least aligned
|
of the two arms. */
|
of the two arms. */
|
align0 = expr_align (TREE_OPERAND (t, 1));
|
align0 = expr_align (TREE_OPERAND (t, 1));
|
align1 = expr_align (TREE_OPERAND (t, 2));
|
align1 = expr_align (TREE_OPERAND (t, 2));
|
return MIN (align0, align1);
|
return MIN (align0, align1);
|
|
|
case LABEL_DECL: case CONST_DECL:
|
case LABEL_DECL: case CONST_DECL:
|
case VAR_DECL: case PARM_DECL: case RESULT_DECL:
|
case VAR_DECL: case PARM_DECL: case RESULT_DECL:
|
if (DECL_ALIGN (t) != 0)
|
if (DECL_ALIGN (t) != 0)
|
return DECL_ALIGN (t);
|
return DECL_ALIGN (t);
|
break;
|
break;
|
|
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
return FUNCTION_BOUNDARY;
|
return FUNCTION_BOUNDARY;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* Otherwise take the alignment from that of the type. */
|
/* Otherwise take the alignment from that of the type. */
|
return TYPE_ALIGN (TREE_TYPE (t));
|
return TYPE_ALIGN (TREE_TYPE (t));
|
}
|
}
|
|
|
/* Return, as a tree node, the number of elements for TYPE (which is an
|
/* Return, as a tree node, the number of elements for TYPE (which is an
|
ARRAY_TYPE) minus one. This counts only elements of the top array. */
|
ARRAY_TYPE) minus one. This counts only elements of the top array. */
|
|
|
tree
|
tree
|
array_type_nelts (tree type)
|
array_type_nelts (tree type)
|
{
|
{
|
tree index_type, min, max;
|
tree index_type, min, max;
|
|
|
/* If they did it with unspecified bounds, then we should have already
|
/* If they did it with unspecified bounds, then we should have already
|
given an error about it before we got here. */
|
given an error about it before we got here. */
|
if (! TYPE_DOMAIN (type))
|
if (! TYPE_DOMAIN (type))
|
return error_mark_node;
|
return error_mark_node;
|
|
|
index_type = TYPE_DOMAIN (type);
|
index_type = TYPE_DOMAIN (type);
|
min = TYPE_MIN_VALUE (index_type);
|
min = TYPE_MIN_VALUE (index_type);
|
max = TYPE_MAX_VALUE (index_type);
|
max = TYPE_MAX_VALUE (index_type);
|
|
|
return (integer_zerop (min)
|
return (integer_zerop (min)
|
? max
|
? max
|
: fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
|
: fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
|
}
|
}
|
|
|
/* If arg is static -- a reference to an object in static storage -- then
|
/* If arg is static -- a reference to an object in static storage -- then
|
return the object. This is not the same as the C meaning of `static'.
|
return the object. This is not the same as the C meaning of `static'.
|
If arg isn't static, return NULL. */
|
If arg isn't static, return NULL. */
|
|
|
tree
|
tree
|
staticp (tree arg)
|
staticp (tree arg)
|
{
|
{
|
switch (TREE_CODE (arg))
|
switch (TREE_CODE (arg))
|
{
|
{
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
/* Nested functions are static, even though taking their address will
|
/* Nested functions are static, even though taking their address will
|
involve a trampoline as we unnest the nested function and create
|
involve a trampoline as we unnest the nested function and create
|
the trampoline on the tree level. */
|
the trampoline on the tree level. */
|
return arg;
|
return arg;
|
|
|
case VAR_DECL:
|
case VAR_DECL:
|
return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
|
return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
|
&& ! DECL_THREAD_LOCAL_P (arg)
|
&& ! DECL_THREAD_LOCAL_P (arg)
|
&& ! DECL_DLLIMPORT_P (arg)
|
&& ! DECL_DLLIMPORT_P (arg)
|
? arg : NULL);
|
? arg : NULL);
|
|
|
case CONST_DECL:
|
case CONST_DECL:
|
return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
|
return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
|
? arg : NULL);
|
? arg : NULL);
|
|
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
return TREE_STATIC (arg) ? arg : NULL;
|
return TREE_STATIC (arg) ? arg : NULL;
|
|
|
case LABEL_DECL:
|
case LABEL_DECL:
|
case STRING_CST:
|
case STRING_CST:
|
return arg;
|
return arg;
|
|
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
/* If the thing being referenced is not a field, then it is
|
/* If the thing being referenced is not a field, then it is
|
something language specific. */
|
something language specific. */
|
if (TREE_CODE (TREE_OPERAND (arg, 1)) != FIELD_DECL)
|
if (TREE_CODE (TREE_OPERAND (arg, 1)) != FIELD_DECL)
|
return (*lang_hooks.staticp) (arg);
|
return (*lang_hooks.staticp) (arg);
|
|
|
/* If we are referencing a bitfield, we can't evaluate an
|
/* If we are referencing a bitfield, we can't evaluate an
|
ADDR_EXPR at compile time and so it isn't a constant. */
|
ADDR_EXPR at compile time and so it isn't a constant. */
|
if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
|
if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
|
return NULL;
|
return NULL;
|
|
|
return staticp (TREE_OPERAND (arg, 0));
|
return staticp (TREE_OPERAND (arg, 0));
|
|
|
case BIT_FIELD_REF:
|
case BIT_FIELD_REF:
|
return NULL;
|
return NULL;
|
|
|
case MISALIGNED_INDIRECT_REF:
|
case MISALIGNED_INDIRECT_REF:
|
case ALIGN_INDIRECT_REF:
|
case ALIGN_INDIRECT_REF:
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
|
return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
|
|
|
case ARRAY_REF:
|
case ARRAY_REF:
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
|
if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
|
&& TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
|
&& TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
|
return staticp (TREE_OPERAND (arg, 0));
|
return staticp (TREE_OPERAND (arg, 0));
|
else
|
else
|
return false;
|
return false;
|
|
|
default:
|
default:
|
if ((unsigned int) TREE_CODE (arg)
|
if ((unsigned int) TREE_CODE (arg)
|
>= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
|
>= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
|
return lang_hooks.staticp (arg);
|
return lang_hooks.staticp (arg);
|
else
|
else
|
return NULL;
|
return NULL;
|
}
|
}
|
}
|
}
|
|
|
/* Wrap a SAVE_EXPR around EXPR, if appropriate.
|
/* Wrap a SAVE_EXPR around EXPR, if appropriate.
|
Do this to any expression which may be used in more than one place,
|
Do this to any expression which may be used in more than one place,
|
but must be evaluated only once.
|
but must be evaluated only once.
|
|
|
Normally, expand_expr would reevaluate the expression each time.
|
Normally, expand_expr would reevaluate the expression each time.
|
Calling save_expr produces something that is evaluated and recorded
|
Calling save_expr produces something that is evaluated and recorded
|
the first time expand_expr is called on it. Subsequent calls to
|
the first time expand_expr is called on it. Subsequent calls to
|
expand_expr just reuse the recorded value.
|
expand_expr just reuse the recorded value.
|
|
|
The call to expand_expr that generates code that actually computes
|
The call to expand_expr that generates code that actually computes
|
the value is the first call *at compile time*. Subsequent calls
|
the value is the first call *at compile time*. Subsequent calls
|
*at compile time* generate code to use the saved value.
|
*at compile time* generate code to use the saved value.
|
This produces correct result provided that *at run time* control
|
This produces correct result provided that *at run time* control
|
always flows through the insns made by the first expand_expr
|
always flows through the insns made by the first expand_expr
|
before reaching the other places where the save_expr was evaluated.
|
before reaching the other places where the save_expr was evaluated.
|
You, the caller of save_expr, must make sure this is so.
|
You, the caller of save_expr, must make sure this is so.
|
|
|
Constants, and certain read-only nodes, are returned with no
|
Constants, and certain read-only nodes, are returned with no
|
SAVE_EXPR because that is safe. Expressions containing placeholders
|
SAVE_EXPR because that is safe. Expressions containing placeholders
|
are not touched; see tree.def for an explanation of what these
|
are not touched; see tree.def for an explanation of what these
|
are used for. */
|
are used for. */
|
|
|
tree
|
tree
|
save_expr (tree expr)
|
save_expr (tree expr)
|
{
|
{
|
tree t = fold (expr);
|
tree t = fold (expr);
|
tree inner;
|
tree inner;
|
|
|
/* If the tree evaluates to a constant, then we don't want to hide that
|
/* If the tree evaluates to a constant, then we don't want to hide that
|
fact (i.e. this allows further folding, and direct checks for constants).
|
fact (i.e. this allows further folding, and direct checks for constants).
|
However, a read-only object that has side effects cannot be bypassed.
|
However, a read-only object that has side effects cannot be bypassed.
|
Since it is no problem to reevaluate literals, we just return the
|
Since it is no problem to reevaluate literals, we just return the
|
literal node. */
|
literal node. */
|
inner = skip_simple_arithmetic (t);
|
inner = skip_simple_arithmetic (t);
|
|
|
if (TREE_INVARIANT (inner)
|
if (TREE_INVARIANT (inner)
|
|| (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
|
|| (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
|
|| TREE_CODE (inner) == SAVE_EXPR
|
|| TREE_CODE (inner) == SAVE_EXPR
|
|| TREE_CODE (inner) == ERROR_MARK)
|
|| TREE_CODE (inner) == ERROR_MARK)
|
return t;
|
return t;
|
|
|
/* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
|
/* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
|
it means that the size or offset of some field of an object depends on
|
it means that the size or offset of some field of an object depends on
|
the value within another field.
|
the value within another field.
|
|
|
Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
|
Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
|
and some variable since it would then need to be both evaluated once and
|
and some variable since it would then need to be both evaluated once and
|
evaluated more than once. Front-ends must assure this case cannot
|
evaluated more than once. Front-ends must assure this case cannot
|
happen by surrounding any such subexpressions in their own SAVE_EXPR
|
happen by surrounding any such subexpressions in their own SAVE_EXPR
|
and forcing evaluation at the proper time. */
|
and forcing evaluation at the proper time. */
|
if (contains_placeholder_p (inner))
|
if (contains_placeholder_p (inner))
|
return t;
|
return t;
|
|
|
t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
|
t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
|
|
|
/* This expression might be placed ahead of a jump to ensure that the
|
/* This expression might be placed ahead of a jump to ensure that the
|
value was computed on both sides of the jump. So make sure it isn't
|
value was computed on both sides of the jump. So make sure it isn't
|
eliminated as dead. */
|
eliminated as dead. */
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_INVARIANT (t) = 1;
|
TREE_INVARIANT (t) = 1;
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Look inside EXPR and into any simple arithmetic operations. Return
|
/* Look inside EXPR and into any simple arithmetic operations. Return
|
the innermost non-arithmetic node. */
|
the innermost non-arithmetic node. */
|
|
|
tree
|
tree
|
skip_simple_arithmetic (tree expr)
|
skip_simple_arithmetic (tree expr)
|
{
|
{
|
tree inner;
|
tree inner;
|
|
|
/* We don't care about whether this can be used as an lvalue in this
|
/* We don't care about whether this can be used as an lvalue in this
|
context. */
|
context. */
|
while (TREE_CODE (expr) == NON_LVALUE_EXPR)
|
while (TREE_CODE (expr) == NON_LVALUE_EXPR)
|
expr = TREE_OPERAND (expr, 0);
|
expr = TREE_OPERAND (expr, 0);
|
|
|
/* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
|
/* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
|
a constant, it will be more efficient to not make another SAVE_EXPR since
|
a constant, it will be more efficient to not make another SAVE_EXPR since
|
it will allow better simplification and GCSE will be able to merge the
|
it will allow better simplification and GCSE will be able to merge the
|
computations if they actually occur. */
|
computations if they actually occur. */
|
inner = expr;
|
inner = expr;
|
while (1)
|
while (1)
|
{
|
{
|
if (UNARY_CLASS_P (inner))
|
if (UNARY_CLASS_P (inner))
|
inner = TREE_OPERAND (inner, 0);
|
inner = TREE_OPERAND (inner, 0);
|
else if (BINARY_CLASS_P (inner))
|
else if (BINARY_CLASS_P (inner))
|
{
|
{
|
if (TREE_INVARIANT (TREE_OPERAND (inner, 1)))
|
if (TREE_INVARIANT (TREE_OPERAND (inner, 1)))
|
inner = TREE_OPERAND (inner, 0);
|
inner = TREE_OPERAND (inner, 0);
|
else if (TREE_INVARIANT (TREE_OPERAND (inner, 0)))
|
else if (TREE_INVARIANT (TREE_OPERAND (inner, 0)))
|
inner = TREE_OPERAND (inner, 1);
|
inner = TREE_OPERAND (inner, 1);
|
else
|
else
|
break;
|
break;
|
}
|
}
|
else
|
else
|
break;
|
break;
|
}
|
}
|
|
|
return inner;
|
return inner;
|
}
|
}
|
|
|
/* Return which tree structure is used by T. */
|
/* Return which tree structure is used by T. */
|
|
|
enum tree_node_structure_enum
|
enum tree_node_structure_enum
|
tree_node_structure (tree t)
|
tree_node_structure (tree t)
|
{
|
{
|
enum tree_code code = TREE_CODE (t);
|
enum tree_code code = TREE_CODE (t);
|
|
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_declaration:
|
case tcc_declaration:
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case FIELD_DECL:
|
case FIELD_DECL:
|
return TS_FIELD_DECL;
|
return TS_FIELD_DECL;
|
case PARM_DECL:
|
case PARM_DECL:
|
return TS_PARM_DECL;
|
return TS_PARM_DECL;
|
case VAR_DECL:
|
case VAR_DECL:
|
return TS_VAR_DECL;
|
return TS_VAR_DECL;
|
case LABEL_DECL:
|
case LABEL_DECL:
|
return TS_LABEL_DECL;
|
return TS_LABEL_DECL;
|
case RESULT_DECL:
|
case RESULT_DECL:
|
return TS_RESULT_DECL;
|
return TS_RESULT_DECL;
|
case CONST_DECL:
|
case CONST_DECL:
|
return TS_CONST_DECL;
|
return TS_CONST_DECL;
|
case TYPE_DECL:
|
case TYPE_DECL:
|
return TS_TYPE_DECL;
|
return TS_TYPE_DECL;
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
return TS_FUNCTION_DECL;
|
return TS_FUNCTION_DECL;
|
case SYMBOL_MEMORY_TAG:
|
case SYMBOL_MEMORY_TAG:
|
case NAME_MEMORY_TAG:
|
case NAME_MEMORY_TAG:
|
case STRUCT_FIELD_TAG:
|
case STRUCT_FIELD_TAG:
|
return TS_MEMORY_TAG;
|
return TS_MEMORY_TAG;
|
default:
|
default:
|
return TS_DECL_NON_COMMON;
|
return TS_DECL_NON_COMMON;
|
}
|
}
|
}
|
}
|
case tcc_type:
|
case tcc_type:
|
return TS_TYPE;
|
return TS_TYPE;
|
case tcc_reference:
|
case tcc_reference:
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_unary:
|
case tcc_unary:
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_expression:
|
case tcc_expression:
|
case tcc_statement:
|
case tcc_statement:
|
return TS_EXP;
|
return TS_EXP;
|
default: /* tcc_constant and tcc_exceptional */
|
default: /* tcc_constant and tcc_exceptional */
|
break;
|
break;
|
}
|
}
|
switch (code)
|
switch (code)
|
{
|
{
|
/* tcc_constant cases. */
|
/* tcc_constant cases. */
|
case INTEGER_CST: return TS_INT_CST;
|
case INTEGER_CST: return TS_INT_CST;
|
case REAL_CST: return TS_REAL_CST;
|
case REAL_CST: return TS_REAL_CST;
|
case COMPLEX_CST: return TS_COMPLEX;
|
case COMPLEX_CST: return TS_COMPLEX;
|
case VECTOR_CST: return TS_VECTOR;
|
case VECTOR_CST: return TS_VECTOR;
|
case STRING_CST: return TS_STRING;
|
case STRING_CST: return TS_STRING;
|
/* tcc_exceptional cases. */
|
/* tcc_exceptional cases. */
|
case ERROR_MARK: return TS_COMMON;
|
case ERROR_MARK: return TS_COMMON;
|
case IDENTIFIER_NODE: return TS_IDENTIFIER;
|
case IDENTIFIER_NODE: return TS_IDENTIFIER;
|
case TREE_LIST: return TS_LIST;
|
case TREE_LIST: return TS_LIST;
|
case TREE_VEC: return TS_VEC;
|
case TREE_VEC: return TS_VEC;
|
case PHI_NODE: return TS_PHI_NODE;
|
case PHI_NODE: return TS_PHI_NODE;
|
case SSA_NAME: return TS_SSA_NAME;
|
case SSA_NAME: return TS_SSA_NAME;
|
case PLACEHOLDER_EXPR: return TS_COMMON;
|
case PLACEHOLDER_EXPR: return TS_COMMON;
|
case STATEMENT_LIST: return TS_STATEMENT_LIST;
|
case STATEMENT_LIST: return TS_STATEMENT_LIST;
|
case BLOCK: return TS_BLOCK;
|
case BLOCK: return TS_BLOCK;
|
case CONSTRUCTOR: return TS_CONSTRUCTOR;
|
case CONSTRUCTOR: return TS_CONSTRUCTOR;
|
case TREE_BINFO: return TS_BINFO;
|
case TREE_BINFO: return TS_BINFO;
|
case VALUE_HANDLE: return TS_VALUE_HANDLE;
|
case VALUE_HANDLE: return TS_VALUE_HANDLE;
|
case OMP_CLAUSE: return TS_OMP_CLAUSE;
|
case OMP_CLAUSE: return TS_OMP_CLAUSE;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
|
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
|
or offset that depends on a field within a record. */
|
or offset that depends on a field within a record. */
|
|
|
bool
|
bool
|
contains_placeholder_p (tree exp)
|
contains_placeholder_p (tree exp)
|
{
|
{
|
enum tree_code code;
|
enum tree_code code;
|
|
|
if (!exp)
|
if (!exp)
|
return 0;
|
return 0;
|
|
|
code = TREE_CODE (exp);
|
code = TREE_CODE (exp);
|
if (code == PLACEHOLDER_EXPR)
|
if (code == PLACEHOLDER_EXPR)
|
return 1;
|
return 1;
|
|
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_reference:
|
case tcc_reference:
|
/* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
|
/* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
|
position computations since they will be converted into a
|
position computations since they will be converted into a
|
WITH_RECORD_EXPR involving the reference, which will assume
|
WITH_RECORD_EXPR involving the reference, which will assume
|
here will be valid. */
|
here will be valid. */
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
|
|
|
case tcc_exceptional:
|
case tcc_exceptional:
|
if (code == TREE_LIST)
|
if (code == TREE_LIST)
|
return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
|
return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
|
|| CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
|
|| CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
|
break;
|
break;
|
|
|
case tcc_unary:
|
case tcc_unary:
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_expression:
|
case tcc_expression:
|
switch (code)
|
switch (code)
|
{
|
{
|
case COMPOUND_EXPR:
|
case COMPOUND_EXPR:
|
/* Ignoring the first operand isn't quite right, but works best. */
|
/* Ignoring the first operand isn't quite right, but works best. */
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
|
|
|
case COND_EXPR:
|
case COND_EXPR:
|
return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
|
return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
|
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
|
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
|
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
|
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
|
|
|
case CALL_EXPR:
|
case CALL_EXPR:
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
switch (TREE_CODE_LENGTH (code))
|
switch (TREE_CODE_LENGTH (code))
|
{
|
{
|
case 1:
|
case 1:
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
|
return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
|
case 2:
|
case 2:
|
return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
|
return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
|
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
|
|| CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
|
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return true if any part of the computation of TYPE involves a
|
/* Return true if any part of the computation of TYPE involves a
|
PLACEHOLDER_EXPR. This includes size, bounds, qualifiers
|
PLACEHOLDER_EXPR. This includes size, bounds, qualifiers
|
(for QUAL_UNION_TYPE) and field positions. */
|
(for QUAL_UNION_TYPE) and field positions. */
|
|
|
static bool
|
static bool
|
type_contains_placeholder_1 (tree type)
|
type_contains_placeholder_1 (tree type)
|
{
|
{
|
/* If the size contains a placeholder or the parent type (component type in
|
/* If the size contains a placeholder or the parent type (component type in
|
the case of arrays) type involves a placeholder, this type does. */
|
the case of arrays) type involves a placeholder, this type does. */
|
if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
|
if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
|
|| CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
|
|| CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
|
|| (TREE_TYPE (type) != 0
|
|| (TREE_TYPE (type) != 0
|
&& type_contains_placeholder_p (TREE_TYPE (type))))
|
&& type_contains_placeholder_p (TREE_TYPE (type))))
|
return true;
|
return true;
|
|
|
/* Now do type-specific checks. Note that the last part of the check above
|
/* Now do type-specific checks. Note that the last part of the check above
|
greatly limits what we have to do below. */
|
greatly limits what we have to do below. */
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case VOID_TYPE:
|
case VOID_TYPE:
|
case COMPLEX_TYPE:
|
case COMPLEX_TYPE:
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
case BOOLEAN_TYPE:
|
case BOOLEAN_TYPE:
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
case OFFSET_TYPE:
|
case OFFSET_TYPE:
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
case METHOD_TYPE:
|
case METHOD_TYPE:
|
case FUNCTION_TYPE:
|
case FUNCTION_TYPE:
|
case VECTOR_TYPE:
|
case VECTOR_TYPE:
|
return false;
|
return false;
|
|
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
case REAL_TYPE:
|
case REAL_TYPE:
|
/* Here we just check the bounds. */
|
/* Here we just check the bounds. */
|
return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
|
return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
|
|| CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
|
|| CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
|
|
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
/* We're already checked the component type (TREE_TYPE), so just check
|
/* We're already checked the component type (TREE_TYPE), so just check
|
the index type. */
|
the index type. */
|
return type_contains_placeholder_p (TYPE_DOMAIN (type));
|
return type_contains_placeholder_p (TYPE_DOMAIN (type));
|
|
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
{
|
{
|
tree field;
|
tree field;
|
|
|
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
|
if (TREE_CODE (field) == FIELD_DECL
|
if (TREE_CODE (field) == FIELD_DECL
|
&& (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
|
&& (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
|
|| (TREE_CODE (type) == QUAL_UNION_TYPE
|
|| (TREE_CODE (type) == QUAL_UNION_TYPE
|
&& CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
|
&& CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
|
|| type_contains_placeholder_p (TREE_TYPE (field))))
|
|| type_contains_placeholder_p (TREE_TYPE (field))))
|
return true;
|
return true;
|
|
|
return false;
|
return false;
|
}
|
}
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
bool
|
bool
|
type_contains_placeholder_p (tree type)
|
type_contains_placeholder_p (tree type)
|
{
|
{
|
bool result;
|
bool result;
|
|
|
/* If the contains_placeholder_bits field has been initialized,
|
/* If the contains_placeholder_bits field has been initialized,
|
then we know the answer. */
|
then we know the answer. */
|
if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
|
if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
|
return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
|
return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
|
|
|
/* Indicate that we've seen this type node, and the answer is false.
|
/* Indicate that we've seen this type node, and the answer is false.
|
This is what we want to return if we run into recursion via fields. */
|
This is what we want to return if we run into recursion via fields. */
|
TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
|
TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
|
|
|
/* Compute the real value. */
|
/* Compute the real value. */
|
result = type_contains_placeholder_1 (type);
|
result = type_contains_placeholder_1 (type);
|
|
|
/* Store the real value. */
|
/* Store the real value. */
|
TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
|
TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
|
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
|
return a tree with all occurrences of references to F in a
|
return a tree with all occurrences of references to F in a
|
PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
|
PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP
|
contains only arithmetic expressions or a CALL_EXPR with a
|
contains only arithmetic expressions or a CALL_EXPR with a
|
PLACEHOLDER_EXPR occurring only in its arglist. */
|
PLACEHOLDER_EXPR occurring only in its arglist. */
|
|
|
tree
|
tree
|
substitute_in_expr (tree exp, tree f, tree r)
|
substitute_in_expr (tree exp, tree f, tree r)
|
{
|
{
|
enum tree_code code = TREE_CODE (exp);
|
enum tree_code code = TREE_CODE (exp);
|
tree op0, op1, op2, op3;
|
tree op0, op1, op2, op3;
|
tree new;
|
tree new;
|
tree inner;
|
tree inner;
|
|
|
/* We handle TREE_LIST and COMPONENT_REF separately. */
|
/* We handle TREE_LIST and COMPONENT_REF separately. */
|
if (code == TREE_LIST)
|
if (code == TREE_LIST)
|
{
|
{
|
op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
|
op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
|
if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
|
if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
|
return exp;
|
return exp;
|
|
|
return tree_cons (TREE_PURPOSE (exp), op1, op0);
|
return tree_cons (TREE_PURPOSE (exp), op1, op0);
|
}
|
}
|
else if (code == COMPONENT_REF)
|
else if (code == COMPONENT_REF)
|
{
|
{
|
/* If this expression is getting a value from a PLACEHOLDER_EXPR
|
/* If this expression is getting a value from a PLACEHOLDER_EXPR
|
and it is the right field, replace it with R. */
|
and it is the right field, replace it with R. */
|
for (inner = TREE_OPERAND (exp, 0);
|
for (inner = TREE_OPERAND (exp, 0);
|
REFERENCE_CLASS_P (inner);
|
REFERENCE_CLASS_P (inner);
|
inner = TREE_OPERAND (inner, 0))
|
inner = TREE_OPERAND (inner, 0))
|
;
|
;
|
if (TREE_CODE (inner) == PLACEHOLDER_EXPR
|
if (TREE_CODE (inner) == PLACEHOLDER_EXPR
|
&& TREE_OPERAND (exp, 1) == f)
|
&& TREE_OPERAND (exp, 1) == f)
|
return r;
|
return r;
|
|
|
/* If this expression hasn't been completed let, leave it alone. */
|
/* If this expression hasn't been completed let, leave it alone. */
|
if (TREE_CODE (inner) == PLACEHOLDER_EXPR && TREE_TYPE (inner) == 0)
|
if (TREE_CODE (inner) == PLACEHOLDER_EXPR && TREE_TYPE (inner) == 0)
|
return exp;
|
return exp;
|
|
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
if (op0 == TREE_OPERAND (exp, 0))
|
if (op0 == TREE_OPERAND (exp, 0))
|
return exp;
|
return exp;
|
|
|
new = fold_build3 (COMPONENT_REF, TREE_TYPE (exp),
|
new = fold_build3 (COMPONENT_REF, TREE_TYPE (exp),
|
op0, TREE_OPERAND (exp, 1), NULL_TREE);
|
op0, TREE_OPERAND (exp, 1), NULL_TREE);
|
}
|
}
|
else
|
else
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_constant:
|
case tcc_constant:
|
case tcc_declaration:
|
case tcc_declaration:
|
return exp;
|
return exp;
|
|
|
case tcc_exceptional:
|
case tcc_exceptional:
|
case tcc_unary:
|
case tcc_unary:
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_expression:
|
case tcc_expression:
|
case tcc_reference:
|
case tcc_reference:
|
switch (TREE_CODE_LENGTH (code))
|
switch (TREE_CODE_LENGTH (code))
|
{
|
{
|
case 0:
|
case 0:
|
return exp;
|
return exp;
|
|
|
case 1:
|
case 1:
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
if (op0 == TREE_OPERAND (exp, 0))
|
if (op0 == TREE_OPERAND (exp, 0))
|
return exp;
|
return exp;
|
|
|
new = fold_build1 (code, TREE_TYPE (exp), op0);
|
new = fold_build1 (code, TREE_TYPE (exp), op0);
|
break;
|
break;
|
|
|
case 2:
|
case 2:
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
|
|
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
|
return exp;
|
return exp;
|
|
|
new = fold_build2 (code, TREE_TYPE (exp), op0, op1);
|
new = fold_build2 (code, TREE_TYPE (exp), op0, op1);
|
break;
|
break;
|
|
|
case 3:
|
case 3:
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
|
op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
|
op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
|
|
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
&& op2 == TREE_OPERAND (exp, 2))
|
&& op2 == TREE_OPERAND (exp, 2))
|
return exp;
|
return exp;
|
|
|
new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
|
new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
|
break;
|
break;
|
|
|
case 4:
|
case 4:
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
|
op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
|
op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
|
op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
|
op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
|
op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
|
|
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
&& op2 == TREE_OPERAND (exp, 2)
|
&& op2 == TREE_OPERAND (exp, 2)
|
&& op3 == TREE_OPERAND (exp, 3))
|
&& op3 == TREE_OPERAND (exp, 3))
|
return exp;
|
return exp;
|
|
|
new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
|
new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
TREE_READONLY (new) = TREE_READONLY (exp);
|
TREE_READONLY (new) = TREE_READONLY (exp);
|
return new;
|
return new;
|
}
|
}
|
|
|
/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
|
/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
|
for it within OBJ, a tree that is an object or a chain of references. */
|
for it within OBJ, a tree that is an object or a chain of references. */
|
|
|
tree
|
tree
|
substitute_placeholder_in_expr (tree exp, tree obj)
|
substitute_placeholder_in_expr (tree exp, tree obj)
|
{
|
{
|
enum tree_code code = TREE_CODE (exp);
|
enum tree_code code = TREE_CODE (exp);
|
tree op0, op1, op2, op3;
|
tree op0, op1, op2, op3;
|
|
|
/* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
|
/* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
|
in the chain of OBJ. */
|
in the chain of OBJ. */
|
if (code == PLACEHOLDER_EXPR)
|
if (code == PLACEHOLDER_EXPR)
|
{
|
{
|
tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
|
tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
|
tree elt;
|
tree elt;
|
|
|
for (elt = obj; elt != 0;
|
for (elt = obj; elt != 0;
|
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|
|| TREE_CODE (elt) == COND_EXPR)
|
|| TREE_CODE (elt) == COND_EXPR)
|
? TREE_OPERAND (elt, 1)
|
? TREE_OPERAND (elt, 1)
|
: (REFERENCE_CLASS_P (elt)
|
: (REFERENCE_CLASS_P (elt)
|
|| UNARY_CLASS_P (elt)
|
|| UNARY_CLASS_P (elt)
|
|| BINARY_CLASS_P (elt)
|
|| BINARY_CLASS_P (elt)
|
|| EXPRESSION_CLASS_P (elt))
|
|| EXPRESSION_CLASS_P (elt))
|
? TREE_OPERAND (elt, 0) : 0))
|
? TREE_OPERAND (elt, 0) : 0))
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
|
if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
|
return elt;
|
return elt;
|
|
|
for (elt = obj; elt != 0;
|
for (elt = obj; elt != 0;
|
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|
elt = ((TREE_CODE (elt) == COMPOUND_EXPR
|
|| TREE_CODE (elt) == COND_EXPR)
|
|| TREE_CODE (elt) == COND_EXPR)
|
? TREE_OPERAND (elt, 1)
|
? TREE_OPERAND (elt, 1)
|
: (REFERENCE_CLASS_P (elt)
|
: (REFERENCE_CLASS_P (elt)
|
|| UNARY_CLASS_P (elt)
|
|| UNARY_CLASS_P (elt)
|
|| BINARY_CLASS_P (elt)
|
|| BINARY_CLASS_P (elt)
|
|| EXPRESSION_CLASS_P (elt))
|
|| EXPRESSION_CLASS_P (elt))
|
? TREE_OPERAND (elt, 0) : 0))
|
? TREE_OPERAND (elt, 0) : 0))
|
if (POINTER_TYPE_P (TREE_TYPE (elt))
|
if (POINTER_TYPE_P (TREE_TYPE (elt))
|
&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
|
&& (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
|
== need_type))
|
== need_type))
|
return fold_build1 (INDIRECT_REF, need_type, elt);
|
return fold_build1 (INDIRECT_REF, need_type, elt);
|
|
|
/* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
|
/* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
|
survives until RTL generation, there will be an error. */
|
survives until RTL generation, there will be an error. */
|
return exp;
|
return exp;
|
}
|
}
|
|
|
/* TREE_LIST is special because we need to look at TREE_VALUE
|
/* TREE_LIST is special because we need to look at TREE_VALUE
|
and TREE_CHAIN, not TREE_OPERANDS. */
|
and TREE_CHAIN, not TREE_OPERANDS. */
|
else if (code == TREE_LIST)
|
else if (code == TREE_LIST)
|
{
|
{
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
|
if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
|
if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
|
return exp;
|
return exp;
|
|
|
return tree_cons (TREE_PURPOSE (exp), op1, op0);
|
return tree_cons (TREE_PURPOSE (exp), op1, op0);
|
}
|
}
|
else
|
else
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_constant:
|
case tcc_constant:
|
case tcc_declaration:
|
case tcc_declaration:
|
return exp;
|
return exp;
|
|
|
case tcc_exceptional:
|
case tcc_exceptional:
|
case tcc_unary:
|
case tcc_unary:
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_expression:
|
case tcc_expression:
|
case tcc_reference:
|
case tcc_reference:
|
case tcc_statement:
|
case tcc_statement:
|
switch (TREE_CODE_LENGTH (code))
|
switch (TREE_CODE_LENGTH (code))
|
{
|
{
|
case 0:
|
case 0:
|
return exp;
|
return exp;
|
|
|
case 1:
|
case 1:
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
if (op0 == TREE_OPERAND (exp, 0))
|
if (op0 == TREE_OPERAND (exp, 0))
|
return exp;
|
return exp;
|
else
|
else
|
return fold_build1 (code, TREE_TYPE (exp), op0);
|
return fold_build1 (code, TREE_TYPE (exp), op0);
|
|
|
case 2:
|
case 2:
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
|
|
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
|
return exp;
|
return exp;
|
else
|
else
|
return fold_build2 (code, TREE_TYPE (exp), op0, op1);
|
return fold_build2 (code, TREE_TYPE (exp), op0, op1);
|
|
|
case 3:
|
case 3:
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
|
op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
|
op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
|
|
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
&& op2 == TREE_OPERAND (exp, 2))
|
&& op2 == TREE_OPERAND (exp, 2))
|
return exp;
|
return exp;
|
else
|
else
|
return fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
|
return fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
|
|
|
case 4:
|
case 4:
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
|
op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
|
op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
|
op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
|
op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
|
op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
|
|
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
|
&& op2 == TREE_OPERAND (exp, 2)
|
&& op2 == TREE_OPERAND (exp, 2)
|
&& op3 == TREE_OPERAND (exp, 3))
|
&& op3 == TREE_OPERAND (exp, 3))
|
return exp;
|
return exp;
|
else
|
else
|
return fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
|
return fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
}
|
}
|
|
|
/* Stabilize a reference so that we can use it any number of times
|
/* Stabilize a reference so that we can use it any number of times
|
without causing its operands to be evaluated more than once.
|
without causing its operands to be evaluated more than once.
|
Returns the stabilized reference. This works by means of save_expr,
|
Returns the stabilized reference. This works by means of save_expr,
|
so see the caveats in the comments about save_expr.
|
so see the caveats in the comments about save_expr.
|
|
|
Also allows conversion expressions whose operands are references.
|
Also allows conversion expressions whose operands are references.
|
Any other kind of expression is returned unchanged. */
|
Any other kind of expression is returned unchanged. */
|
|
|
tree
|
tree
|
stabilize_reference (tree ref)
|
stabilize_reference (tree ref)
|
{
|
{
|
tree result;
|
tree result;
|
enum tree_code code = TREE_CODE (ref);
|
enum tree_code code = TREE_CODE (ref);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case VAR_DECL:
|
case VAR_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
/* No action is needed in this case. */
|
/* No action is needed in this case. */
|
return ref;
|
return ref;
|
|
|
case NOP_EXPR:
|
case NOP_EXPR:
|
case CONVERT_EXPR:
|
case CONVERT_EXPR:
|
case FLOAT_EXPR:
|
case FLOAT_EXPR:
|
case FIX_TRUNC_EXPR:
|
case FIX_TRUNC_EXPR:
|
case FIX_FLOOR_EXPR:
|
case FIX_FLOOR_EXPR:
|
case FIX_ROUND_EXPR:
|
case FIX_ROUND_EXPR:
|
case FIX_CEIL_EXPR:
|
case FIX_CEIL_EXPR:
|
result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
|
result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
|
break;
|
break;
|
|
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
result = build_nt (INDIRECT_REF,
|
result = build_nt (INDIRECT_REF,
|
stabilize_reference_1 (TREE_OPERAND (ref, 0)));
|
stabilize_reference_1 (TREE_OPERAND (ref, 0)));
|
break;
|
break;
|
|
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
result = build_nt (COMPONENT_REF,
|
result = build_nt (COMPONENT_REF,
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
TREE_OPERAND (ref, 1), NULL_TREE);
|
TREE_OPERAND (ref, 1), NULL_TREE);
|
break;
|
break;
|
|
|
case BIT_FIELD_REF:
|
case BIT_FIELD_REF:
|
result = build_nt (BIT_FIELD_REF,
|
result = build_nt (BIT_FIELD_REF,
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 1)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 1)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 2)));
|
stabilize_reference_1 (TREE_OPERAND (ref, 2)));
|
break;
|
break;
|
|
|
case ARRAY_REF:
|
case ARRAY_REF:
|
result = build_nt (ARRAY_REF,
|
result = build_nt (ARRAY_REF,
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 1)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 1)),
|
TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
|
TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
|
break;
|
break;
|
|
|
case ARRAY_RANGE_REF:
|
case ARRAY_RANGE_REF:
|
result = build_nt (ARRAY_RANGE_REF,
|
result = build_nt (ARRAY_RANGE_REF,
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference (TREE_OPERAND (ref, 0)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 1)),
|
stabilize_reference_1 (TREE_OPERAND (ref, 1)),
|
TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
|
TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
|
break;
|
break;
|
|
|
case COMPOUND_EXPR:
|
case COMPOUND_EXPR:
|
/* We cannot wrap the first expression in a SAVE_EXPR, as then
|
/* We cannot wrap the first expression in a SAVE_EXPR, as then
|
it wouldn't be ignored. This matters when dealing with
|
it wouldn't be ignored. This matters when dealing with
|
volatiles. */
|
volatiles. */
|
return stabilize_reference_1 (ref);
|
return stabilize_reference_1 (ref);
|
|
|
/* If arg isn't a kind of lvalue we recognize, make no change.
|
/* If arg isn't a kind of lvalue we recognize, make no change.
|
Caller should recognize the error for an invalid lvalue. */
|
Caller should recognize the error for an invalid lvalue. */
|
default:
|
default:
|
return ref;
|
return ref;
|
|
|
case ERROR_MARK:
|
case ERROR_MARK:
|
return error_mark_node;
|
return error_mark_node;
|
}
|
}
|
|
|
TREE_TYPE (result) = TREE_TYPE (ref);
|
TREE_TYPE (result) = TREE_TYPE (ref);
|
TREE_READONLY (result) = TREE_READONLY (ref);
|
TREE_READONLY (result) = TREE_READONLY (ref);
|
TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
|
TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
|
TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
|
TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Subroutine of stabilize_reference; this is called for subtrees of
|
/* Subroutine of stabilize_reference; this is called for subtrees of
|
references. Any expression with side-effects must be put in a SAVE_EXPR
|
references. Any expression with side-effects must be put in a SAVE_EXPR
|
to ensure that it is only evaluated once.
|
to ensure that it is only evaluated once.
|
|
|
We don't put SAVE_EXPR nodes around everything, because assigning very
|
We don't put SAVE_EXPR nodes around everything, because assigning very
|
simple expressions to temporaries causes us to miss good opportunities
|
simple expressions to temporaries causes us to miss good opportunities
|
for optimizations. Among other things, the opportunity to fold in the
|
for optimizations. Among other things, the opportunity to fold in the
|
addition of a constant into an addressing mode often gets lost, e.g.
|
addition of a constant into an addressing mode often gets lost, e.g.
|
"y[i+1] += x;". In general, we take the approach that we should not make
|
"y[i+1] += x;". In general, we take the approach that we should not make
|
an assignment unless we are forced into it - i.e., that any non-side effect
|
an assignment unless we are forced into it - i.e., that any non-side effect
|
operator should be allowed, and that cse should take care of coalescing
|
operator should be allowed, and that cse should take care of coalescing
|
multiple utterances of the same expression should that prove fruitful. */
|
multiple utterances of the same expression should that prove fruitful. */
|
|
|
tree
|
tree
|
stabilize_reference_1 (tree e)
|
stabilize_reference_1 (tree e)
|
{
|
{
|
tree result;
|
tree result;
|
enum tree_code code = TREE_CODE (e);
|
enum tree_code code = TREE_CODE (e);
|
|
|
/* We cannot ignore const expressions because it might be a reference
|
/* We cannot ignore const expressions because it might be a reference
|
to a const array but whose index contains side-effects. But we can
|
to a const array but whose index contains side-effects. But we can
|
ignore things that are actual constant or that already have been
|
ignore things that are actual constant or that already have been
|
handled by this function. */
|
handled by this function. */
|
|
|
if (TREE_INVARIANT (e))
|
if (TREE_INVARIANT (e))
|
return e;
|
return e;
|
|
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_exceptional:
|
case tcc_exceptional:
|
case tcc_type:
|
case tcc_type:
|
case tcc_declaration:
|
case tcc_declaration:
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_statement:
|
case tcc_statement:
|
case tcc_expression:
|
case tcc_expression:
|
case tcc_reference:
|
case tcc_reference:
|
/* If the expression has side-effects, then encase it in a SAVE_EXPR
|
/* If the expression has side-effects, then encase it in a SAVE_EXPR
|
so that it will only be evaluated once. */
|
so that it will only be evaluated once. */
|
/* The reference (r) and comparison (<) classes could be handled as
|
/* The reference (r) and comparison (<) classes could be handled as
|
below, but it is generally faster to only evaluate them once. */
|
below, but it is generally faster to only evaluate them once. */
|
if (TREE_SIDE_EFFECTS (e))
|
if (TREE_SIDE_EFFECTS (e))
|
return save_expr (e);
|
return save_expr (e);
|
return e;
|
return e;
|
|
|
case tcc_constant:
|
case tcc_constant:
|
/* Constants need no processing. In fact, we should never reach
|
/* Constants need no processing. In fact, we should never reach
|
here. */
|
here. */
|
return e;
|
return e;
|
|
|
case tcc_binary:
|
case tcc_binary:
|
/* Division is slow and tends to be compiled with jumps,
|
/* Division is slow and tends to be compiled with jumps,
|
especially the division by powers of 2 that is often
|
especially the division by powers of 2 that is often
|
found inside of an array reference. So do it just once. */
|
found inside of an array reference. So do it just once. */
|
if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
|
if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
|
|| code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
|
|| code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
|
|| code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
|
|| code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
|
|| code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
|
|| code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
|
return save_expr (e);
|
return save_expr (e);
|
/* Recursively stabilize each operand. */
|
/* Recursively stabilize each operand. */
|
result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
|
result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
|
stabilize_reference_1 (TREE_OPERAND (e, 1)));
|
stabilize_reference_1 (TREE_OPERAND (e, 1)));
|
break;
|
break;
|
|
|
case tcc_unary:
|
case tcc_unary:
|
/* Recursively stabilize each operand. */
|
/* Recursively stabilize each operand. */
|
result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
|
result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
TREE_TYPE (result) = TREE_TYPE (e);
|
TREE_TYPE (result) = TREE_TYPE (e);
|
TREE_READONLY (result) = TREE_READONLY (e);
|
TREE_READONLY (result) = TREE_READONLY (e);
|
TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
|
TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
|
TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
|
TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
|
TREE_INVARIANT (result) = 1;
|
TREE_INVARIANT (result) = 1;
|
|
|
return result;
|
return result;
|
}
|
}
|
|
|
/* Low-level constructors for expressions. */
|
/* Low-level constructors for expressions. */
|
|
|
/* A helper function for build1 and constant folders. Set TREE_CONSTANT,
|
/* A helper function for build1 and constant folders. Set TREE_CONSTANT,
|
TREE_INVARIANT, and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
|
TREE_INVARIANT, and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
|
|
|
void
|
void
|
recompute_tree_invariant_for_addr_expr (tree t)
|
recompute_tree_invariant_for_addr_expr (tree t)
|
{
|
{
|
tree node;
|
tree node;
|
bool tc = true, ti = true, se = false;
|
bool tc = true, ti = true, se = false;
|
|
|
/* We started out assuming this address is both invariant and constant, but
|
/* We started out assuming this address is both invariant and constant, but
|
does not have side effects. Now go down any handled components and see if
|
does not have side effects. Now go down any handled components and see if
|
any of them involve offsets that are either non-constant or non-invariant.
|
any of them involve offsets that are either non-constant or non-invariant.
|
Also check for side-effects.
|
Also check for side-effects.
|
|
|
??? Note that this code makes no attempt to deal with the case where
|
??? Note that this code makes no attempt to deal with the case where
|
taking the address of something causes a copy due to misalignment. */
|
taking the address of something causes a copy due to misalignment. */
|
|
|
#define UPDATE_TITCSE(NODE) \
|
#define UPDATE_TITCSE(NODE) \
|
do { tree _node = (NODE); \
|
do { tree _node = (NODE); \
|
if (_node && !TREE_INVARIANT (_node)) ti = false; \
|
if (_node && !TREE_INVARIANT (_node)) ti = false; \
|
if (_node && !TREE_CONSTANT (_node)) tc = false; \
|
if (_node && !TREE_CONSTANT (_node)) tc = false; \
|
if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
|
if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
|
|
|
for (node = TREE_OPERAND (t, 0); handled_component_p (node);
|
for (node = TREE_OPERAND (t, 0); handled_component_p (node);
|
node = TREE_OPERAND (node, 0))
|
node = TREE_OPERAND (node, 0))
|
{
|
{
|
/* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
|
/* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
|
array reference (probably made temporarily by the G++ front end),
|
array reference (probably made temporarily by the G++ front end),
|
so ignore all the operands. */
|
so ignore all the operands. */
|
if ((TREE_CODE (node) == ARRAY_REF
|
if ((TREE_CODE (node) == ARRAY_REF
|
|| TREE_CODE (node) == ARRAY_RANGE_REF)
|
|| TREE_CODE (node) == ARRAY_RANGE_REF)
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
|
&& TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
|
{
|
{
|
UPDATE_TITCSE (TREE_OPERAND (node, 1));
|
UPDATE_TITCSE (TREE_OPERAND (node, 1));
|
if (TREE_OPERAND (node, 2))
|
if (TREE_OPERAND (node, 2))
|
UPDATE_TITCSE (TREE_OPERAND (node, 2));
|
UPDATE_TITCSE (TREE_OPERAND (node, 2));
|
if (TREE_OPERAND (node, 3))
|
if (TREE_OPERAND (node, 3))
|
UPDATE_TITCSE (TREE_OPERAND (node, 3));
|
UPDATE_TITCSE (TREE_OPERAND (node, 3));
|
}
|
}
|
/* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
|
/* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
|
FIELD_DECL, apparently. The G++ front end can put something else
|
FIELD_DECL, apparently. The G++ front end can put something else
|
there, at least temporarily. */
|
there, at least temporarily. */
|
else if (TREE_CODE (node) == COMPONENT_REF
|
else if (TREE_CODE (node) == COMPONENT_REF
|
&& TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
|
&& TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
|
{
|
{
|
if (TREE_OPERAND (node, 2))
|
if (TREE_OPERAND (node, 2))
|
UPDATE_TITCSE (TREE_OPERAND (node, 2));
|
UPDATE_TITCSE (TREE_OPERAND (node, 2));
|
}
|
}
|
else if (TREE_CODE (node) == BIT_FIELD_REF)
|
else if (TREE_CODE (node) == BIT_FIELD_REF)
|
UPDATE_TITCSE (TREE_OPERAND (node, 2));
|
UPDATE_TITCSE (TREE_OPERAND (node, 2));
|
}
|
}
|
|
|
node = lang_hooks.expr_to_decl (node, &tc, &ti, &se);
|
node = lang_hooks.expr_to_decl (node, &tc, &ti, &se);
|
|
|
/* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
|
/* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
|
the address, since &(*a)->b is a form of addition. If it's a decl, it's
|
the address, since &(*a)->b is a form of addition. If it's a decl, it's
|
invariant and constant if the decl is static. It's also invariant if it's
|
invariant and constant if the decl is static. It's also invariant if it's
|
a decl in the current function. Taking the address of a volatile variable
|
a decl in the current function. Taking the address of a volatile variable
|
is not volatile. If it's a constant, the address is both invariant and
|
is not volatile. If it's a constant, the address is both invariant and
|
constant. Otherwise it's neither. */
|
constant. Otherwise it's neither. */
|
if (TREE_CODE (node) == INDIRECT_REF)
|
if (TREE_CODE (node) == INDIRECT_REF)
|
UPDATE_TITCSE (TREE_OPERAND (node, 0));
|
UPDATE_TITCSE (TREE_OPERAND (node, 0));
|
else if (DECL_P (node))
|
else if (DECL_P (node))
|
{
|
{
|
if (staticp (node))
|
if (staticp (node))
|
;
|
;
|
else if (decl_function_context (node) == current_function_decl
|
else if (decl_function_context (node) == current_function_decl
|
/* Addresses of thread-local variables are invariant. */
|
/* Addresses of thread-local variables are invariant. */
|
|| (TREE_CODE (node) == VAR_DECL
|
|| (TREE_CODE (node) == VAR_DECL
|
&& DECL_THREAD_LOCAL_P (node)))
|
&& DECL_THREAD_LOCAL_P (node)))
|
tc = false;
|
tc = false;
|
else
|
else
|
ti = tc = false;
|
ti = tc = false;
|
}
|
}
|
else if (CONSTANT_CLASS_P (node))
|
else if (CONSTANT_CLASS_P (node))
|
;
|
;
|
else
|
else
|
{
|
{
|
ti = tc = false;
|
ti = tc = false;
|
se |= TREE_SIDE_EFFECTS (node);
|
se |= TREE_SIDE_EFFECTS (node);
|
}
|
}
|
|
|
TREE_CONSTANT (t) = tc;
|
TREE_CONSTANT (t) = tc;
|
TREE_INVARIANT (t) = ti;
|
TREE_INVARIANT (t) = ti;
|
TREE_SIDE_EFFECTS (t) = se;
|
TREE_SIDE_EFFECTS (t) = se;
|
#undef UPDATE_TITCSE
|
#undef UPDATE_TITCSE
|
}
|
}
|
|
|
/* Build an expression of code CODE, data type TYPE, and operands as
|
/* Build an expression of code CODE, data type TYPE, and operands as
|
specified. Expressions and reference nodes can be created this way.
|
specified. Expressions and reference nodes can be created this way.
|
Constants, decls, types and misc nodes cannot be.
|
Constants, decls, types and misc nodes cannot be.
|
|
|
We define 5 non-variadic functions, from 0 to 4 arguments. This is
|
We define 5 non-variadic functions, from 0 to 4 arguments. This is
|
enough for all extant tree codes. */
|
enough for all extant tree codes. */
|
|
|
tree
|
tree
|
build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
|
build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
gcc_assert (TREE_CODE_LENGTH (code) == 0);
|
gcc_assert (TREE_CODE_LENGTH (code) == 0);
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
TREE_TYPE (t) = tt;
|
TREE_TYPE (t) = tt;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
tree
|
tree
|
build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
|
build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
|
{
|
{
|
int length = sizeof (struct tree_exp);
|
int length = sizeof (struct tree_exp);
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_kind kind;
|
tree_node_kind kind;
|
#endif
|
#endif
|
tree t;
|
tree t;
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
switch (TREE_CODE_CLASS (code))
|
switch (TREE_CODE_CLASS (code))
|
{
|
{
|
case tcc_statement: /* an expression with side effects */
|
case tcc_statement: /* an expression with side effects */
|
kind = s_kind;
|
kind = s_kind;
|
break;
|
break;
|
case tcc_reference: /* a reference */
|
case tcc_reference: /* a reference */
|
kind = r_kind;
|
kind = r_kind;
|
break;
|
break;
|
default:
|
default:
|
kind = e_kind;
|
kind = e_kind;
|
break;
|
break;
|
}
|
}
|
|
|
tree_node_counts[(int) kind]++;
|
tree_node_counts[(int) kind]++;
|
tree_node_sizes[(int) kind] += length;
|
tree_node_sizes[(int) kind] += length;
|
#endif
|
#endif
|
|
|
gcc_assert (TREE_CODE_LENGTH (code) == 1);
|
gcc_assert (TREE_CODE_LENGTH (code) == 1);
|
|
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
t = ggc_alloc_zone_pass_stat (length, &tree_zone);
|
|
|
memset (t, 0, sizeof (struct tree_common));
|
memset (t, 0, sizeof (struct tree_common));
|
|
|
TREE_SET_CODE (t, code);
|
TREE_SET_CODE (t, code);
|
|
|
TREE_TYPE (t) = type;
|
TREE_TYPE (t) = type;
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
|
SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
|
#else
|
#else
|
SET_EXPR_LOCUS (t, NULL);
|
SET_EXPR_LOCUS (t, NULL);
|
#endif
|
#endif
|
TREE_COMPLEXITY (t) = 0;
|
TREE_COMPLEXITY (t) = 0;
|
TREE_OPERAND (t, 0) = node;
|
TREE_OPERAND (t, 0) = node;
|
TREE_BLOCK (t) = NULL_TREE;
|
TREE_BLOCK (t) = NULL_TREE;
|
if (node && !TYPE_P (node))
|
if (node && !TYPE_P (node))
|
{
|
{
|
TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
|
TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
|
TREE_READONLY (t) = TREE_READONLY (node);
|
TREE_READONLY (t) = TREE_READONLY (node);
|
}
|
}
|
|
|
if (TREE_CODE_CLASS (code) == tcc_statement)
|
if (TREE_CODE_CLASS (code) == tcc_statement)
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_SIDE_EFFECTS (t) = 1;
|
else switch (code)
|
else switch (code)
|
{
|
{
|
case VA_ARG_EXPR:
|
case VA_ARG_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. */
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_SIDE_EFFECTS (t) = 1;
|
TREE_READONLY (t) = 0;
|
TREE_READONLY (t) = 0;
|
break;
|
break;
|
|
|
case MISALIGNED_INDIRECT_REF:
|
case MISALIGNED_INDIRECT_REF:
|
case ALIGN_INDIRECT_REF:
|
case ALIGN_INDIRECT_REF:
|
case INDIRECT_REF:
|
case INDIRECT_REF:
|
/* Whether a dereference is readonly has nothing to do with whether
|
/* Whether a dereference is readonly has nothing to do with whether
|
its operand is readonly. */
|
its operand is readonly. */
|
TREE_READONLY (t) = 0;
|
TREE_READONLY (t) = 0;
|
break;
|
break;
|
|
|
case ADDR_EXPR:
|
case ADDR_EXPR:
|
if (node)
|
if (node)
|
recompute_tree_invariant_for_addr_expr (t);
|
recompute_tree_invariant_for_addr_expr (t);
|
break;
|
break;
|
|
|
default:
|
default:
|
if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
|
if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
|
&& node && !TYPE_P (node)
|
&& node && !TYPE_P (node)
|
&& TREE_CONSTANT (node))
|
&& TREE_CONSTANT (node))
|
TREE_CONSTANT (t) = 1;
|
TREE_CONSTANT (t) = 1;
|
if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
|
if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
|
&& node && TREE_INVARIANT (node))
|
&& node && TREE_INVARIANT (node))
|
TREE_INVARIANT (t) = 1;
|
TREE_INVARIANT (t) = 1;
|
if (TREE_CODE_CLASS (code) == tcc_reference
|
if (TREE_CODE_CLASS (code) == tcc_reference
|
&& node && TREE_THIS_VOLATILE (node))
|
&& node && TREE_THIS_VOLATILE (node))
|
TREE_THIS_VOLATILE (t) = 1;
|
TREE_THIS_VOLATILE (t) = 1;
|
break;
|
break;
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
#define PROCESS_ARG(N) \
|
#define PROCESS_ARG(N) \
|
do { \
|
do { \
|
TREE_OPERAND (t, N) = arg##N; \
|
TREE_OPERAND (t, N) = arg##N; \
|
if (arg##N &&!TYPE_P (arg##N)) \
|
if (arg##N &&!TYPE_P (arg##N)) \
|
{ \
|
{ \
|
if (TREE_SIDE_EFFECTS (arg##N)) \
|
if (TREE_SIDE_EFFECTS (arg##N)) \
|
side_effects = 1; \
|
side_effects = 1; \
|
if (!TREE_READONLY (arg##N)) \
|
if (!TREE_READONLY (arg##N)) \
|
read_only = 0; \
|
read_only = 0; \
|
if (!TREE_CONSTANT (arg##N)) \
|
if (!TREE_CONSTANT (arg##N)) \
|
constant = 0; \
|
constant = 0; \
|
if (!TREE_INVARIANT (arg##N)) \
|
if (!TREE_INVARIANT (arg##N)) \
|
invariant = 0; \
|
invariant = 0; \
|
} \
|
} \
|
} while (0)
|
} while (0)
|
|
|
tree
|
tree
|
build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
|
build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
|
{
|
{
|
bool constant, read_only, side_effects, invariant;
|
bool constant, read_only, side_effects, invariant;
|
tree t;
|
tree t;
|
|
|
gcc_assert (TREE_CODE_LENGTH (code) == 2);
|
gcc_assert (TREE_CODE_LENGTH (code) == 2);
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
TREE_TYPE (t) = tt;
|
TREE_TYPE (t) = tt;
|
|
|
/* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
|
/* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
|
result based on those same flags for the arguments. But if the
|
result based on those same flags for the arguments. But if the
|
arguments aren't really even `tree' expressions, we shouldn't be trying
|
arguments aren't really even `tree' expressions, we shouldn't be trying
|
to do this. */
|
to do this. */
|
|
|
/* Expressions without side effects may be constant if their
|
/* Expressions without side effects may be constant if their
|
arguments are as well. */
|
arguments are as well. */
|
constant = (TREE_CODE_CLASS (code) == tcc_comparison
|
constant = (TREE_CODE_CLASS (code) == tcc_comparison
|
|| TREE_CODE_CLASS (code) == tcc_binary);
|
|| TREE_CODE_CLASS (code) == tcc_binary);
|
read_only = 1;
|
read_only = 1;
|
side_effects = TREE_SIDE_EFFECTS (t);
|
side_effects = TREE_SIDE_EFFECTS (t);
|
invariant = constant;
|
invariant = constant;
|
|
|
PROCESS_ARG(0);
|
PROCESS_ARG(0);
|
PROCESS_ARG(1);
|
PROCESS_ARG(1);
|
|
|
TREE_READONLY (t) = read_only;
|
TREE_READONLY (t) = read_only;
|
TREE_CONSTANT (t) = constant;
|
TREE_CONSTANT (t) = constant;
|
TREE_INVARIANT (t) = invariant;
|
TREE_INVARIANT (t) = invariant;
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_THIS_VOLATILE (t)
|
TREE_THIS_VOLATILE (t)
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
tree
|
tree
|
build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
tree arg2 MEM_STAT_DECL)
|
tree arg2 MEM_STAT_DECL)
|
{
|
{
|
bool constant, read_only, side_effects, invariant;
|
bool constant, read_only, side_effects, invariant;
|
tree t;
|
tree t;
|
|
|
gcc_assert (TREE_CODE_LENGTH (code) == 3);
|
gcc_assert (TREE_CODE_LENGTH (code) == 3);
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
TREE_TYPE (t) = tt;
|
TREE_TYPE (t) = tt;
|
|
|
side_effects = TREE_SIDE_EFFECTS (t);
|
side_effects = TREE_SIDE_EFFECTS (t);
|
|
|
PROCESS_ARG(0);
|
PROCESS_ARG(0);
|
PROCESS_ARG(1);
|
PROCESS_ARG(1);
|
PROCESS_ARG(2);
|
PROCESS_ARG(2);
|
|
|
if (code == CALL_EXPR && !side_effects)
|
if (code == CALL_EXPR && !side_effects)
|
{
|
{
|
tree node;
|
tree node;
|
int i;
|
int i;
|
|
|
/* Calls have side-effects, except those to const or
|
/* Calls have side-effects, except those to const or
|
pure functions. */
|
pure functions. */
|
i = call_expr_flags (t);
|
i = call_expr_flags (t);
|
if (!(i & (ECF_CONST | ECF_PURE)))
|
if (!(i & (ECF_CONST | ECF_PURE)))
|
side_effects = 1;
|
side_effects = 1;
|
|
|
/* And even those have side-effects if their arguments do. */
|
/* And even those have side-effects if their arguments do. */
|
else for (node = arg1; node; node = TREE_CHAIN (node))
|
else for (node = arg1; node; node = TREE_CHAIN (node))
|
if (TREE_SIDE_EFFECTS (TREE_VALUE (node)))
|
if (TREE_SIDE_EFFECTS (TREE_VALUE (node)))
|
{
|
{
|
side_effects = 1;
|
side_effects = 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_THIS_VOLATILE (t)
|
TREE_THIS_VOLATILE (t)
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
tree
|
tree
|
build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
tree arg2, tree arg3 MEM_STAT_DECL)
|
tree arg2, tree arg3 MEM_STAT_DECL)
|
{
|
{
|
bool constant, read_only, side_effects, invariant;
|
bool constant, read_only, side_effects, invariant;
|
tree t;
|
tree t;
|
|
|
gcc_assert (TREE_CODE_LENGTH (code) == 4);
|
gcc_assert (TREE_CODE_LENGTH (code) == 4);
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
TREE_TYPE (t) = tt;
|
TREE_TYPE (t) = tt;
|
|
|
side_effects = TREE_SIDE_EFFECTS (t);
|
side_effects = TREE_SIDE_EFFECTS (t);
|
|
|
PROCESS_ARG(0);
|
PROCESS_ARG(0);
|
PROCESS_ARG(1);
|
PROCESS_ARG(1);
|
PROCESS_ARG(2);
|
PROCESS_ARG(2);
|
PROCESS_ARG(3);
|
PROCESS_ARG(3);
|
|
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_THIS_VOLATILE (t)
|
TREE_THIS_VOLATILE (t)
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
tree
|
tree
|
build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
|
tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
|
{
|
{
|
bool constant, read_only, side_effects, invariant;
|
bool constant, read_only, side_effects, invariant;
|
tree t;
|
tree t;
|
|
|
gcc_assert (TREE_CODE_LENGTH (code) == 5);
|
gcc_assert (TREE_CODE_LENGTH (code) == 5);
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
TREE_TYPE (t) = tt;
|
TREE_TYPE (t) = tt;
|
|
|
side_effects = TREE_SIDE_EFFECTS (t);
|
side_effects = TREE_SIDE_EFFECTS (t);
|
|
|
PROCESS_ARG(0);
|
PROCESS_ARG(0);
|
PROCESS_ARG(1);
|
PROCESS_ARG(1);
|
PROCESS_ARG(2);
|
PROCESS_ARG(2);
|
PROCESS_ARG(3);
|
PROCESS_ARG(3);
|
PROCESS_ARG(4);
|
PROCESS_ARG(4);
|
|
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_THIS_VOLATILE (t)
|
TREE_THIS_VOLATILE (t)
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
= (TREE_CODE_CLASS (code) == tcc_reference
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
&& arg0 && TREE_THIS_VOLATILE (arg0));
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
tree
|
tree
|
build7_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
build7_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
|
tree arg2, tree arg3, tree arg4, tree arg5,
|
tree arg2, tree arg3, tree arg4, tree arg5,
|
tree arg6 MEM_STAT_DECL)
|
tree arg6 MEM_STAT_DECL)
|
{
|
{
|
bool constant, read_only, side_effects, invariant;
|
bool constant, read_only, side_effects, invariant;
|
tree t;
|
tree t;
|
|
|
gcc_assert (code == TARGET_MEM_REF);
|
gcc_assert (code == TARGET_MEM_REF);
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
TREE_TYPE (t) = tt;
|
TREE_TYPE (t) = tt;
|
|
|
side_effects = TREE_SIDE_EFFECTS (t);
|
side_effects = TREE_SIDE_EFFECTS (t);
|
|
|
PROCESS_ARG(0);
|
PROCESS_ARG(0);
|
PROCESS_ARG(1);
|
PROCESS_ARG(1);
|
PROCESS_ARG(2);
|
PROCESS_ARG(2);
|
PROCESS_ARG(3);
|
PROCESS_ARG(3);
|
PROCESS_ARG(4);
|
PROCESS_ARG(4);
|
PROCESS_ARG(5);
|
PROCESS_ARG(5);
|
PROCESS_ARG(6);
|
PROCESS_ARG(6);
|
|
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_SIDE_EFFECTS (t) = side_effects;
|
TREE_THIS_VOLATILE (t) = 0;
|
TREE_THIS_VOLATILE (t) = 0;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Similar except don't specify the TREE_TYPE
|
/* Similar except don't specify the TREE_TYPE
|
and leave the TREE_SIDE_EFFECTS as 0.
|
and leave the TREE_SIDE_EFFECTS as 0.
|
It is permissible for arguments to be null,
|
It is permissible for arguments to be null,
|
or even garbage if their values do not matter. */
|
or even garbage if their values do not matter. */
|
|
|
tree
|
tree
|
build_nt (enum tree_code code, ...)
|
build_nt (enum tree_code code, ...)
|
{
|
{
|
tree t;
|
tree t;
|
int length;
|
int length;
|
int i;
|
int i;
|
va_list p;
|
va_list p;
|
|
|
va_start (p, code);
|
va_start (p, code);
|
|
|
t = make_node (code);
|
t = make_node (code);
|
length = TREE_CODE_LENGTH (code);
|
length = TREE_CODE_LENGTH (code);
|
|
|
for (i = 0; i < length; i++)
|
for (i = 0; i < length; i++)
|
TREE_OPERAND (t, i) = va_arg (p, tree);
|
TREE_OPERAND (t, i) = va_arg (p, tree);
|
|
|
va_end (p);
|
va_end (p);
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Create a DECL_... node of code CODE, name NAME and data type TYPE.
|
/* Create a DECL_... node of code CODE, name NAME and data type TYPE.
|
We do NOT enter this node in any sort of symbol table.
|
We do NOT enter this node in any sort of symbol table.
|
|
|
layout_decl is used to set up the decl's storage layout.
|
layout_decl is used to set up the decl's storage layout.
|
Other slots are initialized to 0 or null pointers. */
|
Other slots are initialized to 0 or null pointers. */
|
|
|
tree
|
tree
|
build_decl_stat (enum tree_code code, tree name, tree type MEM_STAT_DECL)
|
build_decl_stat (enum tree_code code, tree name, tree type MEM_STAT_DECL)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
t = make_node_stat (code PASS_MEM_STAT);
|
t = make_node_stat (code PASS_MEM_STAT);
|
|
|
/* if (type == error_mark_node)
|
/* if (type == error_mark_node)
|
type = integer_type_node; */
|
type = integer_type_node; */
|
/* That is not done, deliberately, so that having error_mark_node
|
/* That is not done, deliberately, so that having error_mark_node
|
as the type can suppress useless errors in the use of this variable. */
|
as the type can suppress useless errors in the use of this variable. */
|
|
|
DECL_NAME (t) = name;
|
DECL_NAME (t) = name;
|
TREE_TYPE (t) = type;
|
TREE_TYPE (t) = type;
|
|
|
if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
|
if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
|
layout_decl (t, 0);
|
layout_decl (t, 0);
|
else if (code == FUNCTION_DECL)
|
else if (code == FUNCTION_DECL)
|
DECL_MODE (t) = FUNCTION_MODE;
|
DECL_MODE (t) = FUNCTION_MODE;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Builds and returns function declaration with NAME and TYPE. */
|
/* Builds and returns function declaration with NAME and TYPE. */
|
|
|
tree
|
tree
|
build_fn_decl (const char *name, tree type)
|
build_fn_decl (const char *name, tree type)
|
{
|
{
|
tree id = get_identifier (name);
|
tree id = get_identifier (name);
|
tree decl = build_decl (FUNCTION_DECL, id, type);
|
tree decl = build_decl (FUNCTION_DECL, id, type);
|
|
|
DECL_EXTERNAL (decl) = 1;
|
DECL_EXTERNAL (decl) = 1;
|
TREE_PUBLIC (decl) = 1;
|
TREE_PUBLIC (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
DECL_ARTIFICIAL (decl) = 1;
|
TREE_NOTHROW (decl) = 1;
|
TREE_NOTHROW (decl) = 1;
|
|
|
return decl;
|
return decl;
|
}
|
}
|
|
|
|
|
/* BLOCK nodes are used to represent the structure of binding contours
|
/* BLOCK nodes are used to represent the structure of binding contours
|
and declarations, once those contours have been exited and their contents
|
and declarations, once those contours have been exited and their contents
|
compiled. This information is used for outputting debugging info. */
|
compiled. This information is used for outputting debugging info. */
|
|
|
tree
|
tree
|
build_block (tree vars, tree subblocks, tree supercontext, tree chain)
|
build_block (tree vars, tree subblocks, tree supercontext, tree chain)
|
{
|
{
|
tree block = make_node (BLOCK);
|
tree block = make_node (BLOCK);
|
|
|
BLOCK_VARS (block) = vars;
|
BLOCK_VARS (block) = vars;
|
BLOCK_SUBBLOCKS (block) = subblocks;
|
BLOCK_SUBBLOCKS (block) = subblocks;
|
BLOCK_SUPERCONTEXT (block) = supercontext;
|
BLOCK_SUPERCONTEXT (block) = supercontext;
|
BLOCK_CHAIN (block) = chain;
|
BLOCK_CHAIN (block) = chain;
|
return block;
|
return block;
|
}
|
}
|
|
|
#if 1 /* ! defined(USE_MAPPED_LOCATION) */
|
#if 1 /* ! defined(USE_MAPPED_LOCATION) */
|
/* ??? gengtype doesn't handle conditionals */
|
/* ??? gengtype doesn't handle conditionals */
|
static GTY(()) source_locus last_annotated_node;
|
static GTY(()) source_locus last_annotated_node;
|
#endif
|
#endif
|
|
|
#ifdef USE_MAPPED_LOCATION
|
#ifdef USE_MAPPED_LOCATION
|
|
|
expanded_location
|
expanded_location
|
expand_location (source_location loc)
|
expand_location (source_location loc)
|
{
|
{
|
expanded_location xloc;
|
expanded_location xloc;
|
if (loc == 0) { xloc.file = NULL; xloc.line = 0; xloc.column = 0; }
|
if (loc == 0) { xloc.file = NULL; xloc.line = 0; xloc.column = 0; }
|
else
|
else
|
{
|
{
|
const struct line_map *map = linemap_lookup (&line_table, loc);
|
const struct line_map *map = linemap_lookup (&line_table, loc);
|
xloc.file = map->to_file;
|
xloc.file = map->to_file;
|
xloc.line = SOURCE_LINE (map, loc);
|
xloc.line = SOURCE_LINE (map, loc);
|
xloc.column = SOURCE_COLUMN (map, loc);
|
xloc.column = SOURCE_COLUMN (map, loc);
|
};
|
};
|
return xloc;
|
return xloc;
|
}
|
}
|
|
|
#else
|
#else
|
|
|
/* Record the exact location where an expression or an identifier were
|
/* Record the exact location where an expression or an identifier were
|
encountered. */
|
encountered. */
|
|
|
void
|
void
|
annotate_with_file_line (tree node, const char *file, int line)
|
annotate_with_file_line (tree node, const char *file, int line)
|
{
|
{
|
/* Roughly one percent of the calls to this function are to annotate
|
/* Roughly one percent of the calls to this function are to annotate
|
a node with the same information already attached to that node!
|
a node with the same information already attached to that node!
|
Just return instead of wasting memory. */
|
Just return instead of wasting memory. */
|
if (EXPR_LOCUS (node)
|
if (EXPR_LOCUS (node)
|
&& EXPR_LINENO (node) == line
|
&& EXPR_LINENO (node) == line
|
&& (EXPR_FILENAME (node) == file
|
&& (EXPR_FILENAME (node) == file
|
|| !strcmp (EXPR_FILENAME (node), file)))
|
|| !strcmp (EXPR_FILENAME (node), file)))
|
{
|
{
|
last_annotated_node = EXPR_LOCUS (node);
|
last_annotated_node = EXPR_LOCUS (node);
|
return;
|
return;
|
}
|
}
|
|
|
/* In heavily macroized code (such as GCC itself) this single
|
/* In heavily macroized code (such as GCC itself) this single
|
entry cache can reduce the number of allocations by more
|
entry cache can reduce the number of allocations by more
|
than half. */
|
than half. */
|
if (last_annotated_node
|
if (last_annotated_node
|
&& last_annotated_node->line == line
|
&& last_annotated_node->line == line
|
&& (last_annotated_node->file == file
|
&& (last_annotated_node->file == file
|
|| !strcmp (last_annotated_node->file, file)))
|
|| !strcmp (last_annotated_node->file, file)))
|
{
|
{
|
SET_EXPR_LOCUS (node, last_annotated_node);
|
SET_EXPR_LOCUS (node, last_annotated_node);
|
return;
|
return;
|
}
|
}
|
|
|
SET_EXPR_LOCUS (node, ggc_alloc (sizeof (location_t)));
|
SET_EXPR_LOCUS (node, ggc_alloc (sizeof (location_t)));
|
EXPR_LINENO (node) = line;
|
EXPR_LINENO (node) = line;
|
EXPR_FILENAME (node) = file;
|
EXPR_FILENAME (node) = file;
|
last_annotated_node = EXPR_LOCUS (node);
|
last_annotated_node = EXPR_LOCUS (node);
|
}
|
}
|
|
|
void
|
void
|
annotate_with_locus (tree node, location_t locus)
|
annotate_with_locus (tree node, location_t locus)
|
{
|
{
|
annotate_with_file_line (node, locus.file, locus.line);
|
annotate_with_file_line (node, locus.file, locus.line);
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
|
/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
|
is ATTRIBUTE. */
|
is ATTRIBUTE. */
|
|
|
tree
|
tree
|
build_decl_attribute_variant (tree ddecl, tree attribute)
|
build_decl_attribute_variant (tree ddecl, tree attribute)
|
{
|
{
|
DECL_ATTRIBUTES (ddecl) = attribute;
|
DECL_ATTRIBUTES (ddecl) = attribute;
|
return ddecl;
|
return ddecl;
|
}
|
}
|
|
|
/* Borrowed from hashtab.c iterative_hash implementation. */
|
/* Borrowed from hashtab.c iterative_hash implementation. */
|
#define mix(a,b,c) \
|
#define mix(a,b,c) \
|
{ \
|
{ \
|
a -= b; a -= c; a ^= (c>>13); \
|
a -= b; a -= c; a ^= (c>>13); \
|
b -= c; b -= a; b ^= (a<< 8); \
|
b -= c; b -= a; b ^= (a<< 8); \
|
c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
|
c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
|
a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
|
a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
|
b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
|
b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
|
c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
|
c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
|
a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
|
a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
|
b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
|
b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
|
c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
|
c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
|
}
|
}
|
|
|
|
|
/* Produce good hash value combining VAL and VAL2. */
|
/* Produce good hash value combining VAL and VAL2. */
|
static inline hashval_t
|
static inline hashval_t
|
iterative_hash_hashval_t (hashval_t val, hashval_t val2)
|
iterative_hash_hashval_t (hashval_t val, hashval_t val2)
|
{
|
{
|
/* the golden ratio; an arbitrary value. */
|
/* the golden ratio; an arbitrary value. */
|
hashval_t a = 0x9e3779b9;
|
hashval_t a = 0x9e3779b9;
|
|
|
mix (a, val, val2);
|
mix (a, val, val2);
|
return val2;
|
return val2;
|
}
|
}
|
|
|
/* Produce good hash value combining PTR and VAL2. */
|
/* Produce good hash value combining PTR and VAL2. */
|
static inline hashval_t
|
static inline hashval_t
|
iterative_hash_pointer (void *ptr, hashval_t val2)
|
iterative_hash_pointer (void *ptr, hashval_t val2)
|
{
|
{
|
if (sizeof (ptr) == sizeof (hashval_t))
|
if (sizeof (ptr) == sizeof (hashval_t))
|
return iterative_hash_hashval_t ((size_t) ptr, val2);
|
return iterative_hash_hashval_t ((size_t) ptr, val2);
|
else
|
else
|
{
|
{
|
hashval_t a = (hashval_t) (size_t) ptr;
|
hashval_t a = (hashval_t) (size_t) ptr;
|
/* Avoid warnings about shifting of more than the width of the type on
|
/* Avoid warnings about shifting of more than the width of the type on
|
hosts that won't execute this path. */
|
hosts that won't execute this path. */
|
int zero = 0;
|
int zero = 0;
|
hashval_t b = (hashval_t) ((size_t) ptr >> (sizeof (hashval_t) * 8 + zero));
|
hashval_t b = (hashval_t) ((size_t) ptr >> (sizeof (hashval_t) * 8 + zero));
|
mix (a, b, val2);
|
mix (a, b, val2);
|
return val2;
|
return val2;
|
}
|
}
|
}
|
}
|
|
|
/* Produce good hash value combining VAL and VAL2. */
|
/* Produce good hash value combining VAL and VAL2. */
|
static inline hashval_t
|
static inline hashval_t
|
iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
|
iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
|
{
|
{
|
if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
|
if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
|
return iterative_hash_hashval_t (val, val2);
|
return iterative_hash_hashval_t (val, val2);
|
else
|
else
|
{
|
{
|
hashval_t a = (hashval_t) val;
|
hashval_t a = (hashval_t) val;
|
/* Avoid warnings about shifting of more than the width of the type on
|
/* Avoid warnings about shifting of more than the width of the type on
|
hosts that won't execute this path. */
|
hosts that won't execute this path. */
|
int zero = 0;
|
int zero = 0;
|
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
|
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
|
mix (a, b, val2);
|
mix (a, b, val2);
|
if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
|
if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
|
{
|
{
|
hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
|
hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
|
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
|
hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
|
mix (a, b, val2);
|
mix (a, b, val2);
|
}
|
}
|
return val2;
|
return val2;
|
}
|
}
|
}
|
}
|
|
|
/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
|
/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
|
is ATTRIBUTE and its qualifiers are QUALS.
|
is ATTRIBUTE and its qualifiers are QUALS.
|
|
|
Record such modified types already made so we don't make duplicates. */
|
Record such modified types already made so we don't make duplicates. */
|
|
|
static tree
|
static tree
|
build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
|
build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
|
{
|
{
|
if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
|
if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
|
{
|
{
|
hashval_t hashcode = 0;
|
hashval_t hashcode = 0;
|
tree ntype;
|
tree ntype;
|
enum tree_code code = TREE_CODE (ttype);
|
enum tree_code code = TREE_CODE (ttype);
|
|
|
ntype = copy_node (ttype);
|
ntype = copy_node (ttype);
|
|
|
TYPE_POINTER_TO (ntype) = 0;
|
TYPE_POINTER_TO (ntype) = 0;
|
TYPE_REFERENCE_TO (ntype) = 0;
|
TYPE_REFERENCE_TO (ntype) = 0;
|
TYPE_ATTRIBUTES (ntype) = attribute;
|
TYPE_ATTRIBUTES (ntype) = attribute;
|
|
|
/* Create a new main variant of TYPE. */
|
/* Create a new main variant of TYPE. */
|
TYPE_MAIN_VARIANT (ntype) = ntype;
|
TYPE_MAIN_VARIANT (ntype) = ntype;
|
TYPE_NEXT_VARIANT (ntype) = 0;
|
TYPE_NEXT_VARIANT (ntype) = 0;
|
set_type_quals (ntype, TYPE_UNQUALIFIED);
|
set_type_quals (ntype, TYPE_UNQUALIFIED);
|
|
|
hashcode = iterative_hash_object (code, hashcode);
|
hashcode = iterative_hash_object (code, hashcode);
|
if (TREE_TYPE (ntype))
|
if (TREE_TYPE (ntype))
|
hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
|
hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
|
hashcode);
|
hashcode);
|
hashcode = attribute_hash_list (attribute, hashcode);
|
hashcode = attribute_hash_list (attribute, hashcode);
|
|
|
switch (TREE_CODE (ntype))
|
switch (TREE_CODE (ntype))
|
{
|
{
|
case FUNCTION_TYPE:
|
case FUNCTION_TYPE:
|
hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
|
hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
|
break;
|
break;
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
|
hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
|
hashcode);
|
hashcode);
|
break;
|
break;
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
hashcode = iterative_hash_object
|
hashcode = iterative_hash_object
|
(TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
|
(TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
|
hashcode = iterative_hash_object
|
hashcode = iterative_hash_object
|
(TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
|
(TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
|
break;
|
break;
|
case REAL_TYPE:
|
case REAL_TYPE:
|
{
|
{
|
unsigned int precision = TYPE_PRECISION (ntype);
|
unsigned int precision = TYPE_PRECISION (ntype);
|
hashcode = iterative_hash_object (precision, hashcode);
|
hashcode = iterative_hash_object (precision, hashcode);
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
ntype = type_hash_canon (hashcode, ntype);
|
ntype = type_hash_canon (hashcode, ntype);
|
ttype = build_qualified_type (ntype, quals);
|
ttype = build_qualified_type (ntype, quals);
|
}
|
}
|
|
|
return ttype;
|
return ttype;
|
}
|
}
|
|
|
|
|
/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
|
/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
|
is ATTRIBUTE.
|
is ATTRIBUTE.
|
|
|
Record such modified types already made so we don't make duplicates. */
|
Record such modified types already made so we don't make duplicates. */
|
|
|
tree
|
tree
|
build_type_attribute_variant (tree ttype, tree attribute)
|
build_type_attribute_variant (tree ttype, tree attribute)
|
{
|
{
|
return build_type_attribute_qual_variant (ttype, attribute,
|
return build_type_attribute_qual_variant (ttype, attribute,
|
TYPE_QUALS (ttype));
|
TYPE_QUALS (ttype));
|
}
|
}
|
|
|
/* Return nonzero if IDENT is a valid name for attribute ATTR,
|
/* Return nonzero if IDENT is a valid name for attribute ATTR,
|
or zero if not.
|
or zero if not.
|
|
|
We try both `text' and `__text__', ATTR may be either one. */
|
We try both `text' and `__text__', ATTR may be either one. */
|
/* ??? It might be a reasonable simplification to require ATTR to be only
|
/* ??? It might be a reasonable simplification to require ATTR to be only
|
`text'. One might then also require attribute lists to be stored in
|
`text'. One might then also require attribute lists to be stored in
|
their canonicalized form. */
|
their canonicalized form. */
|
|
|
static int
|
static int
|
is_attribute_with_length_p (const char *attr, int attr_len, tree ident)
|
is_attribute_with_length_p (const char *attr, int attr_len, tree ident)
|
{
|
{
|
int ident_len;
|
int ident_len;
|
const char *p;
|
const char *p;
|
|
|
if (TREE_CODE (ident) != IDENTIFIER_NODE)
|
if (TREE_CODE (ident) != IDENTIFIER_NODE)
|
return 0;
|
return 0;
|
|
|
p = IDENTIFIER_POINTER (ident);
|
p = IDENTIFIER_POINTER (ident);
|
ident_len = IDENTIFIER_LENGTH (ident);
|
ident_len = IDENTIFIER_LENGTH (ident);
|
|
|
if (ident_len == attr_len
|
if (ident_len == attr_len
|
&& strcmp (attr, p) == 0)
|
&& strcmp (attr, p) == 0)
|
return 1;
|
return 1;
|
|
|
/* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
|
/* If ATTR is `__text__', IDENT must be `text'; and vice versa. */
|
if (attr[0] == '_')
|
if (attr[0] == '_')
|
{
|
{
|
gcc_assert (attr[1] == '_');
|
gcc_assert (attr[1] == '_');
|
gcc_assert (attr[attr_len - 2] == '_');
|
gcc_assert (attr[attr_len - 2] == '_');
|
gcc_assert (attr[attr_len - 1] == '_');
|
gcc_assert (attr[attr_len - 1] == '_');
|
if (ident_len == attr_len - 4
|
if (ident_len == attr_len - 4
|
&& strncmp (attr + 2, p, attr_len - 4) == 0)
|
&& strncmp (attr + 2, p, attr_len - 4) == 0)
|
return 1;
|
return 1;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (ident_len == attr_len + 4
|
if (ident_len == attr_len + 4
|
&& p[0] == '_' && p[1] == '_'
|
&& p[0] == '_' && p[1] == '_'
|
&& p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
|
&& p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
|
&& strncmp (attr, p + 2, attr_len) == 0)
|
&& strncmp (attr, p + 2, attr_len) == 0)
|
return 1;
|
return 1;
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return nonzero if IDENT is a valid name for attribute ATTR,
|
/* Return nonzero if IDENT is a valid name for attribute ATTR,
|
or zero if not.
|
or zero if not.
|
|
|
We try both `text' and `__text__', ATTR may be either one. */
|
We try both `text' and `__text__', ATTR may be either one. */
|
|
|
int
|
int
|
is_attribute_p (const char *attr, tree ident)
|
is_attribute_p (const char *attr, tree ident)
|
{
|
{
|
return is_attribute_with_length_p (attr, strlen (attr), ident);
|
return is_attribute_with_length_p (attr, strlen (attr), ident);
|
}
|
}
|
|
|
/* Given an attribute name and a list of attributes, return a pointer to the
|
/* Given an attribute name and a list of attributes, return a pointer to the
|
attribute's list element if the attribute is part of the list, or NULL_TREE
|
attribute's list element if the attribute is part of the list, or NULL_TREE
|
if not found. If the attribute appears more than once, this only
|
if not found. If the attribute appears more than once, this only
|
returns the first occurrence; the TREE_CHAIN of the return value should
|
returns the first occurrence; the TREE_CHAIN of the return value should
|
be passed back in if further occurrences are wanted. */
|
be passed back in if further occurrences are wanted. */
|
|
|
tree
|
tree
|
lookup_attribute (const char *attr_name, tree list)
|
lookup_attribute (const char *attr_name, tree list)
|
{
|
{
|
tree l;
|
tree l;
|
size_t attr_len = strlen (attr_name);
|
size_t attr_len = strlen (attr_name);
|
|
|
for (l = list; l; l = TREE_CHAIN (l))
|
for (l = list; l; l = TREE_CHAIN (l))
|
{
|
{
|
gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
|
gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
|
if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
|
if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
|
return l;
|
return l;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Remove any instances of attribute ATTR_NAME in LIST and return the
|
/* Remove any instances of attribute ATTR_NAME in LIST and return the
|
modified list. */
|
modified list. */
|
|
|
tree
|
tree
|
remove_attribute (const char *attr_name, tree list)
|
remove_attribute (const char *attr_name, tree list)
|
{
|
{
|
tree *p;
|
tree *p;
|
size_t attr_len = strlen (attr_name);
|
size_t attr_len = strlen (attr_name);
|
|
|
for (p = &list; *p; )
|
for (p = &list; *p; )
|
{
|
{
|
tree l = *p;
|
tree l = *p;
|
gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
|
gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
|
if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
|
if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
|
*p = TREE_CHAIN (l);
|
*p = TREE_CHAIN (l);
|
else
|
else
|
p = &TREE_CHAIN (l);
|
p = &TREE_CHAIN (l);
|
}
|
}
|
|
|
return list;
|
return list;
|
}
|
}
|
|
|
/* Return an attribute list that is the union of a1 and a2. */
|
/* Return an attribute list that is the union of a1 and a2. */
|
|
|
tree
|
tree
|
merge_attributes (tree a1, tree a2)
|
merge_attributes (tree a1, tree a2)
|
{
|
{
|
tree attributes;
|
tree attributes;
|
|
|
/* Either one unset? Take the set one. */
|
/* Either one unset? Take the set one. */
|
|
|
if ((attributes = a1) == 0)
|
if ((attributes = a1) == 0)
|
attributes = a2;
|
attributes = a2;
|
|
|
/* One that completely contains the other? Take it. */
|
/* One that completely contains the other? Take it. */
|
|
|
else if (a2 != 0 && ! attribute_list_contained (a1, a2))
|
else if (a2 != 0 && ! attribute_list_contained (a1, a2))
|
{
|
{
|
if (attribute_list_contained (a2, a1))
|
if (attribute_list_contained (a2, a1))
|
attributes = a2;
|
attributes = a2;
|
else
|
else
|
{
|
{
|
/* Pick the longest list, and hang on the other list. */
|
/* Pick the longest list, and hang on the other list. */
|
|
|
if (list_length (a1) < list_length (a2))
|
if (list_length (a1) < list_length (a2))
|
attributes = a2, a2 = a1;
|
attributes = a2, a2 = a1;
|
|
|
for (; a2 != 0; a2 = TREE_CHAIN (a2))
|
for (; a2 != 0; a2 = TREE_CHAIN (a2))
|
{
|
{
|
tree a;
|
tree a;
|
for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
|
for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
|
attributes);
|
attributes);
|
a != NULL_TREE;
|
a != NULL_TREE;
|
a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
|
a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
|
TREE_CHAIN (a)))
|
TREE_CHAIN (a)))
|
{
|
{
|
if (TREE_VALUE (a) != NULL
|
if (TREE_VALUE (a) != NULL
|
&& TREE_CODE (TREE_VALUE (a)) == TREE_LIST
|
&& TREE_CODE (TREE_VALUE (a)) == TREE_LIST
|
&& TREE_VALUE (a2) != NULL
|
&& TREE_VALUE (a2) != NULL
|
&& TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
|
&& TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
|
{
|
{
|
if (simple_cst_list_equal (TREE_VALUE (a),
|
if (simple_cst_list_equal (TREE_VALUE (a),
|
TREE_VALUE (a2)) == 1)
|
TREE_VALUE (a2)) == 1)
|
break;
|
break;
|
}
|
}
|
else if (simple_cst_equal (TREE_VALUE (a),
|
else if (simple_cst_equal (TREE_VALUE (a),
|
TREE_VALUE (a2)) == 1)
|
TREE_VALUE (a2)) == 1)
|
break;
|
break;
|
}
|
}
|
if (a == NULL_TREE)
|
if (a == NULL_TREE)
|
{
|
{
|
a1 = copy_node (a2);
|
a1 = copy_node (a2);
|
TREE_CHAIN (a1) = attributes;
|
TREE_CHAIN (a1) = attributes;
|
attributes = a1;
|
attributes = a1;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
return attributes;
|
return attributes;
|
}
|
}
|
|
|
/* Given types T1 and T2, merge their attributes and return
|
/* Given types T1 and T2, merge their attributes and return
|
the result. */
|
the result. */
|
|
|
tree
|
tree
|
merge_type_attributes (tree t1, tree t2)
|
merge_type_attributes (tree t1, tree t2)
|
{
|
{
|
return merge_attributes (TYPE_ATTRIBUTES (t1),
|
return merge_attributes (TYPE_ATTRIBUTES (t1),
|
TYPE_ATTRIBUTES (t2));
|
TYPE_ATTRIBUTES (t2));
|
}
|
}
|
|
|
/* Given decls OLDDECL and NEWDECL, merge their attributes and return
|
/* Given decls OLDDECL and NEWDECL, merge their attributes and return
|
the result. */
|
the result. */
|
|
|
tree
|
tree
|
merge_decl_attributes (tree olddecl, tree newdecl)
|
merge_decl_attributes (tree olddecl, tree newdecl)
|
{
|
{
|
return merge_attributes (DECL_ATTRIBUTES (olddecl),
|
return merge_attributes (DECL_ATTRIBUTES (olddecl),
|
DECL_ATTRIBUTES (newdecl));
|
DECL_ATTRIBUTES (newdecl));
|
}
|
}
|
|
|
#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
|
#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
|
|
|
/* Specialization of merge_decl_attributes for various Windows targets.
|
/* Specialization of merge_decl_attributes for various Windows targets.
|
|
|
This handles the following situation:
|
This handles the following situation:
|
|
|
__declspec (dllimport) int foo;
|
__declspec (dllimport) int foo;
|
int foo;
|
int foo;
|
|
|
The second instance of `foo' nullifies the dllimport. */
|
The second instance of `foo' nullifies the dllimport. */
|
|
|
tree
|
tree
|
merge_dllimport_decl_attributes (tree old, tree new)
|
merge_dllimport_decl_attributes (tree old, tree new)
|
{
|
{
|
tree a;
|
tree a;
|
int delete_dllimport_p = 1;
|
int delete_dllimport_p = 1;
|
|
|
/* What we need to do here is remove from `old' dllimport if it doesn't
|
/* What we need to do here is remove from `old' dllimport if it doesn't
|
appear in `new'. dllimport behaves like extern: if a declaration is
|
appear in `new'. dllimport behaves like extern: if a declaration is
|
marked dllimport and a definition appears later, then the object
|
marked dllimport and a definition appears later, then the object
|
is not dllimport'd. We also remove a `new' dllimport if the old list
|
is not dllimport'd. We also remove a `new' dllimport if the old list
|
contains dllexport: dllexport always overrides dllimport, regardless
|
contains dllexport: dllexport always overrides dllimport, regardless
|
of the order of declaration. */
|
of the order of declaration. */
|
if (!VAR_OR_FUNCTION_DECL_P (new))
|
if (!VAR_OR_FUNCTION_DECL_P (new))
|
delete_dllimport_p = 0;
|
delete_dllimport_p = 0;
|
else if (DECL_DLLIMPORT_P (new)
|
else if (DECL_DLLIMPORT_P (new)
|
&& lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
|
&& lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
|
{
|
{
|
DECL_DLLIMPORT_P (new) = 0;
|
DECL_DLLIMPORT_P (new) = 0;
|
warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
|
warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
|
"dllimport ignored", new);
|
"dllimport ignored", new);
|
}
|
}
|
else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new))
|
else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new))
|
{
|
{
|
/* Warn about overriding a symbol that has already been used. eg:
|
/* Warn about overriding a symbol that has already been used. eg:
|
extern int __attribute__ ((dllimport)) foo;
|
extern int __attribute__ ((dllimport)) foo;
|
int* bar () {return &foo;}
|
int* bar () {return &foo;}
|
int foo;
|
int foo;
|
*/
|
*/
|
if (TREE_USED (old))
|
if (TREE_USED (old))
|
{
|
{
|
warning (0, "%q+D redeclared without dllimport attribute "
|
warning (0, "%q+D redeclared without dllimport attribute "
|
"after being referenced with dll linkage", new);
|
"after being referenced with dll linkage", new);
|
/* If we have used a variable's address with dllimport linkage,
|
/* If we have used a variable's address with dllimport linkage,
|
keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
|
keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
|
decl may already have had TREE_INVARIANT and TREE_CONSTANT
|
decl may already have had TREE_INVARIANT and TREE_CONSTANT
|
computed.
|
computed.
|
We still remove the attribute so that assembler code refers
|
We still remove the attribute so that assembler code refers
|
to '&foo rather than '_imp__foo'. */
|
to '&foo rather than '_imp__foo'. */
|
if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
|
if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
|
DECL_DLLIMPORT_P (new) = 1;
|
DECL_DLLIMPORT_P (new) = 1;
|
}
|
}
|
|
|
/* Let an inline definition silently override the external reference,
|
/* Let an inline definition silently override the external reference,
|
but otherwise warn about attribute inconsistency. */
|
but otherwise warn about attribute inconsistency. */
|
else if (TREE_CODE (new) == VAR_DECL
|
else if (TREE_CODE (new) == VAR_DECL
|
|| !DECL_DECLARED_INLINE_P (new))
|
|| !DECL_DECLARED_INLINE_P (new))
|
warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
|
warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
|
"previous dllimport ignored", new);
|
"previous dllimport ignored", new);
|
}
|
}
|
else
|
else
|
delete_dllimport_p = 0;
|
delete_dllimport_p = 0;
|
|
|
a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new));
|
a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new));
|
|
|
if (delete_dllimport_p)
|
if (delete_dllimport_p)
|
{
|
{
|
tree prev, t;
|
tree prev, t;
|
const size_t attr_len = strlen ("dllimport");
|
const size_t attr_len = strlen ("dllimport");
|
|
|
/* Scan the list for dllimport and delete it. */
|
/* Scan the list for dllimport and delete it. */
|
for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
|
for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
|
{
|
{
|
if (is_attribute_with_length_p ("dllimport", attr_len,
|
if (is_attribute_with_length_p ("dllimport", attr_len,
|
TREE_PURPOSE (t)))
|
TREE_PURPOSE (t)))
|
{
|
{
|
if (prev == NULL_TREE)
|
if (prev == NULL_TREE)
|
a = TREE_CHAIN (a);
|
a = TREE_CHAIN (a);
|
else
|
else
|
TREE_CHAIN (prev) = TREE_CHAIN (t);
|
TREE_CHAIN (prev) = TREE_CHAIN (t);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
return a;
|
return a;
|
}
|
}
|
|
|
/* Handle a "dllimport" or "dllexport" attribute; arguments as in
|
/* Handle a "dllimport" or "dllexport" attribute; arguments as in
|
struct attribute_spec.handler. */
|
struct attribute_spec.handler. */
|
|
|
tree
|
tree
|
handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
|
handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
|
bool *no_add_attrs)
|
bool *no_add_attrs)
|
{
|
{
|
tree node = *pnode;
|
tree node = *pnode;
|
|
|
/* These attributes may apply to structure and union types being created,
|
/* These attributes may apply to structure and union types being created,
|
but otherwise should pass to the declaration involved. */
|
but otherwise should pass to the declaration involved. */
|
if (!DECL_P (node))
|
if (!DECL_P (node))
|
{
|
{
|
if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
|
if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
|
| (int) ATTR_FLAG_ARRAY_NEXT))
|
| (int) ATTR_FLAG_ARRAY_NEXT))
|
{
|
{
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
return tree_cons (name, args, NULL_TREE);
|
return tree_cons (name, args, NULL_TREE);
|
}
|
}
|
if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
|
if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE)
|
{
|
{
|
warning (OPT_Wattributes, "%qs attribute ignored",
|
warning (OPT_Wattributes, "%qs attribute ignored",
|
IDENTIFIER_POINTER (name));
|
IDENTIFIER_POINTER (name));
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
if (TREE_CODE (node) != FUNCTION_DECL
|
if (TREE_CODE (node) != FUNCTION_DECL
|
&& TREE_CODE (node) != VAR_DECL)
|
&& TREE_CODE (node) != VAR_DECL)
|
{
|
{
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
warning (OPT_Wattributes, "%qs attribute ignored",
|
warning (OPT_Wattributes, "%qs attribute ignored",
|
IDENTIFIER_POINTER (name));
|
IDENTIFIER_POINTER (name));
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Report error on dllimport ambiguities seen now before they cause
|
/* Report error on dllimport ambiguities seen now before they cause
|
any damage. */
|
any damage. */
|
else if (is_attribute_p ("dllimport", name))
|
else if (is_attribute_p ("dllimport", name))
|
{
|
{
|
/* Honor any target-specific overrides. */
|
/* Honor any target-specific overrides. */
|
if (!targetm.valid_dllimport_attribute_p (node))
|
if (!targetm.valid_dllimport_attribute_p (node))
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
|
|
else if (TREE_CODE (node) == FUNCTION_DECL
|
else if (TREE_CODE (node) == FUNCTION_DECL
|
&& DECL_DECLARED_INLINE_P (node))
|
&& DECL_DECLARED_INLINE_P (node))
|
{
|
{
|
warning (OPT_Wattributes, "inline function %q+D declared as "
|
warning (OPT_Wattributes, "inline function %q+D declared as "
|
" dllimport: attribute ignored", node);
|
" dllimport: attribute ignored", node);
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
/* Like MS, treat definition of dllimported variables and
|
/* Like MS, treat definition of dllimported variables and
|
non-inlined functions on declaration as syntax errors. */
|
non-inlined functions on declaration as syntax errors. */
|
else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
|
else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
|
{
|
{
|
error ("function %q+D definition is marked dllimport", node);
|
error ("function %q+D definition is marked dllimport", node);
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
else if (TREE_CODE (node) == VAR_DECL)
|
else if (TREE_CODE (node) == VAR_DECL)
|
{
|
{
|
if (DECL_INITIAL (node))
|
if (DECL_INITIAL (node))
|
{
|
{
|
error ("variable %q+D definition is marked dllimport",
|
error ("variable %q+D definition is marked dllimport",
|
node);
|
node);
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
/* `extern' needn't be specified with dllimport.
|
/* `extern' needn't be specified with dllimport.
|
Specify `extern' now and hope for the best. Sigh. */
|
Specify `extern' now and hope for the best. Sigh. */
|
DECL_EXTERNAL (node) = 1;
|
DECL_EXTERNAL (node) = 1;
|
/* Also, implicitly give dllimport'd variables declared within
|
/* Also, implicitly give dllimport'd variables declared within
|
a function global scope, unless declared static. */
|
a function global scope, unless declared static. */
|
if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
|
if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
|
TREE_PUBLIC (node) = 1;
|
TREE_PUBLIC (node) = 1;
|
}
|
}
|
|
|
if (*no_add_attrs == false)
|
if (*no_add_attrs == false)
|
DECL_DLLIMPORT_P (node) = 1;
|
DECL_DLLIMPORT_P (node) = 1;
|
}
|
}
|
|
|
/* Report error if symbol is not accessible at global scope. */
|
/* Report error if symbol is not accessible at global scope. */
|
if (!TREE_PUBLIC (node)
|
if (!TREE_PUBLIC (node)
|
&& (TREE_CODE (node) == VAR_DECL
|
&& (TREE_CODE (node) == VAR_DECL
|
|| TREE_CODE (node) == FUNCTION_DECL))
|
|| TREE_CODE (node) == FUNCTION_DECL))
|
{
|
{
|
error ("external linkage required for symbol %q+D because of "
|
error ("external linkage required for symbol %q+D because of "
|
"%qs attribute", node, IDENTIFIER_POINTER (name));
|
"%qs attribute", node, IDENTIFIER_POINTER (name));
|
*no_add_attrs = true;
|
*no_add_attrs = true;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
|
#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */
|
|
|
/* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
|
/* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
|
of the various TYPE_QUAL values. */
|
of the various TYPE_QUAL values. */
|
|
|
static void
|
static void
|
set_type_quals (tree type, int type_quals)
|
set_type_quals (tree type, int type_quals)
|
{
|
{
|
TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
|
TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
|
TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
|
TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
|
TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
|
TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
|
}
|
}
|
|
|
/* Returns true iff cand is equivalent to base with type_quals. */
|
/* Returns true iff cand is equivalent to base with type_quals. */
|
|
|
bool
|
bool
|
check_qualified_type (tree cand, tree base, int type_quals)
|
check_qualified_type (tree cand, tree base, int type_quals)
|
{
|
{
|
return (TYPE_QUALS (cand) == type_quals
|
return (TYPE_QUALS (cand) == type_quals
|
&& TYPE_NAME (cand) == TYPE_NAME (base)
|
&& TYPE_NAME (cand) == TYPE_NAME (base)
|
/* Apparently this is needed for Objective-C. */
|
/* Apparently this is needed for Objective-C. */
|
&& TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
|
&& TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
|
&& attribute_list_equal (TYPE_ATTRIBUTES (cand),
|
&& attribute_list_equal (TYPE_ATTRIBUTES (cand),
|
TYPE_ATTRIBUTES (base)));
|
TYPE_ATTRIBUTES (base)));
|
}
|
}
|
|
|
/* Return a version of the TYPE, qualified as indicated by the
|
/* Return a version of the TYPE, qualified as indicated by the
|
TYPE_QUALS, if one exists. If no qualified version exists yet,
|
TYPE_QUALS, if one exists. If no qualified version exists yet,
|
return NULL_TREE. */
|
return NULL_TREE. */
|
|
|
tree
|
tree
|
get_qualified_type (tree type, int type_quals)
|
get_qualified_type (tree type, int type_quals)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
if (TYPE_QUALS (type) == type_quals)
|
if (TYPE_QUALS (type) == type_quals)
|
return type;
|
return type;
|
|
|
/* Search the chain of variants to see if there is already one there just
|
/* Search the chain of variants to see if there is already one there just
|
like the one we need to have. If so, use that existing one. We must
|
like the one we need to have. If so, use that existing one. We must
|
preserve the TYPE_NAME, since there is code that depends on this. */
|
preserve the TYPE_NAME, since there is code that depends on this. */
|
for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
|
for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
|
if (check_qualified_type (t, type, type_quals))
|
if (check_qualified_type (t, type, type_quals))
|
return t;
|
return t;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Like get_qualified_type, but creates the type if it does not
|
/* Like get_qualified_type, but creates the type if it does not
|
exist. This function never returns NULL_TREE. */
|
exist. This function never returns NULL_TREE. */
|
|
|
tree
|
tree
|
build_qualified_type (tree type, int type_quals)
|
build_qualified_type (tree type, int type_quals)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* See if we already have the appropriate qualified variant. */
|
/* See if we already have the appropriate qualified variant. */
|
t = get_qualified_type (type, type_quals);
|
t = get_qualified_type (type, type_quals);
|
|
|
/* If not, build it. */
|
/* If not, build it. */
|
if (!t)
|
if (!t)
|
{
|
{
|
t = build_variant_type_copy (type);
|
t = build_variant_type_copy (type);
|
set_type_quals (t, type_quals);
|
set_type_quals (t, type_quals);
|
}
|
}
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Create a new distinct copy of TYPE. The new type is made its own
|
/* Create a new distinct copy of TYPE. The new type is made its own
|
MAIN_VARIANT. */
|
MAIN_VARIANT. */
|
|
|
tree
|
tree
|
build_distinct_type_copy (tree type)
|
build_distinct_type_copy (tree type)
|
{
|
{
|
tree t = copy_node (type);
|
tree t = copy_node (type);
|
|
|
TYPE_POINTER_TO (t) = 0;
|
TYPE_POINTER_TO (t) = 0;
|
TYPE_REFERENCE_TO (t) = 0;
|
TYPE_REFERENCE_TO (t) = 0;
|
|
|
/* Make it its own variant. */
|
/* Make it its own variant. */
|
TYPE_MAIN_VARIANT (t) = t;
|
TYPE_MAIN_VARIANT (t) = t;
|
TYPE_NEXT_VARIANT (t) = 0;
|
TYPE_NEXT_VARIANT (t) = 0;
|
|
|
/* Note that it is now possible for TYPE_MIN_VALUE to be a value
|
/* Note that it is now possible for TYPE_MIN_VALUE to be a value
|
whose TREE_TYPE is not t. This can also happen in the Ada
|
whose TREE_TYPE is not t. This can also happen in the Ada
|
frontend when using subtypes. */
|
frontend when using subtypes. */
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Create a new variant of TYPE, equivalent but distinct.
|
/* Create a new variant of TYPE, equivalent but distinct.
|
This is so the caller can modify it. */
|
This is so the caller can modify it. */
|
|
|
tree
|
tree
|
build_variant_type_copy (tree type)
|
build_variant_type_copy (tree type)
|
{
|
{
|
tree t, m = TYPE_MAIN_VARIANT (type);
|
tree t, m = TYPE_MAIN_VARIANT (type);
|
|
|
t = build_distinct_type_copy (type);
|
t = build_distinct_type_copy (type);
|
|
|
/* Add the new type to the chain of variants of TYPE. */
|
/* Add the new type to the chain of variants of TYPE. */
|
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
|
TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
|
TYPE_NEXT_VARIANT (m) = t;
|
TYPE_NEXT_VARIANT (m) = t;
|
TYPE_MAIN_VARIANT (t) = m;
|
TYPE_MAIN_VARIANT (t) = m;
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return true if the from tree in both tree maps are equal. */
|
/* Return true if the from tree in both tree maps are equal. */
|
|
|
int
|
int
|
tree_map_eq (const void *va, const void *vb)
|
tree_map_eq (const void *va, const void *vb)
|
{
|
{
|
const struct tree_map *a = va, *b = vb;
|
const struct tree_map *a = va, *b = vb;
|
return (a->from == b->from);
|
return (a->from == b->from);
|
}
|
}
|
|
|
/* Hash a from tree in a tree_map. */
|
/* Hash a from tree in a tree_map. */
|
|
|
unsigned int
|
unsigned int
|
tree_map_hash (const void *item)
|
tree_map_hash (const void *item)
|
{
|
{
|
return (((const struct tree_map *) item)->hash);
|
return (((const struct tree_map *) item)->hash);
|
}
|
}
|
|
|
/* Return true if this tree map structure is marked for garbage collection
|
/* Return true if this tree map structure is marked for garbage collection
|
purposes. We simply return true if the from tree is marked, so that this
|
purposes. We simply return true if the from tree is marked, so that this
|
structure goes away when the from tree goes away. */
|
structure goes away when the from tree goes away. */
|
|
|
int
|
int
|
tree_map_marked_p (const void *p)
|
tree_map_marked_p (const void *p)
|
{
|
{
|
tree from = ((struct tree_map *) p)->from;
|
tree from = ((struct tree_map *) p)->from;
|
|
|
return ggc_marked_p (from);
|
return ggc_marked_p (from);
|
}
|
}
|
|
|
/* Return true if the trees in the tree_int_map *'s VA and VB are equal. */
|
/* Return true if the trees in the tree_int_map *'s VA and VB are equal. */
|
|
|
static int
|
static int
|
tree_int_map_eq (const void *va, const void *vb)
|
tree_int_map_eq (const void *va, const void *vb)
|
{
|
{
|
const struct tree_int_map *a = va, *b = vb;
|
const struct tree_int_map *a = va, *b = vb;
|
return (a->from == b->from);
|
return (a->from == b->from);
|
}
|
}
|
|
|
/* Hash a from tree in the tree_int_map * ITEM. */
|
/* Hash a from tree in the tree_int_map * ITEM. */
|
|
|
static unsigned int
|
static unsigned int
|
tree_int_map_hash (const void *item)
|
tree_int_map_hash (const void *item)
|
{
|
{
|
return htab_hash_pointer (((const struct tree_int_map *)item)->from);
|
return htab_hash_pointer (((const struct tree_int_map *)item)->from);
|
}
|
}
|
|
|
/* Return true if this tree int map structure is marked for garbage collection
|
/* Return true if this tree int map structure is marked for garbage collection
|
purposes. We simply return true if the from tree_int_map *P's from tree is marked, so that this
|
purposes. We simply return true if the from tree_int_map *P's from tree is marked, so that this
|
structure goes away when the from tree goes away. */
|
structure goes away when the from tree goes away. */
|
|
|
static int
|
static int
|
tree_int_map_marked_p (const void *p)
|
tree_int_map_marked_p (const void *p)
|
{
|
{
|
tree from = ((struct tree_int_map *) p)->from;
|
tree from = ((struct tree_int_map *) p)->from;
|
|
|
return ggc_marked_p (from);
|
return ggc_marked_p (from);
|
}
|
}
|
/* Lookup an init priority for FROM, and return it if we find one. */
|
/* Lookup an init priority for FROM, and return it if we find one. */
|
|
|
unsigned short
|
unsigned short
|
decl_init_priority_lookup (tree from)
|
decl_init_priority_lookup (tree from)
|
{
|
{
|
struct tree_int_map *h, in;
|
struct tree_int_map *h, in;
|
in.from = from;
|
in.from = from;
|
|
|
h = htab_find_with_hash (init_priority_for_decl,
|
h = htab_find_with_hash (init_priority_for_decl,
|
&in, htab_hash_pointer (from));
|
&in, htab_hash_pointer (from));
|
if (h)
|
if (h)
|
return h->to;
|
return h->to;
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Insert a mapping FROM->TO in the init priority hashtable. */
|
/* Insert a mapping FROM->TO in the init priority hashtable. */
|
|
|
void
|
void
|
decl_init_priority_insert (tree from, unsigned short to)
|
decl_init_priority_insert (tree from, unsigned short to)
|
{
|
{
|
struct tree_int_map *h;
|
struct tree_int_map *h;
|
void **loc;
|
void **loc;
|
|
|
h = ggc_alloc (sizeof (struct tree_int_map));
|
h = ggc_alloc (sizeof (struct tree_int_map));
|
h->from = from;
|
h->from = from;
|
h->to = to;
|
h->to = to;
|
loc = htab_find_slot_with_hash (init_priority_for_decl, h,
|
loc = htab_find_slot_with_hash (init_priority_for_decl, h,
|
htab_hash_pointer (from), INSERT);
|
htab_hash_pointer (from), INSERT);
|
*(struct tree_int_map **) loc = h;
|
*(struct tree_int_map **) loc = h;
|
}
|
}
|
|
|
/* Look up a restrict qualified base decl for FROM. */
|
/* Look up a restrict qualified base decl for FROM. */
|
|
|
tree
|
tree
|
decl_restrict_base_lookup (tree from)
|
decl_restrict_base_lookup (tree from)
|
{
|
{
|
struct tree_map *h;
|
struct tree_map *h;
|
struct tree_map in;
|
struct tree_map in;
|
|
|
in.from = from;
|
in.from = from;
|
h = htab_find_with_hash (restrict_base_for_decl, &in,
|
h = htab_find_with_hash (restrict_base_for_decl, &in,
|
htab_hash_pointer (from));
|
htab_hash_pointer (from));
|
return h ? h->to : NULL_TREE;
|
return h ? h->to : NULL_TREE;
|
}
|
}
|
|
|
/* Record the restrict qualified base TO for FROM. */
|
/* Record the restrict qualified base TO for FROM. */
|
|
|
void
|
void
|
decl_restrict_base_insert (tree from, tree to)
|
decl_restrict_base_insert (tree from, tree to)
|
{
|
{
|
struct tree_map *h;
|
struct tree_map *h;
|
void **loc;
|
void **loc;
|
|
|
h = ggc_alloc (sizeof (struct tree_map));
|
h = ggc_alloc (sizeof (struct tree_map));
|
h->hash = htab_hash_pointer (from);
|
h->hash = htab_hash_pointer (from);
|
h->from = from;
|
h->from = from;
|
h->to = to;
|
h->to = to;
|
loc = htab_find_slot_with_hash (restrict_base_for_decl, h, h->hash, INSERT);
|
loc = htab_find_slot_with_hash (restrict_base_for_decl, h, h->hash, INSERT);
|
*(struct tree_map **) loc = h;
|
*(struct tree_map **) loc = h;
|
}
|
}
|
|
|
/* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
|
/* Print out the statistics for the DECL_DEBUG_EXPR hash table. */
|
|
|
static void
|
static void
|
print_debug_expr_statistics (void)
|
print_debug_expr_statistics (void)
|
{
|
{
|
fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
|
fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
|
(long) htab_size (debug_expr_for_decl),
|
(long) htab_size (debug_expr_for_decl),
|
(long) htab_elements (debug_expr_for_decl),
|
(long) htab_elements (debug_expr_for_decl),
|
htab_collisions (debug_expr_for_decl));
|
htab_collisions (debug_expr_for_decl));
|
}
|
}
|
|
|
/* Print out the statistics for the DECL_VALUE_EXPR hash table. */
|
/* Print out the statistics for the DECL_VALUE_EXPR hash table. */
|
|
|
static void
|
static void
|
print_value_expr_statistics (void)
|
print_value_expr_statistics (void)
|
{
|
{
|
fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
|
fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
|
(long) htab_size (value_expr_for_decl),
|
(long) htab_size (value_expr_for_decl),
|
(long) htab_elements (value_expr_for_decl),
|
(long) htab_elements (value_expr_for_decl),
|
htab_collisions (value_expr_for_decl));
|
htab_collisions (value_expr_for_decl));
|
}
|
}
|
|
|
/* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but
|
/* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but
|
don't print anything if the table is empty. */
|
don't print anything if the table is empty. */
|
|
|
static void
|
static void
|
print_restrict_base_statistics (void)
|
print_restrict_base_statistics (void)
|
{
|
{
|
if (htab_elements (restrict_base_for_decl) != 0)
|
if (htab_elements (restrict_base_for_decl) != 0)
|
fprintf (stderr,
|
fprintf (stderr,
|
"RESTRICT_BASE hash: size %ld, %ld elements, %f collisions\n",
|
"RESTRICT_BASE hash: size %ld, %ld elements, %f collisions\n",
|
(long) htab_size (restrict_base_for_decl),
|
(long) htab_size (restrict_base_for_decl),
|
(long) htab_elements (restrict_base_for_decl),
|
(long) htab_elements (restrict_base_for_decl),
|
htab_collisions (restrict_base_for_decl));
|
htab_collisions (restrict_base_for_decl));
|
}
|
}
|
|
|
/* Lookup a debug expression for FROM, and return it if we find one. */
|
/* Lookup a debug expression for FROM, and return it if we find one. */
|
|
|
tree
|
tree
|
decl_debug_expr_lookup (tree from)
|
decl_debug_expr_lookup (tree from)
|
{
|
{
|
struct tree_map *h, in;
|
struct tree_map *h, in;
|
in.from = from;
|
in.from = from;
|
|
|
h = htab_find_with_hash (debug_expr_for_decl, &in, htab_hash_pointer (from));
|
h = htab_find_with_hash (debug_expr_for_decl, &in, htab_hash_pointer (from));
|
if (h)
|
if (h)
|
return h->to;
|
return h->to;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Insert a mapping FROM->TO in the debug expression hashtable. */
|
/* Insert a mapping FROM->TO in the debug expression hashtable. */
|
|
|
void
|
void
|
decl_debug_expr_insert (tree from, tree to)
|
decl_debug_expr_insert (tree from, tree to)
|
{
|
{
|
struct tree_map *h;
|
struct tree_map *h;
|
void **loc;
|
void **loc;
|
|
|
h = ggc_alloc (sizeof (struct tree_map));
|
h = ggc_alloc (sizeof (struct tree_map));
|
h->hash = htab_hash_pointer (from);
|
h->hash = htab_hash_pointer (from);
|
h->from = from;
|
h->from = from;
|
h->to = to;
|
h->to = to;
|
loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
|
loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
|
*(struct tree_map **) loc = h;
|
*(struct tree_map **) loc = h;
|
}
|
}
|
|
|
/* Lookup a value expression for FROM, and return it if we find one. */
|
/* Lookup a value expression for FROM, and return it if we find one. */
|
|
|
tree
|
tree
|
decl_value_expr_lookup (tree from)
|
decl_value_expr_lookup (tree from)
|
{
|
{
|
struct tree_map *h, in;
|
struct tree_map *h, in;
|
in.from = from;
|
in.from = from;
|
|
|
h = htab_find_with_hash (value_expr_for_decl, &in, htab_hash_pointer (from));
|
h = htab_find_with_hash (value_expr_for_decl, &in, htab_hash_pointer (from));
|
if (h)
|
if (h)
|
return h->to;
|
return h->to;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Insert a mapping FROM->TO in the value expression hashtable. */
|
/* Insert a mapping FROM->TO in the value expression hashtable. */
|
|
|
void
|
void
|
decl_value_expr_insert (tree from, tree to)
|
decl_value_expr_insert (tree from, tree to)
|
{
|
{
|
struct tree_map *h;
|
struct tree_map *h;
|
void **loc;
|
void **loc;
|
|
|
h = ggc_alloc (sizeof (struct tree_map));
|
h = ggc_alloc (sizeof (struct tree_map));
|
h->hash = htab_hash_pointer (from);
|
h->hash = htab_hash_pointer (from);
|
h->from = from;
|
h->from = from;
|
h->to = to;
|
h->to = to;
|
loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
|
loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
|
*(struct tree_map **) loc = h;
|
*(struct tree_map **) loc = h;
|
}
|
}
|
|
|
/* Hashing of types so that we don't make duplicates.
|
/* Hashing of types so that we don't make duplicates.
|
The entry point is `type_hash_canon'. */
|
The entry point is `type_hash_canon'. */
|
|
|
/* Compute a hash code for a list of types (chain of TREE_LIST nodes
|
/* Compute a hash code for a list of types (chain of TREE_LIST nodes
|
with types in the TREE_VALUE slots), by adding the hash codes
|
with types in the TREE_VALUE slots), by adding the hash codes
|
of the individual types. */
|
of the individual types. */
|
|
|
unsigned int
|
unsigned int
|
type_hash_list (tree list, hashval_t hashcode)
|
type_hash_list (tree list, hashval_t hashcode)
|
{
|
{
|
tree tail;
|
tree tail;
|
|
|
for (tail = list; tail; tail = TREE_CHAIN (tail))
|
for (tail = list; tail; tail = TREE_CHAIN (tail))
|
if (TREE_VALUE (tail) != error_mark_node)
|
if (TREE_VALUE (tail) != error_mark_node)
|
hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
|
hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
|
hashcode);
|
hashcode);
|
|
|
return hashcode;
|
return hashcode;
|
}
|
}
|
|
|
/* These are the Hashtable callback functions. */
|
/* These are the Hashtable callback functions. */
|
|
|
/* Returns true iff the types are equivalent. */
|
/* Returns true iff the types are equivalent. */
|
|
|
static int
|
static int
|
type_hash_eq (const void *va, const void *vb)
|
type_hash_eq (const void *va, const void *vb)
|
{
|
{
|
const struct type_hash *a = va, *b = vb;
|
const struct type_hash *a = va, *b = vb;
|
|
|
/* First test the things that are the same for all types. */
|
/* First test the things that are the same for all types. */
|
if (a->hash != b->hash
|
if (a->hash != b->hash
|
|| TREE_CODE (a->type) != TREE_CODE (b->type)
|
|| TREE_CODE (a->type) != TREE_CODE (b->type)
|
|| TREE_TYPE (a->type) != TREE_TYPE (b->type)
|
|| TREE_TYPE (a->type) != TREE_TYPE (b->type)
|
|| !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
|
|| !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
|
TYPE_ATTRIBUTES (b->type))
|
TYPE_ATTRIBUTES (b->type))
|
|| TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
|
|| TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
|
|| TYPE_MODE (a->type) != TYPE_MODE (b->type))
|
|| TYPE_MODE (a->type) != TYPE_MODE (b->type))
|
return 0;
|
return 0;
|
|
|
switch (TREE_CODE (a->type))
|
switch (TREE_CODE (a->type))
|
{
|
{
|
case VOID_TYPE:
|
case VOID_TYPE:
|
case COMPLEX_TYPE:
|
case COMPLEX_TYPE:
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
return 1;
|
return 1;
|
|
|
case VECTOR_TYPE:
|
case VECTOR_TYPE:
|
return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
|
return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
|
|
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
|
if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
|
&& !(TYPE_VALUES (a->type)
|
&& !(TYPE_VALUES (a->type)
|
&& TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
|
&& TYPE_VALUES (b->type)
|
&& TYPE_VALUES (b->type)
|
&& TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
|
&& type_list_equal (TYPE_VALUES (a->type),
|
&& type_list_equal (TYPE_VALUES (a->type),
|
TYPE_VALUES (b->type))))
|
TYPE_VALUES (b->type))))
|
return 0;
|
return 0;
|
|
|
/* ... fall through ... */
|
/* ... fall through ... */
|
|
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
case REAL_TYPE:
|
case REAL_TYPE:
|
case BOOLEAN_TYPE:
|
case BOOLEAN_TYPE:
|
return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
|
return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
|
|| tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
|
|| tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
|
TYPE_MAX_VALUE (b->type)))
|
TYPE_MAX_VALUE (b->type)))
|
&& (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
|
&& (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
|
|| tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
|
|| tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
|
TYPE_MIN_VALUE (b->type))));
|
TYPE_MIN_VALUE (b->type))));
|
|
|
case OFFSET_TYPE:
|
case OFFSET_TYPE:
|
return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
|
return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
|
|
|
case METHOD_TYPE:
|
case METHOD_TYPE:
|
return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
|
return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
|
&& (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
|
&& (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
|
|| (TYPE_ARG_TYPES (a->type)
|
|| (TYPE_ARG_TYPES (a->type)
|
&& TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
|
&& TYPE_ARG_TYPES (b->type)
|
&& TYPE_ARG_TYPES (b->type)
|
&& TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
|
&& type_list_equal (TYPE_ARG_TYPES (a->type),
|
&& type_list_equal (TYPE_ARG_TYPES (a->type),
|
TYPE_ARG_TYPES (b->type)))));
|
TYPE_ARG_TYPES (b->type)))));
|
|
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
|
return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
|
|
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
|
return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
|
|| (TYPE_FIELDS (a->type)
|
|| (TYPE_FIELDS (a->type)
|
&& TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
|
&& TYPE_FIELDS (b->type)
|
&& TYPE_FIELDS (b->type)
|
&& TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
|
&& type_list_equal (TYPE_FIELDS (a->type),
|
&& type_list_equal (TYPE_FIELDS (a->type),
|
TYPE_FIELDS (b->type))));
|
TYPE_FIELDS (b->type))));
|
|
|
case FUNCTION_TYPE:
|
case FUNCTION_TYPE:
|
return (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
|
return (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
|
|| (TYPE_ARG_TYPES (a->type)
|
|| (TYPE_ARG_TYPES (a->type)
|
&& TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
|
&& TYPE_ARG_TYPES (b->type)
|
&& TYPE_ARG_TYPES (b->type)
|
&& TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
|
&& TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
|
&& type_list_equal (TYPE_ARG_TYPES (a->type),
|
&& type_list_equal (TYPE_ARG_TYPES (a->type),
|
TYPE_ARG_TYPES (b->type))));
|
TYPE_ARG_TYPES (b->type))));
|
|
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
/* Return the cached hash value. */
|
/* Return the cached hash value. */
|
|
|
static hashval_t
|
static hashval_t
|
type_hash_hash (const void *item)
|
type_hash_hash (const void *item)
|
{
|
{
|
return ((const struct type_hash *) item)->hash;
|
return ((const struct type_hash *) item)->hash;
|
}
|
}
|
|
|
/* Look in the type hash table for a type isomorphic to TYPE.
|
/* Look in the type hash table for a type isomorphic to TYPE.
|
If one is found, return it. Otherwise return 0. */
|
If one is found, return it. Otherwise return 0. */
|
|
|
tree
|
tree
|
type_hash_lookup (hashval_t hashcode, tree type)
|
type_hash_lookup (hashval_t hashcode, tree type)
|
{
|
{
|
struct type_hash *h, in;
|
struct type_hash *h, in;
|
|
|
/* The TYPE_ALIGN field of a type is set by layout_type(), so we
|
/* The TYPE_ALIGN field of a type is set by layout_type(), so we
|
must call that routine before comparing TYPE_ALIGNs. */
|
must call that routine before comparing TYPE_ALIGNs. */
|
layout_type (type);
|
layout_type (type);
|
|
|
in.hash = hashcode;
|
in.hash = hashcode;
|
in.type = type;
|
in.type = type;
|
|
|
h = htab_find_with_hash (type_hash_table, &in, hashcode);
|
h = htab_find_with_hash (type_hash_table, &in, hashcode);
|
if (h)
|
if (h)
|
return h->type;
|
return h->type;
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Add an entry to the type-hash-table
|
/* Add an entry to the type-hash-table
|
for a type TYPE whose hash code is HASHCODE. */
|
for a type TYPE whose hash code is HASHCODE. */
|
|
|
void
|
void
|
type_hash_add (hashval_t hashcode, tree type)
|
type_hash_add (hashval_t hashcode, tree type)
|
{
|
{
|
struct type_hash *h;
|
struct type_hash *h;
|
void **loc;
|
void **loc;
|
|
|
h = ggc_alloc (sizeof (struct type_hash));
|
h = ggc_alloc (sizeof (struct type_hash));
|
h->hash = hashcode;
|
h->hash = hashcode;
|
h->type = type;
|
h->type = type;
|
loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
|
loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
|
*(struct type_hash **) loc = h;
|
*(struct type_hash **) loc = h;
|
}
|
}
|
|
|
/* Given TYPE, and HASHCODE its hash code, return the canonical
|
/* Given TYPE, and HASHCODE its hash code, return the canonical
|
object for an identical type if one already exists.
|
object for an identical type if one already exists.
|
Otherwise, return TYPE, and record it as the canonical object.
|
Otherwise, return TYPE, and record it as the canonical object.
|
|
|
To use this function, first create a type of the sort you want.
|
To use this function, first create a type of the sort you want.
|
Then compute its hash code from the fields of the type that
|
Then compute its hash code from the fields of the type that
|
make it different from other similar types.
|
make it different from other similar types.
|
Then call this function and use the value. */
|
Then call this function and use the value. */
|
|
|
tree
|
tree
|
type_hash_canon (unsigned int hashcode, tree type)
|
type_hash_canon (unsigned int hashcode, tree type)
|
{
|
{
|
tree t1;
|
tree t1;
|
|
|
/* The hash table only contains main variants, so ensure that's what we're
|
/* The hash table only contains main variants, so ensure that's what we're
|
being passed. */
|
being passed. */
|
gcc_assert (TYPE_MAIN_VARIANT (type) == type);
|
gcc_assert (TYPE_MAIN_VARIANT (type) == type);
|
|
|
if (!lang_hooks.types.hash_types)
|
if (!lang_hooks.types.hash_types)
|
return type;
|
return type;
|
|
|
/* See if the type is in the hash table already. If so, return it.
|
/* See if the type is in the hash table already. If so, return it.
|
Otherwise, add the type. */
|
Otherwise, add the type. */
|
t1 = type_hash_lookup (hashcode, type);
|
t1 = type_hash_lookup (hashcode, type);
|
if (t1 != 0)
|
if (t1 != 0)
|
{
|
{
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_counts[(int) t_kind]--;
|
tree_node_counts[(int) t_kind]--;
|
tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
|
tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
|
#endif
|
#endif
|
return t1;
|
return t1;
|
}
|
}
|
else
|
else
|
{
|
{
|
type_hash_add (hashcode, type);
|
type_hash_add (hashcode, type);
|
return type;
|
return type;
|
}
|
}
|
}
|
}
|
|
|
/* See if the data pointed to by the type hash table is marked. We consider
|
/* See if the data pointed to by the type hash table is marked. We consider
|
it marked if the type is marked or if a debug type number or symbol
|
it marked if the type is marked or if a debug type number or symbol
|
table entry has been made for the type. This reduces the amount of
|
table entry has been made for the type. This reduces the amount of
|
debugging output and eliminates that dependency of the debug output on
|
debugging output and eliminates that dependency of the debug output on
|
the number of garbage collections. */
|
the number of garbage collections. */
|
|
|
static int
|
static int
|
type_hash_marked_p (const void *p)
|
type_hash_marked_p (const void *p)
|
{
|
{
|
tree type = ((struct type_hash *) p)->type;
|
tree type = ((struct type_hash *) p)->type;
|
|
|
return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
|
return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
|
}
|
}
|
|
|
static void
|
static void
|
print_type_hash_statistics (void)
|
print_type_hash_statistics (void)
|
{
|
{
|
fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
|
fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
|
(long) htab_size (type_hash_table),
|
(long) htab_size (type_hash_table),
|
(long) htab_elements (type_hash_table),
|
(long) htab_elements (type_hash_table),
|
htab_collisions (type_hash_table));
|
htab_collisions (type_hash_table));
|
}
|
}
|
|
|
/* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
|
/* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
|
with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
|
with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
|
by adding the hash codes of the individual attributes. */
|
by adding the hash codes of the individual attributes. */
|
|
|
unsigned int
|
unsigned int
|
attribute_hash_list (tree list, hashval_t hashcode)
|
attribute_hash_list (tree list, hashval_t hashcode)
|
{
|
{
|
tree tail;
|
tree tail;
|
|
|
for (tail = list; tail; tail = TREE_CHAIN (tail))
|
for (tail = list; tail; tail = TREE_CHAIN (tail))
|
/* ??? Do we want to add in TREE_VALUE too? */
|
/* ??? Do we want to add in TREE_VALUE too? */
|
hashcode = iterative_hash_object
|
hashcode = iterative_hash_object
|
(IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
|
(IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
|
return hashcode;
|
return hashcode;
|
}
|
}
|
|
|
/* Given two lists of attributes, return true if list l2 is
|
/* Given two lists of attributes, return true if list l2 is
|
equivalent to l1. */
|
equivalent to l1. */
|
|
|
int
|
int
|
attribute_list_equal (tree l1, tree l2)
|
attribute_list_equal (tree l1, tree l2)
|
{
|
{
|
return attribute_list_contained (l1, l2)
|
return attribute_list_contained (l1, l2)
|
&& attribute_list_contained (l2, l1);
|
&& attribute_list_contained (l2, l1);
|
}
|
}
|
|
|
/* Given two lists of attributes, return true if list L2 is
|
/* Given two lists of attributes, return true if list L2 is
|
completely contained within L1. */
|
completely contained within L1. */
|
/* ??? This would be faster if attribute names were stored in a canonicalized
|
/* ??? This would be faster if attribute names were stored in a canonicalized
|
form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
|
form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
|
must be used to show these elements are equivalent (which they are). */
|
must be used to show these elements are equivalent (which they are). */
|
/* ??? It's not clear that attributes with arguments will always be handled
|
/* ??? It's not clear that attributes with arguments will always be handled
|
correctly. */
|
correctly. */
|
|
|
int
|
int
|
attribute_list_contained (tree l1, tree l2)
|
attribute_list_contained (tree l1, tree l2)
|
{
|
{
|
tree t1, t2;
|
tree t1, t2;
|
|
|
/* First check the obvious, maybe the lists are identical. */
|
/* First check the obvious, maybe the lists are identical. */
|
if (l1 == l2)
|
if (l1 == l2)
|
return 1;
|
return 1;
|
|
|
/* Maybe the lists are similar. */
|
/* Maybe the lists are similar. */
|
for (t1 = l1, t2 = l2;
|
for (t1 = l1, t2 = l2;
|
t1 != 0 && t2 != 0
|
t1 != 0 && t2 != 0
|
&& TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
|
&& TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
|
&& TREE_VALUE (t1) == TREE_VALUE (t2);
|
&& TREE_VALUE (t1) == TREE_VALUE (t2);
|
t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
|
t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
|
|
|
/* Maybe the lists are equal. */
|
/* Maybe the lists are equal. */
|
if (t1 == 0 && t2 == 0)
|
if (t1 == 0 && t2 == 0)
|
return 1;
|
return 1;
|
|
|
for (; t2 != 0; t2 = TREE_CHAIN (t2))
|
for (; t2 != 0; t2 = TREE_CHAIN (t2))
|
{
|
{
|
tree attr;
|
tree attr;
|
for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
|
for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
|
attr != NULL_TREE;
|
attr != NULL_TREE;
|
attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
|
attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
|
TREE_CHAIN (attr)))
|
TREE_CHAIN (attr)))
|
{
|
{
|
if (TREE_VALUE (t2) != NULL
|
if (TREE_VALUE (t2) != NULL
|
&& TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
|
&& TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
|
&& TREE_VALUE (attr) != NULL
|
&& TREE_VALUE (attr) != NULL
|
&& TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
|
&& TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
|
{
|
{
|
if (simple_cst_list_equal (TREE_VALUE (t2),
|
if (simple_cst_list_equal (TREE_VALUE (t2),
|
TREE_VALUE (attr)) == 1)
|
TREE_VALUE (attr)) == 1)
|
break;
|
break;
|
}
|
}
|
else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
|
else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
|
break;
|
break;
|
}
|
}
|
|
|
if (attr == 0)
|
if (attr == 0)
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Given two lists of types
|
/* Given two lists of types
|
(chains of TREE_LIST nodes with types in the TREE_VALUE slots)
|
(chains of TREE_LIST nodes with types in the TREE_VALUE slots)
|
return 1 if the lists contain the same types in the same order.
|
return 1 if the lists contain the same types in the same order.
|
Also, the TREE_PURPOSEs must match. */
|
Also, the TREE_PURPOSEs must match. */
|
|
|
int
|
int
|
type_list_equal (tree l1, tree l2)
|
type_list_equal (tree l1, tree l2)
|
{
|
{
|
tree t1, t2;
|
tree t1, t2;
|
|
|
for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
|
for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
|
if (TREE_VALUE (t1) != TREE_VALUE (t2)
|
if (TREE_VALUE (t1) != TREE_VALUE (t2)
|
|| (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
|
|| (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
|
&& ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
|
&& ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
|
&& (TREE_TYPE (TREE_PURPOSE (t1))
|
&& (TREE_TYPE (TREE_PURPOSE (t1))
|
== TREE_TYPE (TREE_PURPOSE (t2))))))
|
== TREE_TYPE (TREE_PURPOSE (t2))))))
|
return 0;
|
return 0;
|
|
|
return t1 == t2;
|
return t1 == t2;
|
}
|
}
|
|
|
/* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
|
/* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
|
given by TYPE. If the argument list accepts variable arguments,
|
given by TYPE. If the argument list accepts variable arguments,
|
then this function counts only the ordinary arguments. */
|
then this function counts only the ordinary arguments. */
|
|
|
int
|
int
|
type_num_arguments (tree type)
|
type_num_arguments (tree type)
|
{
|
{
|
int i = 0;
|
int i = 0;
|
tree t;
|
tree t;
|
|
|
for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
|
for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
|
/* If the function does not take a variable number of arguments,
|
/* If the function does not take a variable number of arguments,
|
the last element in the list will have type `void'. */
|
the last element in the list will have type `void'. */
|
if (VOID_TYPE_P (TREE_VALUE (t)))
|
if (VOID_TYPE_P (TREE_VALUE (t)))
|
break;
|
break;
|
else
|
else
|
++i;
|
++i;
|
|
|
return i;
|
return i;
|
}
|
}
|
|
|
/* Nonzero if integer constants T1 and T2
|
/* Nonzero if integer constants T1 and T2
|
represent the same constant value. */
|
represent the same constant value. */
|
|
|
int
|
int
|
tree_int_cst_equal (tree t1, tree t2)
|
tree_int_cst_equal (tree t1, tree t2)
|
{
|
{
|
if (t1 == t2)
|
if (t1 == t2)
|
return 1;
|
return 1;
|
|
|
if (t1 == 0 || t2 == 0)
|
if (t1 == 0 || t2 == 0)
|
return 0;
|
return 0;
|
|
|
if (TREE_CODE (t1) == INTEGER_CST
|
if (TREE_CODE (t1) == INTEGER_CST
|
&& TREE_CODE (t2) == INTEGER_CST
|
&& TREE_CODE (t2) == INTEGER_CST
|
&& TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
|
&& TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
|
&& TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
|
&& TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
|
return 1;
|
return 1;
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Nonzero if integer constants T1 and T2 represent values that satisfy <.
|
/* Nonzero if integer constants T1 and T2 represent values that satisfy <.
|
The precise way of comparison depends on their data type. */
|
The precise way of comparison depends on their data type. */
|
|
|
int
|
int
|
tree_int_cst_lt (tree t1, tree t2)
|
tree_int_cst_lt (tree t1, tree t2)
|
{
|
{
|
if (t1 == t2)
|
if (t1 == t2)
|
return 0;
|
return 0;
|
|
|
if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
|
if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
|
{
|
{
|
int t1_sgn = tree_int_cst_sgn (t1);
|
int t1_sgn = tree_int_cst_sgn (t1);
|
int t2_sgn = tree_int_cst_sgn (t2);
|
int t2_sgn = tree_int_cst_sgn (t2);
|
|
|
if (t1_sgn < t2_sgn)
|
if (t1_sgn < t2_sgn)
|
return 1;
|
return 1;
|
else if (t1_sgn > t2_sgn)
|
else if (t1_sgn > t2_sgn)
|
return 0;
|
return 0;
|
/* Otherwise, both are non-negative, so we compare them as
|
/* Otherwise, both are non-negative, so we compare them as
|
unsigned just in case one of them would overflow a signed
|
unsigned just in case one of them would overflow a signed
|
type. */
|
type. */
|
}
|
}
|
else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
|
else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
|
return INT_CST_LT (t1, t2);
|
return INT_CST_LT (t1, t2);
|
|
|
return INT_CST_LT_UNSIGNED (t1, t2);
|
return INT_CST_LT_UNSIGNED (t1, t2);
|
}
|
}
|
|
|
/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
|
/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */
|
|
|
int
|
int
|
tree_int_cst_compare (tree t1, tree t2)
|
tree_int_cst_compare (tree t1, tree t2)
|
{
|
{
|
if (tree_int_cst_lt (t1, t2))
|
if (tree_int_cst_lt (t1, t2))
|
return -1;
|
return -1;
|
else if (tree_int_cst_lt (t2, t1))
|
else if (tree_int_cst_lt (t2, t1))
|
return 1;
|
return 1;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
|
/* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
|
the host. If POS is zero, the value can be represented in a single
|
the host. If POS is zero, the value can be represented in a single
|
HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can
|
HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can
|
be represented in a single unsigned HOST_WIDE_INT. */
|
be represented in a single unsigned HOST_WIDE_INT. */
|
|
|
int
|
int
|
host_integerp (tree t, int pos)
|
host_integerp (tree t, int pos)
|
{
|
{
|
return (TREE_CODE (t) == INTEGER_CST
|
return (TREE_CODE (t) == INTEGER_CST
|
&& ((TREE_INT_CST_HIGH (t) == 0
|
&& ((TREE_INT_CST_HIGH (t) == 0
|
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
|
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
|
|| (! pos && TREE_INT_CST_HIGH (t) == -1
|
|| (! pos && TREE_INT_CST_HIGH (t) == -1
|
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
|
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
|
&& (!TYPE_UNSIGNED (TREE_TYPE (t))
|
&& (!TYPE_UNSIGNED (TREE_TYPE (t))
|
|| TYPE_IS_SIZETYPE (TREE_TYPE (t))))
|
|| TYPE_IS_SIZETYPE (TREE_TYPE (t))))
|
|| (pos && TREE_INT_CST_HIGH (t) == 0)));
|
|| (pos && TREE_INT_CST_HIGH (t) == 0)));
|
}
|
}
|
|
|
/* Return the HOST_WIDE_INT least significant bits of T if it is an
|
/* Return the HOST_WIDE_INT least significant bits of T if it is an
|
INTEGER_CST and there is no overflow. POS is nonzero if the result must
|
INTEGER_CST and there is no overflow. POS is nonzero if the result must
|
be non-negative. We must be able to satisfy the above conditions. */
|
be non-negative. We must be able to satisfy the above conditions. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
tree_low_cst (tree t, int pos)
|
tree_low_cst (tree t, int pos)
|
{
|
{
|
gcc_assert (host_integerp (t, pos));
|
gcc_assert (host_integerp (t, pos));
|
return TREE_INT_CST_LOW (t);
|
return TREE_INT_CST_LOW (t);
|
}
|
}
|
|
|
/* Return the most significant bit of the integer constant T. */
|
/* Return the most significant bit of the integer constant T. */
|
|
|
int
|
int
|
tree_int_cst_msb (tree t)
|
tree_int_cst_msb (tree t)
|
{
|
{
|
int prec;
|
int prec;
|
HOST_WIDE_INT h;
|
HOST_WIDE_INT h;
|
unsigned HOST_WIDE_INT l;
|
unsigned HOST_WIDE_INT l;
|
|
|
/* Note that using TYPE_PRECISION here is wrong. We care about the
|
/* Note that using TYPE_PRECISION here is wrong. We care about the
|
actual bits, not the (arbitrary) range of the type. */
|
actual bits, not the (arbitrary) range of the type. */
|
prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
|
prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
|
rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
|
rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
|
2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
|
2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
|
return (l & 1) == 1;
|
return (l & 1) == 1;
|
}
|
}
|
|
|
/* Return an indication of the sign of the integer constant T.
|
/* Return an indication of the sign of the integer constant T.
|
The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
|
The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
|
Note that -1 will never be returned if T's type is unsigned. */
|
Note that -1 will never be returned if T's type is unsigned. */
|
|
|
int
|
int
|
tree_int_cst_sgn (tree t)
|
tree_int_cst_sgn (tree t)
|
{
|
{
|
if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
|
if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
|
return 0;
|
return 0;
|
else if (TYPE_UNSIGNED (TREE_TYPE (t)))
|
else if (TYPE_UNSIGNED (TREE_TYPE (t)))
|
return 1;
|
return 1;
|
else if (TREE_INT_CST_HIGH (t) < 0)
|
else if (TREE_INT_CST_HIGH (t) < 0)
|
return -1;
|
return -1;
|
else
|
else
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Compare two constructor-element-type constants. Return 1 if the lists
|
/* Compare two constructor-element-type constants. Return 1 if the lists
|
are known to be equal; otherwise return 0. */
|
are known to be equal; otherwise return 0. */
|
|
|
int
|
int
|
simple_cst_list_equal (tree l1, tree l2)
|
simple_cst_list_equal (tree l1, tree l2)
|
{
|
{
|
while (l1 != NULL_TREE && l2 != NULL_TREE)
|
while (l1 != NULL_TREE && l2 != NULL_TREE)
|
{
|
{
|
if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
|
if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
|
return 0;
|
return 0;
|
|
|
l1 = TREE_CHAIN (l1);
|
l1 = TREE_CHAIN (l1);
|
l2 = TREE_CHAIN (l2);
|
l2 = TREE_CHAIN (l2);
|
}
|
}
|
|
|
return l1 == l2;
|
return l1 == l2;
|
}
|
}
|
|
|
/* Return truthvalue of whether T1 is the same tree structure as T2.
|
/* Return truthvalue of whether T1 is the same tree structure as T2.
|
Return 1 if they are the same.
|
Return 1 if they are the same.
|
Return 0 if they are understandably different.
|
Return 0 if they are understandably different.
|
Return -1 if either contains tree structure not understood by
|
Return -1 if either contains tree structure not understood by
|
this function. */
|
this function. */
|
|
|
int
|
int
|
simple_cst_equal (tree t1, tree t2)
|
simple_cst_equal (tree t1, tree t2)
|
{
|
{
|
enum tree_code code1, code2;
|
enum tree_code code1, code2;
|
int cmp;
|
int cmp;
|
int i;
|
int i;
|
|
|
if (t1 == t2)
|
if (t1 == t2)
|
return 1;
|
return 1;
|
if (t1 == 0 || t2 == 0)
|
if (t1 == 0 || t2 == 0)
|
return 0;
|
return 0;
|
|
|
code1 = TREE_CODE (t1);
|
code1 = TREE_CODE (t1);
|
code2 = TREE_CODE (t2);
|
code2 = TREE_CODE (t2);
|
|
|
if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
|
if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
|
{
|
{
|
if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
|
if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
|
|| code2 == NON_LVALUE_EXPR)
|
|| code2 == NON_LVALUE_EXPR)
|
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
else
|
else
|
return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
|
return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
|
}
|
}
|
|
|
else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
|
else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
|
|| code2 == NON_LVALUE_EXPR)
|
|| code2 == NON_LVALUE_EXPR)
|
return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
|
return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
|
|
|
if (code1 != code2)
|
if (code1 != code2)
|
return 0;
|
return 0;
|
|
|
switch (code1)
|
switch (code1)
|
{
|
{
|
case INTEGER_CST:
|
case INTEGER_CST:
|
return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
|
return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
|
&& TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
|
&& TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
|
|
|
case REAL_CST:
|
case REAL_CST:
|
return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
|
return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
|
|
|
case STRING_CST:
|
case STRING_CST:
|
return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
|
return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
|
&& ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
|
&& ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
|
TREE_STRING_LENGTH (t1)));
|
TREE_STRING_LENGTH (t1)));
|
|
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
{
|
{
|
unsigned HOST_WIDE_INT idx;
|
unsigned HOST_WIDE_INT idx;
|
VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
|
VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
|
VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
|
VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
|
|
|
if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
|
if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
|
return false;
|
return false;
|
|
|
for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
|
for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
|
/* ??? Should we handle also fields here? */
|
/* ??? Should we handle also fields here? */
|
if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
|
if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
|
VEC_index (constructor_elt, v2, idx)->value))
|
VEC_index (constructor_elt, v2, idx)->value))
|
return false;
|
return false;
|
return true;
|
return true;
|
}
|
}
|
|
|
case SAVE_EXPR:
|
case SAVE_EXPR:
|
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
|
|
case CALL_EXPR:
|
case CALL_EXPR:
|
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
if (cmp <= 0)
|
if (cmp <= 0)
|
return cmp;
|
return cmp;
|
return
|
return
|
simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
|
simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
|
|
|
case TARGET_EXPR:
|
case TARGET_EXPR:
|
/* Special case: if either target is an unallocated VAR_DECL,
|
/* Special case: if either target is an unallocated VAR_DECL,
|
it means that it's going to be unified with whatever the
|
it means that it's going to be unified with whatever the
|
TARGET_EXPR is really supposed to initialize, so treat it
|
TARGET_EXPR is really supposed to initialize, so treat it
|
as being equivalent to anything. */
|
as being equivalent to anything. */
|
if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
|
if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
|
&& DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
|
&& DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
|
&& !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
|
&& !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
|
|| (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
|
|| (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
|
&& DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
|
&& DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
|
&& !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
|
&& !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
|
cmp = 1;
|
cmp = 1;
|
else
|
else
|
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
|
|
if (cmp <= 0)
|
if (cmp <= 0)
|
return cmp;
|
return cmp;
|
|
|
return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
|
return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
|
|
|
case WITH_CLEANUP_EXPR:
|
case WITH_CLEANUP_EXPR:
|
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
if (cmp <= 0)
|
if (cmp <= 0)
|
return cmp;
|
return cmp;
|
|
|
return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
|
return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
|
|
|
case COMPONENT_REF:
|
case COMPONENT_REF:
|
if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
|
if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
|
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
|
|
|
return 0;
|
return 0;
|
|
|
case VAR_DECL:
|
case VAR_DECL:
|
case PARM_DECL:
|
case PARM_DECL:
|
case CONST_DECL:
|
case CONST_DECL:
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
return 0;
|
return 0;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* This general rule works for most tree codes. All exceptions should be
|
/* This general rule works for most tree codes. All exceptions should be
|
handled above. If this is a language-specific tree code, we can't
|
handled above. If this is a language-specific tree code, we can't
|
trust what might be in the operand, so say we don't know
|
trust what might be in the operand, so say we don't know
|
the situation. */
|
the situation. */
|
if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
|
if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
|
return -1;
|
return -1;
|
|
|
switch (TREE_CODE_CLASS (code1))
|
switch (TREE_CODE_CLASS (code1))
|
{
|
{
|
case tcc_unary:
|
case tcc_unary:
|
case tcc_binary:
|
case tcc_binary:
|
case tcc_comparison:
|
case tcc_comparison:
|
case tcc_expression:
|
case tcc_expression:
|
case tcc_reference:
|
case tcc_reference:
|
case tcc_statement:
|
case tcc_statement:
|
cmp = 1;
|
cmp = 1;
|
for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
|
for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
|
{
|
{
|
cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
|
cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
|
if (cmp <= 0)
|
if (cmp <= 0)
|
return cmp;
|
return cmp;
|
}
|
}
|
|
|
return cmp;
|
return cmp;
|
|
|
default:
|
default:
|
return -1;
|
return -1;
|
}
|
}
|
}
|
}
|
|
|
/* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
|
/* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
|
Return -1, 0, or 1 if the value of T is less than, equal to, or greater
|
Return -1, 0, or 1 if the value of T is less than, equal to, or greater
|
than U, respectively. */
|
than U, respectively. */
|
|
|
int
|
int
|
compare_tree_int (tree t, unsigned HOST_WIDE_INT u)
|
compare_tree_int (tree t, unsigned HOST_WIDE_INT u)
|
{
|
{
|
if (tree_int_cst_sgn (t) < 0)
|
if (tree_int_cst_sgn (t) < 0)
|
return -1;
|
return -1;
|
else if (TREE_INT_CST_HIGH (t) != 0)
|
else if (TREE_INT_CST_HIGH (t) != 0)
|
return 1;
|
return 1;
|
else if (TREE_INT_CST_LOW (t) == u)
|
else if (TREE_INT_CST_LOW (t) == u)
|
return 0;
|
return 0;
|
else if (TREE_INT_CST_LOW (t) < u)
|
else if (TREE_INT_CST_LOW (t) < u)
|
return -1;
|
return -1;
|
else
|
else
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Return true if CODE represents an associative tree code. Otherwise
|
/* Return true if CODE represents an associative tree code. Otherwise
|
return false. */
|
return false. */
|
bool
|
bool
|
associative_tree_code (enum tree_code code)
|
associative_tree_code (enum tree_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case BIT_IOR_EXPR:
|
case BIT_IOR_EXPR:
|
case BIT_AND_EXPR:
|
case BIT_AND_EXPR:
|
case BIT_XOR_EXPR:
|
case BIT_XOR_EXPR:
|
case PLUS_EXPR:
|
case PLUS_EXPR:
|
case MULT_EXPR:
|
case MULT_EXPR:
|
case MIN_EXPR:
|
case MIN_EXPR:
|
case MAX_EXPR:
|
case MAX_EXPR:
|
return true;
|
return true;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Return true if CODE represents a commutative tree code. Otherwise
|
/* Return true if CODE represents a commutative tree code. Otherwise
|
return false. */
|
return false. */
|
bool
|
bool
|
commutative_tree_code (enum tree_code code)
|
commutative_tree_code (enum tree_code code)
|
{
|
{
|
switch (code)
|
switch (code)
|
{
|
{
|
case PLUS_EXPR:
|
case PLUS_EXPR:
|
case MULT_EXPR:
|
case MULT_EXPR:
|
case MIN_EXPR:
|
case MIN_EXPR:
|
case MAX_EXPR:
|
case MAX_EXPR:
|
case BIT_IOR_EXPR:
|
case BIT_IOR_EXPR:
|
case BIT_XOR_EXPR:
|
case BIT_XOR_EXPR:
|
case BIT_AND_EXPR:
|
case BIT_AND_EXPR:
|
case NE_EXPR:
|
case NE_EXPR:
|
case EQ_EXPR:
|
case EQ_EXPR:
|
case UNORDERED_EXPR:
|
case UNORDERED_EXPR:
|
case ORDERED_EXPR:
|
case ORDERED_EXPR:
|
case UNEQ_EXPR:
|
case UNEQ_EXPR:
|
case LTGT_EXPR:
|
case LTGT_EXPR:
|
case TRUTH_AND_EXPR:
|
case TRUTH_AND_EXPR:
|
case TRUTH_XOR_EXPR:
|
case TRUTH_XOR_EXPR:
|
case TRUTH_OR_EXPR:
|
case TRUTH_OR_EXPR:
|
return true;
|
return true;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
/* Generate a hash value for an expression. This can be used iteratively
|
/* Generate a hash value for an expression. This can be used iteratively
|
by passing a previous result as the "val" argument.
|
by passing a previous result as the "val" argument.
|
|
|
This function is intended to produce the same hash for expressions which
|
This function is intended to produce the same hash for expressions which
|
would compare equal using operand_equal_p. */
|
would compare equal using operand_equal_p. */
|
|
|
hashval_t
|
hashval_t
|
iterative_hash_expr (tree t, hashval_t val)
|
iterative_hash_expr (tree t, hashval_t val)
|
{
|
{
|
int i;
|
int i;
|
enum tree_code code;
|
enum tree_code code;
|
char class;
|
char class;
|
|
|
if (t == NULL_TREE)
|
if (t == NULL_TREE)
|
return iterative_hash_pointer (t, val);
|
return iterative_hash_pointer (t, val);
|
|
|
code = TREE_CODE (t);
|
code = TREE_CODE (t);
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
/* Alas, constants aren't shared, so we can't rely on pointer
|
/* Alas, constants aren't shared, so we can't rely on pointer
|
identity. */
|
identity. */
|
case INTEGER_CST:
|
case INTEGER_CST:
|
val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
|
val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
|
return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
|
return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
|
case REAL_CST:
|
case REAL_CST:
|
{
|
{
|
unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
|
unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
|
|
|
return iterative_hash_hashval_t (val2, val);
|
return iterative_hash_hashval_t (val2, val);
|
}
|
}
|
case STRING_CST:
|
case STRING_CST:
|
return iterative_hash (TREE_STRING_POINTER (t),
|
return iterative_hash (TREE_STRING_POINTER (t),
|
TREE_STRING_LENGTH (t), val);
|
TREE_STRING_LENGTH (t), val);
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
val = iterative_hash_expr (TREE_REALPART (t), val);
|
val = iterative_hash_expr (TREE_REALPART (t), val);
|
return iterative_hash_expr (TREE_IMAGPART (t), val);
|
return iterative_hash_expr (TREE_IMAGPART (t), val);
|
case VECTOR_CST:
|
case VECTOR_CST:
|
return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
|
return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
|
|
|
case SSA_NAME:
|
case SSA_NAME:
|
case VALUE_HANDLE:
|
case VALUE_HANDLE:
|
/* we can just compare by pointer. */
|
/* we can just compare by pointer. */
|
return iterative_hash_pointer (t, val);
|
return iterative_hash_pointer (t, val);
|
|
|
case TREE_LIST:
|
case TREE_LIST:
|
/* A list of expressions, for a CALL_EXPR or as the elements of a
|
/* A list of expressions, for a CALL_EXPR or as the elements of a
|
VECTOR_CST. */
|
VECTOR_CST. */
|
for (; t; t = TREE_CHAIN (t))
|
for (; t; t = TREE_CHAIN (t))
|
val = iterative_hash_expr (TREE_VALUE (t), val);
|
val = iterative_hash_expr (TREE_VALUE (t), val);
|
return val;
|
return val;
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
{
|
{
|
unsigned HOST_WIDE_INT idx;
|
unsigned HOST_WIDE_INT idx;
|
tree field, value;
|
tree field, value;
|
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
|
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
|
{
|
{
|
val = iterative_hash_expr (field, val);
|
val = iterative_hash_expr (field, val);
|
val = iterative_hash_expr (value, val);
|
val = iterative_hash_expr (value, val);
|
}
|
}
|
return val;
|
return val;
|
}
|
}
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
/* When referring to a built-in FUNCTION_DECL, use the
|
/* When referring to a built-in FUNCTION_DECL, use the
|
__builtin__ form. Otherwise nodes that compare equal
|
__builtin__ form. Otherwise nodes that compare equal
|
according to operand_equal_p might get different
|
according to operand_equal_p might get different
|
hash codes. */
|
hash codes. */
|
if (DECL_BUILT_IN (t))
|
if (DECL_BUILT_IN (t))
|
{
|
{
|
val = iterative_hash_pointer (built_in_decls[DECL_FUNCTION_CODE (t)],
|
val = iterative_hash_pointer (built_in_decls[DECL_FUNCTION_CODE (t)],
|
val);
|
val);
|
return val;
|
return val;
|
}
|
}
|
/* else FALL THROUGH */
|
/* else FALL THROUGH */
|
default:
|
default:
|
class = TREE_CODE_CLASS (code);
|
class = TREE_CODE_CLASS (code);
|
|
|
if (class == tcc_declaration)
|
if (class == tcc_declaration)
|
{
|
{
|
/* DECL's have a unique ID */
|
/* DECL's have a unique ID */
|
val = iterative_hash_host_wide_int (DECL_UID (t), val);
|
val = iterative_hash_host_wide_int (DECL_UID (t), val);
|
}
|
}
|
else
|
else
|
{
|
{
|
gcc_assert (IS_EXPR_CODE_CLASS (class));
|
gcc_assert (IS_EXPR_CODE_CLASS (class));
|
|
|
val = iterative_hash_object (code, val);
|
val = iterative_hash_object (code, val);
|
|
|
/* Don't hash the type, that can lead to having nodes which
|
/* Don't hash the type, that can lead to having nodes which
|
compare equal according to operand_equal_p, but which
|
compare equal according to operand_equal_p, but which
|
have different hash codes. */
|
have different hash codes. */
|
if (code == NOP_EXPR
|
if (code == NOP_EXPR
|
|| code == CONVERT_EXPR
|
|| code == CONVERT_EXPR
|
|| code == NON_LVALUE_EXPR)
|
|| code == NON_LVALUE_EXPR)
|
{
|
{
|
/* Make sure to include signness in the hash computation. */
|
/* Make sure to include signness in the hash computation. */
|
val += TYPE_UNSIGNED (TREE_TYPE (t));
|
val += TYPE_UNSIGNED (TREE_TYPE (t));
|
val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
|
val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
|
}
|
}
|
|
|
else if (commutative_tree_code (code))
|
else if (commutative_tree_code (code))
|
{
|
{
|
/* It's a commutative expression. We want to hash it the same
|
/* It's a commutative expression. We want to hash it the same
|
however it appears. We do this by first hashing both operands
|
however it appears. We do this by first hashing both operands
|
and then rehashing based on the order of their independent
|
and then rehashing based on the order of their independent
|
hashes. */
|
hashes. */
|
hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
|
hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
|
hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
|
hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
|
hashval_t t;
|
hashval_t t;
|
|
|
if (one > two)
|
if (one > two)
|
t = one, one = two, two = t;
|
t = one, one = two, two = t;
|
|
|
val = iterative_hash_hashval_t (one, val);
|
val = iterative_hash_hashval_t (one, val);
|
val = iterative_hash_hashval_t (two, val);
|
val = iterative_hash_hashval_t (two, val);
|
}
|
}
|
else
|
else
|
for (i = TREE_CODE_LENGTH (code) - 1; i >= 0; --i)
|
for (i = TREE_CODE_LENGTH (code) - 1; i >= 0; --i)
|
val = iterative_hash_expr (TREE_OPERAND (t, i), val);
|
val = iterative_hash_expr (TREE_OPERAND (t, i), val);
|
}
|
}
|
return val;
|
return val;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
/* Constructors for pointer, array and function types.
|
/* Constructors for pointer, array and function types.
|
(RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
|
(RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
|
constructed by language-dependent code, not here.) */
|
constructed by language-dependent code, not here.) */
|
|
|
/* Construct, lay out and return the type of pointers to TO_TYPE with
|
/* Construct, lay out and return the type of pointers to TO_TYPE with
|
mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
|
mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can
|
reference all of memory. If such a type has already been
|
reference all of memory. If such a type has already been
|
constructed, reuse it. */
|
constructed, reuse it. */
|
|
|
tree
|
tree
|
build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
|
build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
|
bool can_alias_all)
|
bool can_alias_all)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
if (to_type == error_mark_node)
|
if (to_type == error_mark_node)
|
return error_mark_node;
|
return error_mark_node;
|
|
|
/* In some cases, languages will have things that aren't a POINTER_TYPE
|
/* In some cases, languages will have things that aren't a POINTER_TYPE
|
(such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
|
(such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
|
In that case, return that type without regard to the rest of our
|
In that case, return that type without regard to the rest of our
|
operands.
|
operands.
|
|
|
??? This is a kludge, but consistent with the way this function has
|
??? This is a kludge, but consistent with the way this function has
|
always operated and there doesn't seem to be a good way to avoid this
|
always operated and there doesn't seem to be a good way to avoid this
|
at the moment. */
|
at the moment. */
|
if (TYPE_POINTER_TO (to_type) != 0
|
if (TYPE_POINTER_TO (to_type) != 0
|
&& TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
|
&& TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
|
return TYPE_POINTER_TO (to_type);
|
return TYPE_POINTER_TO (to_type);
|
|
|
/* First, if we already have a type for pointers to TO_TYPE and it's
|
/* First, if we already have a type for pointers to TO_TYPE and it's
|
the proper mode, use it. */
|
the proper mode, use it. */
|
for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
|
for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
|
if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
|
if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
|
return t;
|
return t;
|
|
|
t = make_node (POINTER_TYPE);
|
t = make_node (POINTER_TYPE);
|
|
|
TREE_TYPE (t) = to_type;
|
TREE_TYPE (t) = to_type;
|
TYPE_MODE (t) = mode;
|
TYPE_MODE (t) = mode;
|
TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
|
TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
|
TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
|
TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
|
TYPE_POINTER_TO (to_type) = t;
|
TYPE_POINTER_TO (to_type) = t;
|
|
|
/* Lay out the type. This function has many callers that are concerned
|
/* Lay out the type. This function has many callers that are concerned
|
with expression-construction, and this simplifies them all. */
|
with expression-construction, and this simplifies them all. */
|
layout_type (t);
|
layout_type (t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* By default build pointers in ptr_mode. */
|
/* By default build pointers in ptr_mode. */
|
|
|
tree
|
tree
|
build_pointer_type (tree to_type)
|
build_pointer_type (tree to_type)
|
{
|
{
|
return build_pointer_type_for_mode (to_type, ptr_mode, false);
|
return build_pointer_type_for_mode (to_type, ptr_mode, false);
|
}
|
}
|
|
|
/* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
|
/* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
|
|
|
tree
|
tree
|
build_reference_type_for_mode (tree to_type, enum machine_mode mode,
|
build_reference_type_for_mode (tree to_type, enum machine_mode mode,
|
bool can_alias_all)
|
bool can_alias_all)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* In some cases, languages will have things that aren't a REFERENCE_TYPE
|
/* In some cases, languages will have things that aren't a REFERENCE_TYPE
|
(such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
|
(such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
|
In that case, return that type without regard to the rest of our
|
In that case, return that type without regard to the rest of our
|
operands.
|
operands.
|
|
|
??? This is a kludge, but consistent with the way this function has
|
??? This is a kludge, but consistent with the way this function has
|
always operated and there doesn't seem to be a good way to avoid this
|
always operated and there doesn't seem to be a good way to avoid this
|
at the moment. */
|
at the moment. */
|
if (TYPE_REFERENCE_TO (to_type) != 0
|
if (TYPE_REFERENCE_TO (to_type) != 0
|
&& TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
|
&& TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
|
return TYPE_REFERENCE_TO (to_type);
|
return TYPE_REFERENCE_TO (to_type);
|
|
|
/* First, if we already have a type for pointers to TO_TYPE and it's
|
/* First, if we already have a type for pointers to TO_TYPE and it's
|
the proper mode, use it. */
|
the proper mode, use it. */
|
for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
|
for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
|
if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
|
if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
|
return t;
|
return t;
|
|
|
t = make_node (REFERENCE_TYPE);
|
t = make_node (REFERENCE_TYPE);
|
|
|
TREE_TYPE (t) = to_type;
|
TREE_TYPE (t) = to_type;
|
TYPE_MODE (t) = mode;
|
TYPE_MODE (t) = mode;
|
TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
|
TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
|
TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
|
TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
|
TYPE_REFERENCE_TO (to_type) = t;
|
TYPE_REFERENCE_TO (to_type) = t;
|
|
|
layout_type (t);
|
layout_type (t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Build the node for the type of references-to-TO_TYPE by default
|
/* Build the node for the type of references-to-TO_TYPE by default
|
in ptr_mode. */
|
in ptr_mode. */
|
|
|
tree
|
tree
|
build_reference_type (tree to_type)
|
build_reference_type (tree to_type)
|
{
|
{
|
return build_reference_type_for_mode (to_type, ptr_mode, false);
|
return build_reference_type_for_mode (to_type, ptr_mode, false);
|
}
|
}
|
|
|
/* Build a type that is compatible with t but has no cv quals anywhere
|
/* Build a type that is compatible with t but has no cv quals anywhere
|
in its type, thus
|
in its type, thus
|
|
|
const char *const *const * -> char ***. */
|
const char *const *const * -> char ***. */
|
|
|
tree
|
tree
|
build_type_no_quals (tree t)
|
build_type_no_quals (tree t)
|
{
|
{
|
switch (TREE_CODE (t))
|
switch (TREE_CODE (t))
|
{
|
{
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
|
return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
|
TYPE_MODE (t),
|
TYPE_MODE (t),
|
TYPE_REF_CAN_ALIAS_ALL (t));
|
TYPE_REF_CAN_ALIAS_ALL (t));
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
return
|
return
|
build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
|
build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
|
TYPE_MODE (t),
|
TYPE_MODE (t),
|
TYPE_REF_CAN_ALIAS_ALL (t));
|
TYPE_REF_CAN_ALIAS_ALL (t));
|
default:
|
default:
|
return TYPE_MAIN_VARIANT (t);
|
return TYPE_MAIN_VARIANT (t);
|
}
|
}
|
}
|
}
|
|
|
/* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
|
/* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
|
MAXVAL should be the maximum value in the domain
|
MAXVAL should be the maximum value in the domain
|
(one less than the length of the array).
|
(one less than the length of the array).
|
|
|
The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
|
The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
|
We don't enforce this limit, that is up to caller (e.g. language front end).
|
We don't enforce this limit, that is up to caller (e.g. language front end).
|
The limit exists because the result is a signed type and we don't handle
|
The limit exists because the result is a signed type and we don't handle
|
sizes that use more than one HOST_WIDE_INT. */
|
sizes that use more than one HOST_WIDE_INT. */
|
|
|
tree
|
tree
|
build_index_type (tree maxval)
|
build_index_type (tree maxval)
|
{
|
{
|
tree itype = make_node (INTEGER_TYPE);
|
tree itype = make_node (INTEGER_TYPE);
|
|
|
TREE_TYPE (itype) = sizetype;
|
TREE_TYPE (itype) = sizetype;
|
TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
|
TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
|
TYPE_MIN_VALUE (itype) = size_zero_node;
|
TYPE_MIN_VALUE (itype) = size_zero_node;
|
TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
|
TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
|
TYPE_MODE (itype) = TYPE_MODE (sizetype);
|
TYPE_MODE (itype) = TYPE_MODE (sizetype);
|
TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
|
TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
|
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
|
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
|
TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
|
TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
|
TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
|
TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
|
|
|
if (host_integerp (maxval, 1))
|
if (host_integerp (maxval, 1))
|
return type_hash_canon (tree_low_cst (maxval, 1), itype);
|
return type_hash_canon (tree_low_cst (maxval, 1), itype);
|
else
|
else
|
return itype;
|
return itype;
|
}
|
}
|
|
|
/* Builds a signed or unsigned integer type of precision PRECISION.
|
/* Builds a signed or unsigned integer type of precision PRECISION.
|
Used for C bitfields whose precision does not match that of
|
Used for C bitfields whose precision does not match that of
|
built-in target types. */
|
built-in target types. */
|
tree
|
tree
|
build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
|
build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
|
int unsignedp)
|
int unsignedp)
|
{
|
{
|
tree itype = make_node (INTEGER_TYPE);
|
tree itype = make_node (INTEGER_TYPE);
|
|
|
TYPE_PRECISION (itype) = precision;
|
TYPE_PRECISION (itype) = precision;
|
|
|
if (unsignedp)
|
if (unsignedp)
|
fixup_unsigned_type (itype);
|
fixup_unsigned_type (itype);
|
else
|
else
|
fixup_signed_type (itype);
|
fixup_signed_type (itype);
|
|
|
if (host_integerp (TYPE_MAX_VALUE (itype), 1))
|
if (host_integerp (TYPE_MAX_VALUE (itype), 1))
|
return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
|
return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
|
|
|
return itype;
|
return itype;
|
}
|
}
|
|
|
/* Create a range of some discrete type TYPE (an INTEGER_TYPE,
|
/* Create a range of some discrete type TYPE (an INTEGER_TYPE,
|
ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
|
ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
|
high bound HIGHVAL. If TYPE is NULL, sizetype is used. */
|
high bound HIGHVAL. If TYPE is NULL, sizetype is used. */
|
|
|
tree
|
tree
|
build_range_type (tree type, tree lowval, tree highval)
|
build_range_type (tree type, tree lowval, tree highval)
|
{
|
{
|
tree itype = make_node (INTEGER_TYPE);
|
tree itype = make_node (INTEGER_TYPE);
|
|
|
TREE_TYPE (itype) = type;
|
TREE_TYPE (itype) = type;
|
if (type == NULL_TREE)
|
if (type == NULL_TREE)
|
type = sizetype;
|
type = sizetype;
|
|
|
TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
|
TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
|
TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
|
TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
|
|
|
TYPE_PRECISION (itype) = TYPE_PRECISION (type);
|
TYPE_PRECISION (itype) = TYPE_PRECISION (type);
|
TYPE_MODE (itype) = TYPE_MODE (type);
|
TYPE_MODE (itype) = TYPE_MODE (type);
|
TYPE_SIZE (itype) = TYPE_SIZE (type);
|
TYPE_SIZE (itype) = TYPE_SIZE (type);
|
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
|
TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
|
TYPE_ALIGN (itype) = TYPE_ALIGN (type);
|
TYPE_ALIGN (itype) = TYPE_ALIGN (type);
|
TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
|
TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
|
|
|
if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
|
if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
|
return type_hash_canon (tree_low_cst (highval, 0)
|
return type_hash_canon (tree_low_cst (highval, 0)
|
- tree_low_cst (lowval, 0),
|
- tree_low_cst (lowval, 0),
|
itype);
|
itype);
|
else
|
else
|
return itype;
|
return itype;
|
}
|
}
|
|
|
/* Just like build_index_type, but takes lowval and highval instead
|
/* Just like build_index_type, but takes lowval and highval instead
|
of just highval (maxval). */
|
of just highval (maxval). */
|
|
|
tree
|
tree
|
build_index_2_type (tree lowval, tree highval)
|
build_index_2_type (tree lowval, tree highval)
|
{
|
{
|
return build_range_type (sizetype, lowval, highval);
|
return build_range_type (sizetype, lowval, highval);
|
}
|
}
|
|
|
/* Construct, lay out and return the type of arrays of elements with ELT_TYPE
|
/* Construct, lay out and return the type of arrays of elements with ELT_TYPE
|
and number of elements specified by the range of values of INDEX_TYPE.
|
and number of elements specified by the range of values of INDEX_TYPE.
|
If such a type has already been constructed, reuse it. */
|
If such a type has already been constructed, reuse it. */
|
|
|
tree
|
tree
|
build_array_type (tree elt_type, tree index_type)
|
build_array_type (tree elt_type, tree index_type)
|
{
|
{
|
tree t;
|
tree t;
|
hashval_t hashcode = 0;
|
hashval_t hashcode = 0;
|
|
|
if (TREE_CODE (elt_type) == FUNCTION_TYPE)
|
if (TREE_CODE (elt_type) == FUNCTION_TYPE)
|
{
|
{
|
error ("arrays of functions are not meaningful");
|
error ("arrays of functions are not meaningful");
|
elt_type = integer_type_node;
|
elt_type = integer_type_node;
|
}
|
}
|
|
|
t = make_node (ARRAY_TYPE);
|
t = make_node (ARRAY_TYPE);
|
TREE_TYPE (t) = elt_type;
|
TREE_TYPE (t) = elt_type;
|
TYPE_DOMAIN (t) = index_type;
|
TYPE_DOMAIN (t) = index_type;
|
|
|
if (index_type == 0)
|
if (index_type == 0)
|
{
|
{
|
tree save = t;
|
tree save = t;
|
hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
|
t = type_hash_canon (hashcode, t);
|
t = type_hash_canon (hashcode, t);
|
if (save == t)
|
if (save == t)
|
layout_type (t);
|
layout_type (t);
|
return t;
|
return t;
|
}
|
}
|
|
|
hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
|
t = type_hash_canon (hashcode, t);
|
t = type_hash_canon (hashcode, t);
|
|
|
if (!COMPLETE_TYPE_P (t))
|
if (!COMPLETE_TYPE_P (t))
|
layout_type (t);
|
layout_type (t);
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Return the TYPE of the elements comprising
|
/* Return the TYPE of the elements comprising
|
the innermost dimension of ARRAY. */
|
the innermost dimension of ARRAY. */
|
|
|
tree
|
tree
|
get_inner_array_type (tree array)
|
get_inner_array_type (tree array)
|
{
|
{
|
tree type = TREE_TYPE (array);
|
tree type = TREE_TYPE (array);
|
|
|
while (TREE_CODE (type) == ARRAY_TYPE)
|
while (TREE_CODE (type) == ARRAY_TYPE)
|
type = TREE_TYPE (type);
|
type = TREE_TYPE (type);
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
/* Construct, lay out and return
|
/* Construct, lay out and return
|
the type of functions returning type VALUE_TYPE
|
the type of functions returning type VALUE_TYPE
|
given arguments of types ARG_TYPES.
|
given arguments of types ARG_TYPES.
|
ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
|
ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
|
are data type nodes for the arguments of the function.
|
are data type nodes for the arguments of the function.
|
If such a type has already been constructed, reuse it. */
|
If such a type has already been constructed, reuse it. */
|
|
|
tree
|
tree
|
build_function_type (tree value_type, tree arg_types)
|
build_function_type (tree value_type, tree arg_types)
|
{
|
{
|
tree t;
|
tree t;
|
hashval_t hashcode = 0;
|
hashval_t hashcode = 0;
|
|
|
if (TREE_CODE (value_type) == FUNCTION_TYPE)
|
if (TREE_CODE (value_type) == FUNCTION_TYPE)
|
{
|
{
|
error ("function return type cannot be function");
|
error ("function return type cannot be function");
|
value_type = integer_type_node;
|
value_type = integer_type_node;
|
}
|
}
|
|
|
/* Make a node of the sort we want. */
|
/* Make a node of the sort we want. */
|
t = make_node (FUNCTION_TYPE);
|
t = make_node (FUNCTION_TYPE);
|
TREE_TYPE (t) = value_type;
|
TREE_TYPE (t) = value_type;
|
TYPE_ARG_TYPES (t) = arg_types;
|
TYPE_ARG_TYPES (t) = arg_types;
|
|
|
/* If we already have such a type, use the old one. */
|
/* If we already have such a type, use the old one. */
|
hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
|
hashcode = type_hash_list (arg_types, hashcode);
|
hashcode = type_hash_list (arg_types, hashcode);
|
t = type_hash_canon (hashcode, t);
|
t = type_hash_canon (hashcode, t);
|
|
|
if (!COMPLETE_TYPE_P (t))
|
if (!COMPLETE_TYPE_P (t))
|
layout_type (t);
|
layout_type (t);
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Build a function type. The RETURN_TYPE is the type returned by the
|
/* Build a function type. The RETURN_TYPE is the type returned by the
|
function. If additional arguments are provided, they are
|
function. If additional arguments are provided, they are
|
additional argument types. The list of argument types must always
|
additional argument types. The list of argument types must always
|
be terminated by NULL_TREE. */
|
be terminated by NULL_TREE. */
|
|
|
tree
|
tree
|
build_function_type_list (tree return_type, ...)
|
build_function_type_list (tree return_type, ...)
|
{
|
{
|
tree t, args, last;
|
tree t, args, last;
|
va_list p;
|
va_list p;
|
|
|
va_start (p, return_type);
|
va_start (p, return_type);
|
|
|
t = va_arg (p, tree);
|
t = va_arg (p, tree);
|
for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree))
|
for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree))
|
args = tree_cons (NULL_TREE, t, args);
|
args = tree_cons (NULL_TREE, t, args);
|
|
|
if (args == NULL_TREE)
|
if (args == NULL_TREE)
|
args = void_list_node;
|
args = void_list_node;
|
else
|
else
|
{
|
{
|
last = args;
|
last = args;
|
args = nreverse (args);
|
args = nreverse (args);
|
TREE_CHAIN (last) = void_list_node;
|
TREE_CHAIN (last) = void_list_node;
|
}
|
}
|
args = build_function_type (return_type, args);
|
args = build_function_type (return_type, args);
|
|
|
va_end (p);
|
va_end (p);
|
return args;
|
return args;
|
}
|
}
|
|
|
/* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
|
/* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE)
|
and ARGTYPES (a TREE_LIST) are the return type and arguments types
|
and ARGTYPES (a TREE_LIST) are the return type and arguments types
|
for the method. An implicit additional parameter (of type
|
for the method. An implicit additional parameter (of type
|
pointer-to-BASETYPE) is added to the ARGTYPES. */
|
pointer-to-BASETYPE) is added to the ARGTYPES. */
|
|
|
tree
|
tree
|
build_method_type_directly (tree basetype,
|
build_method_type_directly (tree basetype,
|
tree rettype,
|
tree rettype,
|
tree argtypes)
|
tree argtypes)
|
{
|
{
|
tree t;
|
tree t;
|
tree ptype;
|
tree ptype;
|
int hashcode = 0;
|
int hashcode = 0;
|
|
|
/* Make a node of the sort we want. */
|
/* Make a node of the sort we want. */
|
t = make_node (METHOD_TYPE);
|
t = make_node (METHOD_TYPE);
|
|
|
TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
|
TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
|
TREE_TYPE (t) = rettype;
|
TREE_TYPE (t) = rettype;
|
ptype = build_pointer_type (basetype);
|
ptype = build_pointer_type (basetype);
|
|
|
/* The actual arglist for this function includes a "hidden" argument
|
/* The actual arglist for this function includes a "hidden" argument
|
which is "this". Put it into the list of argument types. */
|
which is "this". Put it into the list of argument types. */
|
argtypes = tree_cons (NULL_TREE, ptype, argtypes);
|
argtypes = tree_cons (NULL_TREE, ptype, argtypes);
|
TYPE_ARG_TYPES (t) = argtypes;
|
TYPE_ARG_TYPES (t) = argtypes;
|
|
|
/* If we already have such a type, use the old one. */
|
/* If we already have such a type, use the old one. */
|
hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
|
hashcode = type_hash_list (argtypes, hashcode);
|
hashcode = type_hash_list (argtypes, hashcode);
|
t = type_hash_canon (hashcode, t);
|
t = type_hash_canon (hashcode, t);
|
|
|
if (!COMPLETE_TYPE_P (t))
|
if (!COMPLETE_TYPE_P (t))
|
layout_type (t);
|
layout_type (t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Construct, lay out and return the type of methods belonging to class
|
/* Construct, lay out and return the type of methods belonging to class
|
BASETYPE and whose arguments and values are described by TYPE.
|
BASETYPE and whose arguments and values are described by TYPE.
|
If that type exists already, reuse it.
|
If that type exists already, reuse it.
|
TYPE must be a FUNCTION_TYPE node. */
|
TYPE must be a FUNCTION_TYPE node. */
|
|
|
tree
|
tree
|
build_method_type (tree basetype, tree type)
|
build_method_type (tree basetype, tree type)
|
{
|
{
|
gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
|
gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
|
|
|
return build_method_type_directly (basetype,
|
return build_method_type_directly (basetype,
|
TREE_TYPE (type),
|
TREE_TYPE (type),
|
TYPE_ARG_TYPES (type));
|
TYPE_ARG_TYPES (type));
|
}
|
}
|
|
|
/* Construct, lay out and return the type of offsets to a value
|
/* Construct, lay out and return the type of offsets to a value
|
of type TYPE, within an object of type BASETYPE.
|
of type TYPE, within an object of type BASETYPE.
|
If a suitable offset type exists already, reuse it. */
|
If a suitable offset type exists already, reuse it. */
|
|
|
tree
|
tree
|
build_offset_type (tree basetype, tree type)
|
build_offset_type (tree basetype, tree type)
|
{
|
{
|
tree t;
|
tree t;
|
hashval_t hashcode = 0;
|
hashval_t hashcode = 0;
|
|
|
/* Make a node of the sort we want. */
|
/* Make a node of the sort we want. */
|
t = make_node (OFFSET_TYPE);
|
t = make_node (OFFSET_TYPE);
|
|
|
TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
|
TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
|
TREE_TYPE (t) = type;
|
TREE_TYPE (t) = type;
|
|
|
/* If we already have such a type, use the old one. */
|
/* If we already have such a type, use the old one. */
|
hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
|
t = type_hash_canon (hashcode, t);
|
t = type_hash_canon (hashcode, t);
|
|
|
if (!COMPLETE_TYPE_P (t))
|
if (!COMPLETE_TYPE_P (t))
|
layout_type (t);
|
layout_type (t);
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Create a complex type whose components are COMPONENT_TYPE. */
|
/* Create a complex type whose components are COMPONENT_TYPE. */
|
|
|
tree
|
tree
|
build_complex_type (tree component_type)
|
build_complex_type (tree component_type)
|
{
|
{
|
tree t;
|
tree t;
|
hashval_t hashcode;
|
hashval_t hashcode;
|
|
|
/* Make a node of the sort we want. */
|
/* Make a node of the sort we want. */
|
t = make_node (COMPLEX_TYPE);
|
t = make_node (COMPLEX_TYPE);
|
|
|
TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
|
TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
|
|
|
/* If we already have such a type, use the old one. */
|
/* If we already have such a type, use the old one. */
|
hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
|
hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
|
t = type_hash_canon (hashcode, t);
|
t = type_hash_canon (hashcode, t);
|
|
|
if (!COMPLETE_TYPE_P (t))
|
if (!COMPLETE_TYPE_P (t))
|
layout_type (t);
|
layout_type (t);
|
|
|
/* If we are writing Dwarf2 output we need to create a name,
|
/* If we are writing Dwarf2 output we need to create a name,
|
since complex is a fundamental type. */
|
since complex is a fundamental type. */
|
if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
|
if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
|
&& ! TYPE_NAME (t))
|
&& ! TYPE_NAME (t))
|
{
|
{
|
const char *name;
|
const char *name;
|
if (component_type == char_type_node)
|
if (component_type == char_type_node)
|
name = "complex char";
|
name = "complex char";
|
else if (component_type == signed_char_type_node)
|
else if (component_type == signed_char_type_node)
|
name = "complex signed char";
|
name = "complex signed char";
|
else if (component_type == unsigned_char_type_node)
|
else if (component_type == unsigned_char_type_node)
|
name = "complex unsigned char";
|
name = "complex unsigned char";
|
else if (component_type == short_integer_type_node)
|
else if (component_type == short_integer_type_node)
|
name = "complex short int";
|
name = "complex short int";
|
else if (component_type == short_unsigned_type_node)
|
else if (component_type == short_unsigned_type_node)
|
name = "complex short unsigned int";
|
name = "complex short unsigned int";
|
else if (component_type == integer_type_node)
|
else if (component_type == integer_type_node)
|
name = "complex int";
|
name = "complex int";
|
else if (component_type == unsigned_type_node)
|
else if (component_type == unsigned_type_node)
|
name = "complex unsigned int";
|
name = "complex unsigned int";
|
else if (component_type == long_integer_type_node)
|
else if (component_type == long_integer_type_node)
|
name = "complex long int";
|
name = "complex long int";
|
else if (component_type == long_unsigned_type_node)
|
else if (component_type == long_unsigned_type_node)
|
name = "complex long unsigned int";
|
name = "complex long unsigned int";
|
else if (component_type == long_long_integer_type_node)
|
else if (component_type == long_long_integer_type_node)
|
name = "complex long long int";
|
name = "complex long long int";
|
else if (component_type == long_long_unsigned_type_node)
|
else if (component_type == long_long_unsigned_type_node)
|
name = "complex long long unsigned int";
|
name = "complex long long unsigned int";
|
else
|
else
|
name = 0;
|
name = 0;
|
|
|
if (name != 0)
|
if (name != 0)
|
TYPE_NAME (t) = get_identifier (name);
|
TYPE_NAME (t) = get_identifier (name);
|
}
|
}
|
|
|
return build_qualified_type (t, TYPE_QUALS (component_type));
|
return build_qualified_type (t, TYPE_QUALS (component_type));
|
}
|
}
|
|
|
/* Return OP, stripped of any conversions to wider types as much as is safe.
|
/* Return OP, stripped of any conversions to wider types as much as is safe.
|
Converting the value back to OP's type makes a value equivalent to OP.
|
Converting the value back to OP's type makes a value equivalent to OP.
|
|
|
If FOR_TYPE is nonzero, we return a value which, if converted to
|
If FOR_TYPE is nonzero, we return a value which, if converted to
|
type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
|
type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
|
|
|
If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
|
If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
|
narrowest type that can hold the value, even if they don't exactly fit.
|
narrowest type that can hold the value, even if they don't exactly fit.
|
Otherwise, bit-field references are changed to a narrower type
|
Otherwise, bit-field references are changed to a narrower type
|
only if they can be fetched directly from memory in that type.
|
only if they can be fetched directly from memory in that type.
|
|
|
OP must have integer, real or enumeral type. Pointers are not allowed!
|
OP must have integer, real or enumeral type. Pointers are not allowed!
|
|
|
There are some cases where the obvious value we could return
|
There are some cases where the obvious value we could return
|
would regenerate to OP if converted to OP's type,
|
would regenerate to OP if converted to OP's type,
|
but would not extend like OP to wider types.
|
but would not extend like OP to wider types.
|
If FOR_TYPE indicates such extension is contemplated, we eschew such values.
|
If FOR_TYPE indicates such extension is contemplated, we eschew such values.
|
For example, if OP is (unsigned short)(signed char)-1,
|
For example, if OP is (unsigned short)(signed char)-1,
|
we avoid returning (signed char)-1 if FOR_TYPE is int,
|
we avoid returning (signed char)-1 if FOR_TYPE is int,
|
even though extending that to an unsigned short would regenerate OP,
|
even though extending that to an unsigned short would regenerate OP,
|
since the result of extending (signed char)-1 to (int)
|
since the result of extending (signed char)-1 to (int)
|
is different from (int) OP. */
|
is different from (int) OP. */
|
|
|
tree
|
tree
|
get_unwidened (tree op, tree for_type)
|
get_unwidened (tree op, tree for_type)
|
{
|
{
|
/* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
|
/* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
|
tree type = TREE_TYPE (op);
|
tree type = TREE_TYPE (op);
|
unsigned final_prec
|
unsigned final_prec
|
= TYPE_PRECISION (for_type != 0 ? for_type : type);
|
= TYPE_PRECISION (for_type != 0 ? for_type : type);
|
int uns
|
int uns
|
= (for_type != 0 && for_type != type
|
= (for_type != 0 && for_type != type
|
&& final_prec > TYPE_PRECISION (type)
|
&& final_prec > TYPE_PRECISION (type)
|
&& TYPE_UNSIGNED (type));
|
&& TYPE_UNSIGNED (type));
|
tree win = op;
|
tree win = op;
|
|
|
while (TREE_CODE (op) == NOP_EXPR
|
while (TREE_CODE (op) == NOP_EXPR
|
|| TREE_CODE (op) == CONVERT_EXPR)
|
|| TREE_CODE (op) == CONVERT_EXPR)
|
{
|
{
|
int bitschange;
|
int bitschange;
|
|
|
/* TYPE_PRECISION on vector types has different meaning
|
/* TYPE_PRECISION on vector types has different meaning
|
(TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
|
(TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
|
so avoid them here. */
|
so avoid them here. */
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
|
if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
|
break;
|
break;
|
|
|
bitschange = TYPE_PRECISION (TREE_TYPE (op))
|
bitschange = TYPE_PRECISION (TREE_TYPE (op))
|
- TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
|
- TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
|
|
|
/* Truncations are many-one so cannot be removed.
|
/* Truncations are many-one so cannot be removed.
|
Unless we are later going to truncate down even farther. */
|
Unless we are later going to truncate down even farther. */
|
if (bitschange < 0
|
if (bitschange < 0
|
&& final_prec > TYPE_PRECISION (TREE_TYPE (op)))
|
&& final_prec > TYPE_PRECISION (TREE_TYPE (op)))
|
break;
|
break;
|
|
|
/* See what's inside this conversion. If we decide to strip it,
|
/* See what's inside this conversion. If we decide to strip it,
|
we will set WIN. */
|
we will set WIN. */
|
op = TREE_OPERAND (op, 0);
|
op = TREE_OPERAND (op, 0);
|
|
|
/* If we have not stripped any zero-extensions (uns is 0),
|
/* If we have not stripped any zero-extensions (uns is 0),
|
we can strip any kind of extension.
|
we can strip any kind of extension.
|
If we have previously stripped a zero-extension,
|
If we have previously stripped a zero-extension,
|
only zero-extensions can safely be stripped.
|
only zero-extensions can safely be stripped.
|
Any extension can be stripped if the bits it would produce
|
Any extension can be stripped if the bits it would produce
|
are all going to be discarded later by truncating to FOR_TYPE. */
|
are all going to be discarded later by truncating to FOR_TYPE. */
|
|
|
if (bitschange > 0)
|
if (bitschange > 0)
|
{
|
{
|
if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
|
if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
|
win = op;
|
win = op;
|
/* TYPE_UNSIGNED says whether this is a zero-extension.
|
/* TYPE_UNSIGNED says whether this is a zero-extension.
|
Let's avoid computing it if it does not affect WIN
|
Let's avoid computing it if it does not affect WIN
|
and if UNS will not be needed again. */
|
and if UNS will not be needed again. */
|
if ((uns
|
if ((uns
|
|| TREE_CODE (op) == NOP_EXPR
|
|| TREE_CODE (op) == NOP_EXPR
|
|| TREE_CODE (op) == CONVERT_EXPR)
|
|| TREE_CODE (op) == CONVERT_EXPR)
|
&& TYPE_UNSIGNED (TREE_TYPE (op)))
|
&& TYPE_UNSIGNED (TREE_TYPE (op)))
|
{
|
{
|
uns = 1;
|
uns = 1;
|
win = op;
|
win = op;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
if (TREE_CODE (op) == COMPONENT_REF
|
if (TREE_CODE (op) == COMPONENT_REF
|
/* Since type_for_size always gives an integer type. */
|
/* Since type_for_size always gives an integer type. */
|
&& TREE_CODE (type) != REAL_TYPE
|
&& TREE_CODE (type) != REAL_TYPE
|
/* Don't crash if field not laid out yet. */
|
/* Don't crash if field not laid out yet. */
|
&& DECL_SIZE (TREE_OPERAND (op, 1)) != 0
|
&& DECL_SIZE (TREE_OPERAND (op, 1)) != 0
|
&& host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
|
&& host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
|
{
|
{
|
unsigned int innerprec
|
unsigned int innerprec
|
= tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
|
= tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
|
int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
|
int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
|
|| TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
|
|| TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
|
type = lang_hooks.types.type_for_size (innerprec, unsignedp);
|
type = lang_hooks.types.type_for_size (innerprec, unsignedp);
|
|
|
/* We can get this structure field in the narrowest type it fits in.
|
/* We can get this structure field in the narrowest type it fits in.
|
If FOR_TYPE is 0, do this only for a field that matches the
|
If FOR_TYPE is 0, do this only for a field that matches the
|
narrower type exactly and is aligned for it
|
narrower type exactly and is aligned for it
|
The resulting extension to its nominal type (a fullword type)
|
The resulting extension to its nominal type (a fullword type)
|
must fit the same conditions as for other extensions. */
|
must fit the same conditions as for other extensions. */
|
|
|
if (type != 0
|
if (type != 0
|
&& INT_CST_LT_UNSIGNED (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (op)))
|
&& INT_CST_LT_UNSIGNED (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (op)))
|
&& (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
|
&& (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
|
&& (! uns || final_prec <= innerprec || unsignedp))
|
&& (! uns || final_prec <= innerprec || unsignedp))
|
{
|
{
|
win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
|
win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0),
|
TREE_OPERAND (op, 1), NULL_TREE);
|
TREE_OPERAND (op, 1), NULL_TREE);
|
TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
|
TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
|
TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
|
TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
|
}
|
}
|
}
|
}
|
|
|
return win;
|
return win;
|
}
|
}
|
|
|
/* Return OP or a simpler expression for a narrower value
|
/* Return OP or a simpler expression for a narrower value
|
which can be sign-extended or zero-extended to give back OP.
|
which can be sign-extended or zero-extended to give back OP.
|
Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
|
Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
|
or 0 if the value should be sign-extended. */
|
or 0 if the value should be sign-extended. */
|
|
|
tree
|
tree
|
get_narrower (tree op, int *unsignedp_ptr)
|
get_narrower (tree op, int *unsignedp_ptr)
|
{
|
{
|
int uns = 0;
|
int uns = 0;
|
int first = 1;
|
int first = 1;
|
tree win = op;
|
tree win = op;
|
bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
|
bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
|
|
|
while (TREE_CODE (op) == NOP_EXPR)
|
while (TREE_CODE (op) == NOP_EXPR)
|
{
|
{
|
int bitschange
|
int bitschange
|
= (TYPE_PRECISION (TREE_TYPE (op))
|
= (TYPE_PRECISION (TREE_TYPE (op))
|
- TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
|
- TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
|
|
|
/* Truncations are many-one so cannot be removed. */
|
/* Truncations are many-one so cannot be removed. */
|
if (bitschange < 0)
|
if (bitschange < 0)
|
break;
|
break;
|
|
|
/* See what's inside this conversion. If we decide to strip it,
|
/* See what's inside this conversion. If we decide to strip it,
|
we will set WIN. */
|
we will set WIN. */
|
|
|
if (bitschange > 0)
|
if (bitschange > 0)
|
{
|
{
|
op = TREE_OPERAND (op, 0);
|
op = TREE_OPERAND (op, 0);
|
/* An extension: the outermost one can be stripped,
|
/* An extension: the outermost one can be stripped,
|
but remember whether it is zero or sign extension. */
|
but remember whether it is zero or sign extension. */
|
if (first)
|
if (first)
|
uns = TYPE_UNSIGNED (TREE_TYPE (op));
|
uns = TYPE_UNSIGNED (TREE_TYPE (op));
|
/* Otherwise, if a sign extension has been stripped,
|
/* Otherwise, if a sign extension has been stripped,
|
only sign extensions can now be stripped;
|
only sign extensions can now be stripped;
|
if a zero extension has been stripped, only zero-extensions. */
|
if a zero extension has been stripped, only zero-extensions. */
|
else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
|
else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
|
break;
|
break;
|
first = 0;
|
first = 0;
|
}
|
}
|
else /* bitschange == 0 */
|
else /* bitschange == 0 */
|
{
|
{
|
/* A change in nominal type can always be stripped, but we must
|
/* A change in nominal type can always be stripped, but we must
|
preserve the unsignedness. */
|
preserve the unsignedness. */
|
if (first)
|
if (first)
|
uns = TYPE_UNSIGNED (TREE_TYPE (op));
|
uns = TYPE_UNSIGNED (TREE_TYPE (op));
|
first = 0;
|
first = 0;
|
op = TREE_OPERAND (op, 0);
|
op = TREE_OPERAND (op, 0);
|
/* Keep trying to narrow, but don't assign op to win if it
|
/* Keep trying to narrow, but don't assign op to win if it
|
would turn an integral type into something else. */
|
would turn an integral type into something else. */
|
if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
|
if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
|
continue;
|
continue;
|
}
|
}
|
|
|
win = op;
|
win = op;
|
}
|
}
|
|
|
if (TREE_CODE (op) == COMPONENT_REF
|
if (TREE_CODE (op) == COMPONENT_REF
|
/* Since type_for_size always gives an integer type. */
|
/* Since type_for_size always gives an integer type. */
|
&& TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
|
&& TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
|
/* Ensure field is laid out already. */
|
/* Ensure field is laid out already. */
|
&& DECL_SIZE (TREE_OPERAND (op, 1)) != 0
|
&& DECL_SIZE (TREE_OPERAND (op, 1)) != 0
|
&& host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
|
&& host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
|
{
|
{
|
unsigned HOST_WIDE_INT innerprec
|
unsigned HOST_WIDE_INT innerprec
|
= tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
|
= tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
|
int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
|
int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
|
|| TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
|
|| TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
|
tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
|
tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
|
|
|
/* We can get this structure field in a narrower type that fits it,
|
/* We can get this structure field in a narrower type that fits it,
|
but the resulting extension to its nominal type (a fullword type)
|
but the resulting extension to its nominal type (a fullword type)
|
must satisfy the same conditions as for other extensions.
|
must satisfy the same conditions as for other extensions.
|
|
|
Do this only for fields that are aligned (not bit-fields),
|
Do this only for fields that are aligned (not bit-fields),
|
because when bit-field insns will be used there is no
|
because when bit-field insns will be used there is no
|
advantage in doing this. */
|
advantage in doing this. */
|
|
|
if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
|
if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
|
&& ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
|
&& ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
|
&& (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
|
&& (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
|
&& type != 0)
|
&& type != 0)
|
{
|
{
|
if (first)
|
if (first)
|
uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
|
uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
|
win = fold_convert (type, op);
|
win = fold_convert (type, op);
|
}
|
}
|
}
|
}
|
|
|
*unsignedp_ptr = uns;
|
*unsignedp_ptr = uns;
|
return win;
|
return win;
|
}
|
}
|
|
|
/* Nonzero if integer constant C has a value that is permissible
|
/* Nonzero if integer constant C has a value that is permissible
|
for type TYPE (an INTEGER_TYPE). */
|
for type TYPE (an INTEGER_TYPE). */
|
|
|
int
|
int
|
int_fits_type_p (tree c, tree type)
|
int_fits_type_p (tree c, tree type)
|
{
|
{
|
tree type_low_bound = TYPE_MIN_VALUE (type);
|
tree type_low_bound = TYPE_MIN_VALUE (type);
|
tree type_high_bound = TYPE_MAX_VALUE (type);
|
tree type_high_bound = TYPE_MAX_VALUE (type);
|
bool ok_for_low_bound, ok_for_high_bound;
|
bool ok_for_low_bound, ok_for_high_bound;
|
tree tmp;
|
tree tmp;
|
|
|
/* If at least one bound of the type is a constant integer, we can check
|
/* If at least one bound of the type is a constant integer, we can check
|
ourselves and maybe make a decision. If no such decision is possible, but
|
ourselves and maybe make a decision. If no such decision is possible, but
|
this type is a subtype, try checking against that. Otherwise, use
|
this type is a subtype, try checking against that. Otherwise, use
|
force_fit_type, which checks against the precision.
|
force_fit_type, which checks against the precision.
|
|
|
Compute the status for each possibly constant bound, and return if we see
|
Compute the status for each possibly constant bound, and return if we see
|
one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
|
one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
|
for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
|
for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
|
for "constant known to fit". */
|
for "constant known to fit". */
|
|
|
/* Check if C >= type_low_bound. */
|
/* Check if C >= type_low_bound. */
|
if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
|
if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
|
{
|
{
|
if (tree_int_cst_lt (c, type_low_bound))
|
if (tree_int_cst_lt (c, type_low_bound))
|
return 0;
|
return 0;
|
ok_for_low_bound = true;
|
ok_for_low_bound = true;
|
}
|
}
|
else
|
else
|
ok_for_low_bound = false;
|
ok_for_low_bound = false;
|
|
|
/* Check if c <= type_high_bound. */
|
/* Check if c <= type_high_bound. */
|
if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
|
if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
|
{
|
{
|
if (tree_int_cst_lt (type_high_bound, c))
|
if (tree_int_cst_lt (type_high_bound, c))
|
return 0;
|
return 0;
|
ok_for_high_bound = true;
|
ok_for_high_bound = true;
|
}
|
}
|
else
|
else
|
ok_for_high_bound = false;
|
ok_for_high_bound = false;
|
|
|
/* If the constant fits both bounds, the result is known. */
|
/* If the constant fits both bounds, the result is known. */
|
if (ok_for_low_bound && ok_for_high_bound)
|
if (ok_for_low_bound && ok_for_high_bound)
|
return 1;
|
return 1;
|
|
|
/* Perform some generic filtering which may allow making a decision
|
/* Perform some generic filtering which may allow making a decision
|
even if the bounds are not constant. First, negative integers
|
even if the bounds are not constant. First, negative integers
|
never fit in unsigned types, */
|
never fit in unsigned types, */
|
if (TYPE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0)
|
if (TYPE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0)
|
return 0;
|
return 0;
|
|
|
/* Second, narrower types always fit in wider ones. */
|
/* Second, narrower types always fit in wider ones. */
|
if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
|
if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
|
return 1;
|
return 1;
|
|
|
/* Third, unsigned integers with top bit set never fit signed types. */
|
/* Third, unsigned integers with top bit set never fit signed types. */
|
if (! TYPE_UNSIGNED (type)
|
if (! TYPE_UNSIGNED (type)
|
&& TYPE_UNSIGNED (TREE_TYPE (c))
|
&& TYPE_UNSIGNED (TREE_TYPE (c))
|
&& tree_int_cst_msb (c))
|
&& tree_int_cst_msb (c))
|
return 0;
|
return 0;
|
|
|
/* If we haven't been able to decide at this point, there nothing more we
|
/* If we haven't been able to decide at this point, there nothing more we
|
can check ourselves here. Look at the base type if we have one and it
|
can check ourselves here. Look at the base type if we have one and it
|
has the same precision. */
|
has the same precision. */
|
if (TREE_CODE (type) == INTEGER_TYPE
|
if (TREE_CODE (type) == INTEGER_TYPE
|
&& TREE_TYPE (type) != 0
|
&& TREE_TYPE (type) != 0
|
&& TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
|
&& TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
|
return int_fits_type_p (c, TREE_TYPE (type));
|
return int_fits_type_p (c, TREE_TYPE (type));
|
|
|
/* Or to force_fit_type, if nothing else. */
|
/* Or to force_fit_type, if nothing else. */
|
tmp = copy_node (c);
|
tmp = copy_node (c);
|
TREE_TYPE (tmp) = type;
|
TREE_TYPE (tmp) = type;
|
tmp = force_fit_type (tmp, -1, false, false);
|
tmp = force_fit_type (tmp, -1, false, false);
|
return TREE_INT_CST_HIGH (tmp) == TREE_INT_CST_HIGH (c)
|
return TREE_INT_CST_HIGH (tmp) == TREE_INT_CST_HIGH (c)
|
&& TREE_INT_CST_LOW (tmp) == TREE_INT_CST_LOW (c);
|
&& TREE_INT_CST_LOW (tmp) == TREE_INT_CST_LOW (c);
|
}
|
}
|
|
|
/* Subprogram of following function. Called by walk_tree.
|
/* Subprogram of following function. Called by walk_tree.
|
|
|
Return *TP if it is an automatic variable or parameter of the
|
Return *TP if it is an automatic variable or parameter of the
|
function passed in as DATA. */
|
function passed in as DATA. */
|
|
|
static tree
|
static tree
|
find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
|
find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
|
{
|
{
|
tree fn = (tree) data;
|
tree fn = (tree) data;
|
|
|
if (TYPE_P (*tp))
|
if (TYPE_P (*tp))
|
*walk_subtrees = 0;
|
*walk_subtrees = 0;
|
|
|
else if (DECL_P (*tp)
|
else if (DECL_P (*tp)
|
&& lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
|
&& lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn))
|
return *tp;
|
return *tp;
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Returns true if T is, contains, or refers to a type with variable
|
/* Returns true if T is, contains, or refers to a type with variable
|
size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
|
size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
|
arguments, but not the return type. If FN is nonzero, only return
|
arguments, but not the return type. If FN is nonzero, only return
|
true if a modifier of the type or position of FN is a variable or
|
true if a modifier of the type or position of FN is a variable or
|
parameter inside FN.
|
parameter inside FN.
|
|
|
This concept is more general than that of C99 'variably modified types':
|
This concept is more general than that of C99 'variably modified types':
|
in C99, a struct type is never variably modified because a VLA may not
|
in C99, a struct type is never variably modified because a VLA may not
|
appear as a structure member. However, in GNU C code like:
|
appear as a structure member. However, in GNU C code like:
|
|
|
struct S { int i[f()]; };
|
struct S { int i[f()]; };
|
|
|
is valid, and other languages may define similar constructs. */
|
is valid, and other languages may define similar constructs. */
|
|
|
bool
|
bool
|
variably_modified_type_p (tree type, tree fn)
|
variably_modified_type_p (tree type, tree fn)
|
{
|
{
|
tree t;
|
tree t;
|
|
|
/* Test if T is either variable (if FN is zero) or an expression containing
|
/* Test if T is either variable (if FN is zero) or an expression containing
|
a variable in FN. */
|
a variable in FN. */
|
#define RETURN_TRUE_IF_VAR(T) \
|
#define RETURN_TRUE_IF_VAR(T) \
|
do { tree _t = (T); \
|
do { tree _t = (T); \
|
if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
|
if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \
|
&& (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
|
&& (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
|
return true; } while (0)
|
return true; } while (0)
|
|
|
if (type == error_mark_node)
|
if (type == error_mark_node)
|
return false;
|
return false;
|
|
|
/* If TYPE itself has variable size, it is variably modified. */
|
/* If TYPE itself has variable size, it is variably modified. */
|
RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
|
RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
|
RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
|
RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
|
|
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
case VECTOR_TYPE:
|
case VECTOR_TYPE:
|
if (variably_modified_type_p (TREE_TYPE (type), fn))
|
if (variably_modified_type_p (TREE_TYPE (type), fn))
|
return true;
|
return true;
|
break;
|
break;
|
|
|
case FUNCTION_TYPE:
|
case FUNCTION_TYPE:
|
case METHOD_TYPE:
|
case METHOD_TYPE:
|
/* If TYPE is a function type, it is variably modified if the
|
/* If TYPE is a function type, it is variably modified if the
|
return type is variably modified. */
|
return type is variably modified. */
|
if (variably_modified_type_p (TREE_TYPE (type), fn))
|
if (variably_modified_type_p (TREE_TYPE (type), fn))
|
return true;
|
return true;
|
break;
|
break;
|
|
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
case REAL_TYPE:
|
case REAL_TYPE:
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
case BOOLEAN_TYPE:
|
case BOOLEAN_TYPE:
|
/* Scalar types are variably modified if their end points
|
/* Scalar types are variably modified if their end points
|
aren't constant. */
|
aren't constant. */
|
RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
|
RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
|
RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
|
RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
|
break;
|
break;
|
|
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
/* We can't see if any of the fields are variably-modified by the
|
/* We can't see if any of the fields are variably-modified by the
|
definition we normally use, since that would produce infinite
|
definition we normally use, since that would produce infinite
|
recursion via pointers. */
|
recursion via pointers. */
|
/* This is variably modified if some field's type is. */
|
/* This is variably modified if some field's type is. */
|
for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
|
for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
|
if (TREE_CODE (t) == FIELD_DECL)
|
if (TREE_CODE (t) == FIELD_DECL)
|
{
|
{
|
RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
|
RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
|
RETURN_TRUE_IF_VAR (DECL_SIZE (t));
|
RETURN_TRUE_IF_VAR (DECL_SIZE (t));
|
RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
|
RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
|
|
|
if (TREE_CODE (type) == QUAL_UNION_TYPE)
|
if (TREE_CODE (type) == QUAL_UNION_TYPE)
|
RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
|
RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
|
}
|
}
|
break;
|
break;
|
|
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
/* Do not call ourselves to avoid infinite recursion. This is
|
/* Do not call ourselves to avoid infinite recursion. This is
|
variably modified if the element type is. */
|
variably modified if the element type is. */
|
RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
|
RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
|
RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
|
RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* The current language may have other cases to check, but in general,
|
/* The current language may have other cases to check, but in general,
|
all other types are not variably modified. */
|
all other types are not variably modified. */
|
return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
|
return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
|
|
|
#undef RETURN_TRUE_IF_VAR
|
#undef RETURN_TRUE_IF_VAR
|
}
|
}
|
|
|
/* Given a DECL or TYPE, return the scope in which it was declared, or
|
/* Given a DECL or TYPE, return the scope in which it was declared, or
|
NULL_TREE if there is no containing scope. */
|
NULL_TREE if there is no containing scope. */
|
|
|
tree
|
tree
|
get_containing_scope (tree t)
|
get_containing_scope (tree t)
|
{
|
{
|
return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
|
return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
|
}
|
}
|
|
|
/* Return the innermost context enclosing DECL that is
|
/* Return the innermost context enclosing DECL that is
|
a FUNCTION_DECL, or zero if none. */
|
a FUNCTION_DECL, or zero if none. */
|
|
|
tree
|
tree
|
decl_function_context (tree decl)
|
decl_function_context (tree decl)
|
{
|
{
|
tree context;
|
tree context;
|
|
|
if (TREE_CODE (decl) == ERROR_MARK)
|
if (TREE_CODE (decl) == ERROR_MARK)
|
return 0;
|
return 0;
|
|
|
/* C++ virtual functions use DECL_CONTEXT for the class of the vtable
|
/* C++ virtual functions use DECL_CONTEXT for the class of the vtable
|
where we look up the function at runtime. Such functions always take
|
where we look up the function at runtime. Such functions always take
|
a first argument of type 'pointer to real context'.
|
a first argument of type 'pointer to real context'.
|
|
|
C++ should really be fixed to use DECL_CONTEXT for the real context,
|
C++ should really be fixed to use DECL_CONTEXT for the real context,
|
and use something else for the "virtual context". */
|
and use something else for the "virtual context". */
|
else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
|
else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
|
context
|
context
|
= TYPE_MAIN_VARIANT
|
= TYPE_MAIN_VARIANT
|
(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
|
(TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
|
else
|
else
|
context = DECL_CONTEXT (decl);
|
context = DECL_CONTEXT (decl);
|
|
|
while (context && TREE_CODE (context) != FUNCTION_DECL)
|
while (context && TREE_CODE (context) != FUNCTION_DECL)
|
{
|
{
|
if (TREE_CODE (context) == BLOCK)
|
if (TREE_CODE (context) == BLOCK)
|
context = BLOCK_SUPERCONTEXT (context);
|
context = BLOCK_SUPERCONTEXT (context);
|
else
|
else
|
context = get_containing_scope (context);
|
context = get_containing_scope (context);
|
}
|
}
|
|
|
return context;
|
return context;
|
}
|
}
|
|
|
/* Return the innermost context enclosing DECL that is
|
/* Return the innermost context enclosing DECL that is
|
a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
|
a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
|
TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
|
TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
|
|
|
tree
|
tree
|
decl_type_context (tree decl)
|
decl_type_context (tree decl)
|
{
|
{
|
tree context = DECL_CONTEXT (decl);
|
tree context = DECL_CONTEXT (decl);
|
|
|
while (context)
|
while (context)
|
switch (TREE_CODE (context))
|
switch (TREE_CODE (context))
|
{
|
{
|
case NAMESPACE_DECL:
|
case NAMESPACE_DECL:
|
case TRANSLATION_UNIT_DECL:
|
case TRANSLATION_UNIT_DECL:
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
case RECORD_TYPE:
|
case RECORD_TYPE:
|
case UNION_TYPE:
|
case UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
case QUAL_UNION_TYPE:
|
return context;
|
return context;
|
|
|
case TYPE_DECL:
|
case TYPE_DECL:
|
case FUNCTION_DECL:
|
case FUNCTION_DECL:
|
context = DECL_CONTEXT (context);
|
context = DECL_CONTEXT (context);
|
break;
|
break;
|
|
|
case BLOCK:
|
case BLOCK:
|
context = BLOCK_SUPERCONTEXT (context);
|
context = BLOCK_SUPERCONTEXT (context);
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* CALL is a CALL_EXPR. Return the declaration for the function
|
/* CALL is a CALL_EXPR. Return the declaration for the function
|
called, or NULL_TREE if the called function cannot be
|
called, or NULL_TREE if the called function cannot be
|
determined. */
|
determined. */
|
|
|
tree
|
tree
|
get_callee_fndecl (tree call)
|
get_callee_fndecl (tree call)
|
{
|
{
|
tree addr;
|
tree addr;
|
|
|
if (call == error_mark_node)
|
if (call == error_mark_node)
|
return call;
|
return call;
|
|
|
/* It's invalid to call this function with anything but a
|
/* It's invalid to call this function with anything but a
|
CALL_EXPR. */
|
CALL_EXPR. */
|
gcc_assert (TREE_CODE (call) == CALL_EXPR);
|
gcc_assert (TREE_CODE (call) == CALL_EXPR);
|
|
|
/* The first operand to the CALL is the address of the function
|
/* The first operand to the CALL is the address of the function
|
called. */
|
called. */
|
addr = TREE_OPERAND (call, 0);
|
addr = TREE_OPERAND (call, 0);
|
|
|
STRIP_NOPS (addr);
|
STRIP_NOPS (addr);
|
|
|
/* If this is a readonly function pointer, extract its initial value. */
|
/* If this is a readonly function pointer, extract its initial value. */
|
if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
|
if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
|
&& TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
|
&& TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
|
&& DECL_INITIAL (addr))
|
&& DECL_INITIAL (addr))
|
addr = DECL_INITIAL (addr);
|
addr = DECL_INITIAL (addr);
|
|
|
/* If the address is just `&f' for some function `f', then we know
|
/* If the address is just `&f' for some function `f', then we know
|
that `f' is being called. */
|
that `f' is being called. */
|
if (TREE_CODE (addr) == ADDR_EXPR
|
if (TREE_CODE (addr) == ADDR_EXPR
|
&& TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
|
&& TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
|
return TREE_OPERAND (addr, 0);
|
return TREE_OPERAND (addr, 0);
|
|
|
/* We couldn't figure out what was being called. Maybe the front
|
/* We couldn't figure out what was being called. Maybe the front
|
end has some idea. */
|
end has some idea. */
|
return lang_hooks.lang_get_callee_fndecl (call);
|
return lang_hooks.lang_get_callee_fndecl (call);
|
}
|
}
|
|
|
/* Print debugging information about tree nodes generated during the compile,
|
/* Print debugging information about tree nodes generated during the compile,
|
and any language-specific information. */
|
and any language-specific information. */
|
|
|
void
|
void
|
dump_tree_statistics (void)
|
dump_tree_statistics (void)
|
{
|
{
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
int i;
|
int i;
|
int total_nodes, total_bytes;
|
int total_nodes, total_bytes;
|
#endif
|
#endif
|
|
|
fprintf (stderr, "\n??? tree nodes created\n\n");
|
fprintf (stderr, "\n??? tree nodes created\n\n");
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
fprintf (stderr, "Kind Nodes Bytes\n");
|
fprintf (stderr, "Kind Nodes Bytes\n");
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "---------------------------------------\n");
|
total_nodes = total_bytes = 0;
|
total_nodes = total_bytes = 0;
|
for (i = 0; i < (int) all_kinds; i++)
|
for (i = 0; i < (int) all_kinds; i++)
|
{
|
{
|
fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
|
fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
|
tree_node_counts[i], tree_node_sizes[i]);
|
tree_node_counts[i], tree_node_sizes[i]);
|
total_nodes += tree_node_counts[i];
|
total_nodes += tree_node_counts[i];
|
total_bytes += tree_node_sizes[i];
|
total_bytes += tree_node_sizes[i];
|
}
|
}
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
|
fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
|
fprintf (stderr, "---------------------------------------\n");
|
fprintf (stderr, "---------------------------------------\n");
|
ssanames_print_statistics ();
|
ssanames_print_statistics ();
|
phinodes_print_statistics ();
|
phinodes_print_statistics ();
|
#else
|
#else
|
fprintf (stderr, "(No per-node statistics)\n");
|
fprintf (stderr, "(No per-node statistics)\n");
|
#endif
|
#endif
|
print_type_hash_statistics ();
|
print_type_hash_statistics ();
|
print_debug_expr_statistics ();
|
print_debug_expr_statistics ();
|
print_value_expr_statistics ();
|
print_value_expr_statistics ();
|
print_restrict_base_statistics ();
|
print_restrict_base_statistics ();
|
lang_hooks.print_statistics ();
|
lang_hooks.print_statistics ();
|
}
|
}
|
|
|
#define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
|
#define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
|
|
|
/* Generate a crc32 of a string. */
|
/* Generate a crc32 of a string. */
|
|
|
unsigned
|
unsigned
|
crc32_string (unsigned chksum, const char *string)
|
crc32_string (unsigned chksum, const char *string)
|
{
|
{
|
do
|
do
|
{
|
{
|
unsigned value = *string << 24;
|
unsigned value = *string << 24;
|
unsigned ix;
|
unsigned ix;
|
|
|
for (ix = 8; ix--; value <<= 1)
|
for (ix = 8; ix--; value <<= 1)
|
{
|
{
|
unsigned feedback;
|
unsigned feedback;
|
|
|
feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
|
feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
|
chksum <<= 1;
|
chksum <<= 1;
|
chksum ^= feedback;
|
chksum ^= feedback;
|
}
|
}
|
}
|
}
|
while (*string++);
|
while (*string++);
|
return chksum;
|
return chksum;
|
}
|
}
|
|
|
/* P is a string that will be used in a symbol. Mask out any characters
|
/* P is a string that will be used in a symbol. Mask out any characters
|
that are not valid in that context. */
|
that are not valid in that context. */
|
|
|
void
|
void
|
clean_symbol_name (char *p)
|
clean_symbol_name (char *p)
|
{
|
{
|
for (; *p; p++)
|
for (; *p; p++)
|
if (! (ISALNUM (*p)
|
if (! (ISALNUM (*p)
|
#ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
|
#ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
|
|| *p == '$'
|
|| *p == '$'
|
#endif
|
#endif
|
#ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
|
#ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
|
|| *p == '.'
|
|| *p == '.'
|
#endif
|
#endif
|
))
|
))
|
*p = '_';
|
*p = '_';
|
}
|
}
|
|
|
/* Generate a name for a function unique to this translation unit.
|
/* Generate a name for a function unique to this translation unit.
|
TYPE is some string to identify the purpose of this function to the
|
TYPE is some string to identify the purpose of this function to the
|
linker or collect2. */
|
linker or collect2. */
|
|
|
tree
|
tree
|
get_file_function_name_long (const char *type)
|
get_file_function_name_long (const char *type)
|
{
|
{
|
char *buf;
|
char *buf;
|
const char *p;
|
const char *p;
|
char *q;
|
char *q;
|
|
|
if (first_global_object_name)
|
if (first_global_object_name)
|
{
|
{
|
p = first_global_object_name;
|
p = first_global_object_name;
|
|
|
/* For type 'F', the generated name must be unique not only to this
|
/* For type 'F', the generated name must be unique not only to this
|
translation unit but also to any given link. Since global names
|
translation unit but also to any given link. Since global names
|
can be overloaded, we concatenate the first global object name
|
can be overloaded, we concatenate the first global object name
|
with a string derived from the file name of this object. */
|
with a string derived from the file name of this object. */
|
if (!strcmp (type, "F"))
|
if (!strcmp (type, "F"))
|
{
|
{
|
const char *file = main_input_filename;
|
const char *file = main_input_filename;
|
|
|
if (! file)
|
if (! file)
|
file = input_filename;
|
file = input_filename;
|
|
|
q = alloca (strlen (p) + 10);
|
q = alloca (strlen (p) + 10);
|
sprintf (q, "%s_%08X", p, crc32_string (0, file));
|
sprintf (q, "%s_%08X", p, crc32_string (0, file));
|
|
|
p = q;
|
p = q;
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We don't have anything that we know to be unique to this translation
|
/* We don't have anything that we know to be unique to this translation
|
unit, so use what we do have and throw in some randomness. */
|
unit, so use what we do have and throw in some randomness. */
|
unsigned len;
|
unsigned len;
|
const char *name = weak_global_object_name;
|
const char *name = weak_global_object_name;
|
const char *file = main_input_filename;
|
const char *file = main_input_filename;
|
|
|
if (! name)
|
if (! name)
|
name = "";
|
name = "";
|
if (! file)
|
if (! file)
|
file = input_filename;
|
file = input_filename;
|
|
|
len = strlen (file);
|
len = strlen (file);
|
q = alloca (9 * 2 + len + 1);
|
q = alloca (9 * 2 + len + 1);
|
memcpy (q, file, len + 1);
|
memcpy (q, file, len + 1);
|
clean_symbol_name (q);
|
clean_symbol_name (q);
|
|
|
sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
|
sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
|
crc32_string (0, flag_random_seed));
|
crc32_string (0, flag_random_seed));
|
|
|
p = q;
|
p = q;
|
}
|
}
|
|
|
buf = alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) + strlen (type));
|
buf = alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) + strlen (type));
|
|
|
/* Set up the name of the file-level functions we may need.
|
/* Set up the name of the file-level functions we may need.
|
Use a global object (which is already required to be unique over
|
Use a global object (which is already required to be unique over
|
the program) rather than the file name (which imposes extra
|
the program) rather than the file name (which imposes extra
|
constraints). */
|
constraints). */
|
sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
|
sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
|
|
|
return get_identifier (buf);
|
return get_identifier (buf);
|
}
|
}
|
|
|
/* If KIND=='I', return a suitable global initializer (constructor) name.
|
/* If KIND=='I', return a suitable global initializer (constructor) name.
|
If KIND=='D', return a suitable global clean-up (destructor) name. */
|
If KIND=='D', return a suitable global clean-up (destructor) name. */
|
|
|
tree
|
tree
|
get_file_function_name (int kind)
|
get_file_function_name (int kind)
|
{
|
{
|
char p[2];
|
char p[2];
|
|
|
p[0] = kind;
|
p[0] = kind;
|
p[1] = 0;
|
p[1] = 0;
|
|
|
return get_file_function_name_long (p);
|
return get_file_function_name_long (p);
|
}
|
}
|
|
|
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
|
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
|
|
|
/* Complain that the tree code of NODE does not match the expected 0
|
/* Complain that the tree code of NODE does not match the expected 0
|
terminated list of trailing codes. The trailing code list can be
|
terminated list of trailing codes. The trailing code list can be
|
empty, for a more vague error message. FILE, LINE, and FUNCTION
|
empty, for a more vague error message. FILE, LINE, and FUNCTION
|
are of the caller. */
|
are of the caller. */
|
|
|
void
|
void
|
tree_check_failed (const tree node, const char *file,
|
tree_check_failed (const tree node, const char *file,
|
int line, const char *function, ...)
|
int line, const char *function, ...)
|
{
|
{
|
va_list args;
|
va_list args;
|
char *buffer;
|
char *buffer;
|
unsigned length = 0;
|
unsigned length = 0;
|
int code;
|
int code;
|
|
|
va_start (args, function);
|
va_start (args, function);
|
while ((code = va_arg (args, int)))
|
while ((code = va_arg (args, int)))
|
length += 4 + strlen (tree_code_name[code]);
|
length += 4 + strlen (tree_code_name[code]);
|
va_end (args);
|
va_end (args);
|
if (length)
|
if (length)
|
{
|
{
|
va_start (args, function);
|
va_start (args, function);
|
length += strlen ("expected ");
|
length += strlen ("expected ");
|
buffer = alloca (length);
|
buffer = alloca (length);
|
length = 0;
|
length = 0;
|
while ((code = va_arg (args, int)))
|
while ((code = va_arg (args, int)))
|
{
|
{
|
const char *prefix = length ? " or " : "expected ";
|
const char *prefix = length ? " or " : "expected ";
|
|
|
strcpy (buffer + length, prefix);
|
strcpy (buffer + length, prefix);
|
length += strlen (prefix);
|
length += strlen (prefix);
|
strcpy (buffer + length, tree_code_name[code]);
|
strcpy (buffer + length, tree_code_name[code]);
|
length += strlen (tree_code_name[code]);
|
length += strlen (tree_code_name[code]);
|
}
|
}
|
va_end (args);
|
va_end (args);
|
}
|
}
|
else
|
else
|
buffer = (char *)"unexpected node";
|
buffer = (char *)"unexpected node";
|
|
|
internal_error ("tree check: %s, have %s in %s, at %s:%d",
|
internal_error ("tree check: %s, have %s in %s, at %s:%d",
|
buffer, tree_code_name[TREE_CODE (node)],
|
buffer, tree_code_name[TREE_CODE (node)],
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
|
|
/* Complain that the tree code of NODE does match the expected 0
|
/* Complain that the tree code of NODE does match the expected 0
|
terminated list of trailing codes. FILE, LINE, and FUNCTION are of
|
terminated list of trailing codes. FILE, LINE, and FUNCTION are of
|
the caller. */
|
the caller. */
|
|
|
void
|
void
|
tree_not_check_failed (const tree node, const char *file,
|
tree_not_check_failed (const tree node, const char *file,
|
int line, const char *function, ...)
|
int line, const char *function, ...)
|
{
|
{
|
va_list args;
|
va_list args;
|
char *buffer;
|
char *buffer;
|
unsigned length = 0;
|
unsigned length = 0;
|
int code;
|
int code;
|
|
|
va_start (args, function);
|
va_start (args, function);
|
while ((code = va_arg (args, int)))
|
while ((code = va_arg (args, int)))
|
length += 4 + strlen (tree_code_name[code]);
|
length += 4 + strlen (tree_code_name[code]);
|
va_end (args);
|
va_end (args);
|
va_start (args, function);
|
va_start (args, function);
|
buffer = alloca (length);
|
buffer = alloca (length);
|
length = 0;
|
length = 0;
|
while ((code = va_arg (args, int)))
|
while ((code = va_arg (args, int)))
|
{
|
{
|
if (length)
|
if (length)
|
{
|
{
|
strcpy (buffer + length, " or ");
|
strcpy (buffer + length, " or ");
|
length += 4;
|
length += 4;
|
}
|
}
|
strcpy (buffer + length, tree_code_name[code]);
|
strcpy (buffer + length, tree_code_name[code]);
|
length += strlen (tree_code_name[code]);
|
length += strlen (tree_code_name[code]);
|
}
|
}
|
va_end (args);
|
va_end (args);
|
|
|
internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
|
internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
|
buffer, tree_code_name[TREE_CODE (node)],
|
buffer, tree_code_name[TREE_CODE (node)],
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
|
|
/* Similar to tree_check_failed, except that we check for a class of tree
|
/* Similar to tree_check_failed, except that we check for a class of tree
|
code, given in CL. */
|
code, given in CL. */
|
|
|
void
|
void
|
tree_class_check_failed (const tree node, const enum tree_code_class cl,
|
tree_class_check_failed (const tree node, const enum tree_code_class cl,
|
const char *file, int line, const char *function)
|
const char *file, int line, const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
|
("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
|
TREE_CODE_CLASS_STRING (cl),
|
TREE_CODE_CLASS_STRING (cl),
|
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
|
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
|
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
|
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
|
}
|
}
|
|
|
/* Similar to tree_check_failed, except that instead of specifying a
|
/* Similar to tree_check_failed, except that instead of specifying a
|
dozen codes, use the knowledge that they're all sequential. */
|
dozen codes, use the knowledge that they're all sequential. */
|
|
|
void
|
void
|
tree_range_check_failed (const tree node, const char *file, int line,
|
tree_range_check_failed (const tree node, const char *file, int line,
|
const char *function, enum tree_code c1,
|
const char *function, enum tree_code c1,
|
enum tree_code c2)
|
enum tree_code c2)
|
{
|
{
|
char *buffer;
|
char *buffer;
|
unsigned length = 0;
|
unsigned length = 0;
|
enum tree_code c;
|
enum tree_code c;
|
|
|
for (c = c1; c <= c2; ++c)
|
for (c = c1; c <= c2; ++c)
|
length += 4 + strlen (tree_code_name[c]);
|
length += 4 + strlen (tree_code_name[c]);
|
|
|
length += strlen ("expected ");
|
length += strlen ("expected ");
|
buffer = alloca (length);
|
buffer = alloca (length);
|
length = 0;
|
length = 0;
|
|
|
for (c = c1; c <= c2; ++c)
|
for (c = c1; c <= c2; ++c)
|
{
|
{
|
const char *prefix = length ? " or " : "expected ";
|
const char *prefix = length ? " or " : "expected ";
|
|
|
strcpy (buffer + length, prefix);
|
strcpy (buffer + length, prefix);
|
length += strlen (prefix);
|
length += strlen (prefix);
|
strcpy (buffer + length, tree_code_name[c]);
|
strcpy (buffer + length, tree_code_name[c]);
|
length += strlen (tree_code_name[c]);
|
length += strlen (tree_code_name[c]);
|
}
|
}
|
|
|
internal_error ("tree check: %s, have %s in %s, at %s:%d",
|
internal_error ("tree check: %s, have %s in %s, at %s:%d",
|
buffer, tree_code_name[TREE_CODE (node)],
|
buffer, tree_code_name[TREE_CODE (node)],
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
|
|
|
|
/* Similar to tree_check_failed, except that we check that a tree does
|
/* Similar to tree_check_failed, except that we check that a tree does
|
not have the specified code, given in CL. */
|
not have the specified code, given in CL. */
|
|
|
void
|
void
|
tree_not_class_check_failed (const tree node, const enum tree_code_class cl,
|
tree_not_class_check_failed (const tree node, const enum tree_code_class cl,
|
const char *file, int line, const char *function)
|
const char *file, int line, const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
|
("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
|
TREE_CODE_CLASS_STRING (cl),
|
TREE_CODE_CLASS_STRING (cl),
|
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
|
TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
|
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
|
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
|
}
|
}
|
|
|
|
|
/* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
|
/* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
|
|
|
void
|
void
|
omp_clause_check_failed (const tree node, const char *file, int line,
|
omp_clause_check_failed (const tree node, const char *file, int line,
|
const char *function, enum omp_clause_code code)
|
const char *function, enum omp_clause_code code)
|
{
|
{
|
internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
|
internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
|
omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
|
omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
|
|
|
|
/* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
|
/* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
|
|
|
void
|
void
|
omp_clause_range_check_failed (const tree node, const char *file, int line,
|
omp_clause_range_check_failed (const tree node, const char *file, int line,
|
const char *function, enum omp_clause_code c1,
|
const char *function, enum omp_clause_code c1,
|
enum omp_clause_code c2)
|
enum omp_clause_code c2)
|
{
|
{
|
char *buffer;
|
char *buffer;
|
unsigned length = 0;
|
unsigned length = 0;
|
enum omp_clause_code c;
|
enum omp_clause_code c;
|
|
|
for (c = c1; c <= c2; ++c)
|
for (c = c1; c <= c2; ++c)
|
length += 4 + strlen (omp_clause_code_name[c]);
|
length += 4 + strlen (omp_clause_code_name[c]);
|
|
|
length += strlen ("expected ");
|
length += strlen ("expected ");
|
buffer = alloca (length);
|
buffer = alloca (length);
|
length = 0;
|
length = 0;
|
|
|
for (c = c1; c <= c2; ++c)
|
for (c = c1; c <= c2; ++c)
|
{
|
{
|
const char *prefix = length ? " or " : "expected ";
|
const char *prefix = length ? " or " : "expected ";
|
|
|
strcpy (buffer + length, prefix);
|
strcpy (buffer + length, prefix);
|
length += strlen (prefix);
|
length += strlen (prefix);
|
strcpy (buffer + length, omp_clause_code_name[c]);
|
strcpy (buffer + length, omp_clause_code_name[c]);
|
length += strlen (omp_clause_code_name[c]);
|
length += strlen (omp_clause_code_name[c]);
|
}
|
}
|
|
|
internal_error ("tree check: %s, have %s in %s, at %s:%d",
|
internal_error ("tree check: %s, have %s in %s, at %s:%d",
|
buffer, omp_clause_code_name[TREE_CODE (node)],
|
buffer, omp_clause_code_name[TREE_CODE (node)],
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
|
|
|
|
#undef DEFTREESTRUCT
|
#undef DEFTREESTRUCT
|
#define DEFTREESTRUCT(VAL, NAME) NAME,
|
#define DEFTREESTRUCT(VAL, NAME) NAME,
|
|
|
static const char *ts_enum_names[] = {
|
static const char *ts_enum_names[] = {
|
#include "treestruct.def"
|
#include "treestruct.def"
|
};
|
};
|
#undef DEFTREESTRUCT
|
#undef DEFTREESTRUCT
|
|
|
#define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
|
#define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
|
|
|
/* Similar to tree_class_check_failed, except that we check for
|
/* Similar to tree_class_check_failed, except that we check for
|
whether CODE contains the tree structure identified by EN. */
|
whether CODE contains the tree structure identified by EN. */
|
|
|
void
|
void
|
tree_contains_struct_check_failed (const tree node,
|
tree_contains_struct_check_failed (const tree node,
|
const enum tree_node_structure_enum en,
|
const enum tree_node_structure_enum en,
|
const char *file, int line,
|
const char *file, int line,
|
const char *function)
|
const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
|
("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
|
TS_ENUM_NAME(en),
|
TS_ENUM_NAME(en),
|
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
|
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
|
}
|
}
|
|
|
|
|
/* Similar to above, except that the check is for the bounds of a TREE_VEC's
|
/* Similar to above, except that the check is for the bounds of a TREE_VEC's
|
(dynamically sized) vector. */
|
(dynamically sized) vector. */
|
|
|
void
|
void
|
tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
|
tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
|
const char *function)
|
const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
|
("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
|
idx + 1, len, function, trim_filename (file), line);
|
idx + 1, len, function, trim_filename (file), line);
|
}
|
}
|
|
|
/* Similar to above, except that the check is for the bounds of a PHI_NODE's
|
/* Similar to above, except that the check is for the bounds of a PHI_NODE's
|
(dynamically sized) vector. */
|
(dynamically sized) vector. */
|
|
|
void
|
void
|
phi_node_elt_check_failed (int idx, int len, const char *file, int line,
|
phi_node_elt_check_failed (int idx, int len, const char *file, int line,
|
const char *function)
|
const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: accessed elt %d of phi_node with %d elts in %s, at %s:%d",
|
("tree check: accessed elt %d of phi_node with %d elts in %s, at %s:%d",
|
idx + 1, len, function, trim_filename (file), line);
|
idx + 1, len, function, trim_filename (file), line);
|
}
|
}
|
|
|
/* Similar to above, except that the check is for the bounds of the operand
|
/* Similar to above, except that the check is for the bounds of the operand
|
vector of an expression node. */
|
vector of an expression node. */
|
|
|
void
|
void
|
tree_operand_check_failed (int idx, enum tree_code code, const char *file,
|
tree_operand_check_failed (int idx, enum tree_code code, const char *file,
|
int line, const char *function)
|
int line, const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
|
("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
|
idx + 1, tree_code_name[code], TREE_CODE_LENGTH (code),
|
idx + 1, tree_code_name[code], TREE_CODE_LENGTH (code),
|
function, trim_filename (file), line);
|
function, trim_filename (file), line);
|
}
|
}
|
|
|
/* Similar to above, except that the check is for the number of
|
/* Similar to above, except that the check is for the number of
|
operands of an OMP_CLAUSE node. */
|
operands of an OMP_CLAUSE node. */
|
|
|
void
|
void
|
omp_clause_operand_check_failed (int idx, tree t, const char *file,
|
omp_clause_operand_check_failed (int idx, tree t, const char *file,
|
int line, const char *function)
|
int line, const char *function)
|
{
|
{
|
internal_error
|
internal_error
|
("tree check: accessed operand %d of omp_clause %s with %d operands "
|
("tree check: accessed operand %d of omp_clause %s with %d operands "
|
"in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
|
"in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
|
omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
|
omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
|
trim_filename (file), line);
|
trim_filename (file), line);
|
}
|
}
|
#endif /* ENABLE_TREE_CHECKING */
|
#endif /* ENABLE_TREE_CHECKING */
|
|
|
/* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
|
/* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
|
and mapped to the machine mode MODE. Initialize its fields and build
|
and mapped to the machine mode MODE. Initialize its fields and build
|
the information necessary for debugging output. */
|
the information necessary for debugging output. */
|
|
|
static tree
|
static tree
|
make_vector_type (tree innertype, int nunits, enum machine_mode mode)
|
make_vector_type (tree innertype, int nunits, enum machine_mode mode)
|
{
|
{
|
tree t;
|
tree t;
|
hashval_t hashcode = 0;
|
hashval_t hashcode = 0;
|
|
|
/* Build a main variant, based on the main variant of the inner type, then
|
/* Build a main variant, based on the main variant of the inner type, then
|
use it to build the variant we return. */
|
use it to build the variant we return. */
|
if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
|
if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
|
&& TYPE_MAIN_VARIANT (innertype) != innertype)
|
&& TYPE_MAIN_VARIANT (innertype) != innertype)
|
return build_type_attribute_qual_variant (
|
return build_type_attribute_qual_variant (
|
make_vector_type (TYPE_MAIN_VARIANT (innertype), nunits, mode),
|
make_vector_type (TYPE_MAIN_VARIANT (innertype), nunits, mode),
|
TYPE_ATTRIBUTES (innertype),
|
TYPE_ATTRIBUTES (innertype),
|
TYPE_QUALS (innertype));
|
TYPE_QUALS (innertype));
|
|
|
t = make_node (VECTOR_TYPE);
|
t = make_node (VECTOR_TYPE);
|
TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
|
TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
|
SET_TYPE_VECTOR_SUBPARTS (t, nunits);
|
SET_TYPE_VECTOR_SUBPARTS (t, nunits);
|
TYPE_MODE (t) = mode;
|
TYPE_MODE (t) = mode;
|
TYPE_READONLY (t) = TYPE_READONLY (innertype);
|
TYPE_READONLY (t) = TYPE_READONLY (innertype);
|
TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype);
|
TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype);
|
|
|
layout_type (t);
|
layout_type (t);
|
|
|
{
|
{
|
tree index = build_int_cst (NULL_TREE, nunits - 1);
|
tree index = build_int_cst (NULL_TREE, nunits - 1);
|
tree array = build_array_type (innertype, build_index_type (index));
|
tree array = build_array_type (innertype, build_index_type (index));
|
tree rt = make_node (RECORD_TYPE);
|
tree rt = make_node (RECORD_TYPE);
|
|
|
TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
|
TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
|
DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
|
DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
|
layout_type (rt);
|
layout_type (rt);
|
TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
|
TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
|
/* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
|
/* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output
|
the representation type, and we want to find that die when looking up
|
the representation type, and we want to find that die when looking up
|
the vector type. This is most easily achieved by making the TYPE_UID
|
the vector type. This is most easily achieved by making the TYPE_UID
|
numbers equal. */
|
numbers equal. */
|
TYPE_UID (rt) = TYPE_UID (t);
|
TYPE_UID (rt) = TYPE_UID (t);
|
}
|
}
|
|
|
hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
|
hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
|
hashcode = iterative_hash_host_wide_int (mode, hashcode);
|
hashcode = iterative_hash_host_wide_int (mode, hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (innertype), hashcode);
|
hashcode = iterative_hash_object (TYPE_HASH (innertype), hashcode);
|
return type_hash_canon (hashcode, t);
|
return type_hash_canon (hashcode, t);
|
}
|
}
|
|
|
static tree
|
static tree
|
make_or_reuse_type (unsigned size, int unsignedp)
|
make_or_reuse_type (unsigned size, int unsignedp)
|
{
|
{
|
if (size == INT_TYPE_SIZE)
|
if (size == INT_TYPE_SIZE)
|
return unsignedp ? unsigned_type_node : integer_type_node;
|
return unsignedp ? unsigned_type_node : integer_type_node;
|
if (size == CHAR_TYPE_SIZE)
|
if (size == CHAR_TYPE_SIZE)
|
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
|
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
|
if (size == SHORT_TYPE_SIZE)
|
if (size == SHORT_TYPE_SIZE)
|
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
|
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
|
if (size == LONG_TYPE_SIZE)
|
if (size == LONG_TYPE_SIZE)
|
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
|
if (size == LONG_LONG_TYPE_SIZE)
|
if (size == LONG_LONG_TYPE_SIZE)
|
return (unsignedp ? long_long_unsigned_type_node
|
return (unsignedp ? long_long_unsigned_type_node
|
: long_long_integer_type_node);
|
: long_long_integer_type_node);
|
|
|
if (unsignedp)
|
if (unsignedp)
|
return make_unsigned_type (size);
|
return make_unsigned_type (size);
|
else
|
else
|
return make_signed_type (size);
|
return make_signed_type (size);
|
}
|
}
|
|
|
/* Create nodes for all integer types (and error_mark_node) using the sizes
|
/* Create nodes for all integer types (and error_mark_node) using the sizes
|
of C datatypes. The caller should call set_sizetype soon after calling
|
of C datatypes. The caller should call set_sizetype soon after calling
|
this function to select one of the types as sizetype. */
|
this function to select one of the types as sizetype. */
|
|
|
void
|
void
|
build_common_tree_nodes (bool signed_char, bool signed_sizetype)
|
build_common_tree_nodes (bool signed_char, bool signed_sizetype)
|
{
|
{
|
error_mark_node = make_node (ERROR_MARK);
|
error_mark_node = make_node (ERROR_MARK);
|
TREE_TYPE (error_mark_node) = error_mark_node;
|
TREE_TYPE (error_mark_node) = error_mark_node;
|
|
|
initialize_sizetypes (signed_sizetype);
|
initialize_sizetypes (signed_sizetype);
|
|
|
/* Define both `signed char' and `unsigned char'. */
|
/* Define both `signed char' and `unsigned char'. */
|
signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
|
signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
|
TYPE_STRING_FLAG (signed_char_type_node) = 1;
|
TYPE_STRING_FLAG (signed_char_type_node) = 1;
|
unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
|
unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
|
TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
|
TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
|
|
|
/* Define `char', which is like either `signed char' or `unsigned char'
|
/* Define `char', which is like either `signed char' or `unsigned char'
|
but not the same as either. */
|
but not the same as either. */
|
char_type_node
|
char_type_node
|
= (signed_char
|
= (signed_char
|
? make_signed_type (CHAR_TYPE_SIZE)
|
? make_signed_type (CHAR_TYPE_SIZE)
|
: make_unsigned_type (CHAR_TYPE_SIZE));
|
: make_unsigned_type (CHAR_TYPE_SIZE));
|
TYPE_STRING_FLAG (char_type_node) = 1;
|
TYPE_STRING_FLAG (char_type_node) = 1;
|
|
|
short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
|
short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
|
short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
|
short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
|
integer_type_node = make_signed_type (INT_TYPE_SIZE);
|
integer_type_node = make_signed_type (INT_TYPE_SIZE);
|
unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
|
unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
|
long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
|
long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
|
long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
|
long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
|
long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
|
long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
|
long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
|
long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
|
|
|
/* Define a boolean type. This type only represents boolean values but
|
/* Define a boolean type. This type only represents boolean values but
|
may be larger than char depending on the value of BOOL_TYPE_SIZE.
|
may be larger than char depending on the value of BOOL_TYPE_SIZE.
|
Front ends which want to override this size (i.e. Java) can redefine
|
Front ends which want to override this size (i.e. Java) can redefine
|
boolean_type_node before calling build_common_tree_nodes_2. */
|
boolean_type_node before calling build_common_tree_nodes_2. */
|
boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
|
boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
|
TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
|
TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
|
TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
|
TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
|
TYPE_PRECISION (boolean_type_node) = 1;
|
TYPE_PRECISION (boolean_type_node) = 1;
|
|
|
/* Fill in the rest of the sized types. Reuse existing type nodes
|
/* Fill in the rest of the sized types. Reuse existing type nodes
|
when possible. */
|
when possible. */
|
intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
|
intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
|
intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
|
intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
|
intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
|
intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
|
intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
|
intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
|
intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
|
intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
|
|
|
unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
|
unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
|
unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
|
unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
|
unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
|
unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
|
unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
|
unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
|
unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
|
unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
|
|
|
access_public_node = get_identifier ("public");
|
access_public_node = get_identifier ("public");
|
access_protected_node = get_identifier ("protected");
|
access_protected_node = get_identifier ("protected");
|
access_private_node = get_identifier ("private");
|
access_private_node = get_identifier ("private");
|
}
|
}
|
|
|
/* Call this function after calling build_common_tree_nodes and set_sizetype.
|
/* Call this function after calling build_common_tree_nodes and set_sizetype.
|
It will create several other common tree nodes. */
|
It will create several other common tree nodes. */
|
|
|
void
|
void
|
build_common_tree_nodes_2 (int short_double)
|
build_common_tree_nodes_2 (int short_double)
|
{
|
{
|
/* Define these next since types below may used them. */
|
/* Define these next since types below may used them. */
|
integer_zero_node = build_int_cst (NULL_TREE, 0);
|
integer_zero_node = build_int_cst (NULL_TREE, 0);
|
integer_one_node = build_int_cst (NULL_TREE, 1);
|
integer_one_node = build_int_cst (NULL_TREE, 1);
|
integer_minus_one_node = build_int_cst (NULL_TREE, -1);
|
integer_minus_one_node = build_int_cst (NULL_TREE, -1);
|
|
|
size_zero_node = size_int (0);
|
size_zero_node = size_int (0);
|
size_one_node = size_int (1);
|
size_one_node = size_int (1);
|
bitsize_zero_node = bitsize_int (0);
|
bitsize_zero_node = bitsize_int (0);
|
bitsize_one_node = bitsize_int (1);
|
bitsize_one_node = bitsize_int (1);
|
bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
|
bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
|
|
|
boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
|
boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
|
boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
|
boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
|
|
|
void_type_node = make_node (VOID_TYPE);
|
void_type_node = make_node (VOID_TYPE);
|
layout_type (void_type_node);
|
layout_type (void_type_node);
|
|
|
/* We are not going to have real types in C with less than byte alignment,
|
/* We are not going to have real types in C with less than byte alignment,
|
so we might as well not have any types that claim to have it. */
|
so we might as well not have any types that claim to have it. */
|
TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
|
TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
|
TYPE_USER_ALIGN (void_type_node) = 0;
|
TYPE_USER_ALIGN (void_type_node) = 0;
|
|
|
null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
|
null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
|
layout_type (TREE_TYPE (null_pointer_node));
|
layout_type (TREE_TYPE (null_pointer_node));
|
|
|
ptr_type_node = build_pointer_type (void_type_node);
|
ptr_type_node = build_pointer_type (void_type_node);
|
const_ptr_type_node
|
const_ptr_type_node
|
= build_pointer_type (build_type_variant (void_type_node, 1, 0));
|
= build_pointer_type (build_type_variant (void_type_node, 1, 0));
|
fileptr_type_node = ptr_type_node;
|
fileptr_type_node = ptr_type_node;
|
|
|
float_type_node = make_node (REAL_TYPE);
|
float_type_node = make_node (REAL_TYPE);
|
TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
|
TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
|
layout_type (float_type_node);
|
layout_type (float_type_node);
|
|
|
double_type_node = make_node (REAL_TYPE);
|
double_type_node = make_node (REAL_TYPE);
|
if (short_double)
|
if (short_double)
|
TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
|
TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
|
else
|
else
|
TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
|
TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
|
layout_type (double_type_node);
|
layout_type (double_type_node);
|
|
|
long_double_type_node = make_node (REAL_TYPE);
|
long_double_type_node = make_node (REAL_TYPE);
|
TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
|
TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
|
layout_type (long_double_type_node);
|
layout_type (long_double_type_node);
|
|
|
float_ptr_type_node = build_pointer_type (float_type_node);
|
float_ptr_type_node = build_pointer_type (float_type_node);
|
double_ptr_type_node = build_pointer_type (double_type_node);
|
double_ptr_type_node = build_pointer_type (double_type_node);
|
long_double_ptr_type_node = build_pointer_type (long_double_type_node);
|
long_double_ptr_type_node = build_pointer_type (long_double_type_node);
|
integer_ptr_type_node = build_pointer_type (integer_type_node);
|
integer_ptr_type_node = build_pointer_type (integer_type_node);
|
|
|
/* Decimal float types. */
|
/* Decimal float types. */
|
dfloat32_type_node = make_node (REAL_TYPE);
|
dfloat32_type_node = make_node (REAL_TYPE);
|
TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
|
TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
|
layout_type (dfloat32_type_node);
|
layout_type (dfloat32_type_node);
|
TYPE_MODE (dfloat32_type_node) = SDmode;
|
TYPE_MODE (dfloat32_type_node) = SDmode;
|
dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
|
dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
|
|
|
dfloat64_type_node = make_node (REAL_TYPE);
|
dfloat64_type_node = make_node (REAL_TYPE);
|
TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
|
TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
|
layout_type (dfloat64_type_node);
|
layout_type (dfloat64_type_node);
|
TYPE_MODE (dfloat64_type_node) = DDmode;
|
TYPE_MODE (dfloat64_type_node) = DDmode;
|
dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
|
dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
|
|
|
dfloat128_type_node = make_node (REAL_TYPE);
|
dfloat128_type_node = make_node (REAL_TYPE);
|
TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
|
TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
|
layout_type (dfloat128_type_node);
|
layout_type (dfloat128_type_node);
|
TYPE_MODE (dfloat128_type_node) = TDmode;
|
TYPE_MODE (dfloat128_type_node) = TDmode;
|
dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
|
dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
|
|
|
complex_integer_type_node = make_node (COMPLEX_TYPE);
|
complex_integer_type_node = make_node (COMPLEX_TYPE);
|
TREE_TYPE (complex_integer_type_node) = integer_type_node;
|
TREE_TYPE (complex_integer_type_node) = integer_type_node;
|
layout_type (complex_integer_type_node);
|
layout_type (complex_integer_type_node);
|
|
|
complex_float_type_node = make_node (COMPLEX_TYPE);
|
complex_float_type_node = make_node (COMPLEX_TYPE);
|
TREE_TYPE (complex_float_type_node) = float_type_node;
|
TREE_TYPE (complex_float_type_node) = float_type_node;
|
layout_type (complex_float_type_node);
|
layout_type (complex_float_type_node);
|
|
|
complex_double_type_node = make_node (COMPLEX_TYPE);
|
complex_double_type_node = make_node (COMPLEX_TYPE);
|
TREE_TYPE (complex_double_type_node) = double_type_node;
|
TREE_TYPE (complex_double_type_node) = double_type_node;
|
layout_type (complex_double_type_node);
|
layout_type (complex_double_type_node);
|
|
|
complex_long_double_type_node = make_node (COMPLEX_TYPE);
|
complex_long_double_type_node = make_node (COMPLEX_TYPE);
|
TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
|
TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
|
layout_type (complex_long_double_type_node);
|
layout_type (complex_long_double_type_node);
|
|
|
{
|
{
|
tree t = targetm.build_builtin_va_list ();
|
tree t = targetm.build_builtin_va_list ();
|
|
|
/* Many back-ends define record types without setting TYPE_NAME.
|
/* Many back-ends define record types without setting TYPE_NAME.
|
If we copied the record type here, we'd keep the original
|
If we copied the record type here, we'd keep the original
|
record type without a name. This breaks name mangling. So,
|
record type without a name. This breaks name mangling. So,
|
don't copy record types and let c_common_nodes_and_builtins()
|
don't copy record types and let c_common_nodes_and_builtins()
|
declare the type to be __builtin_va_list. */
|
declare the type to be __builtin_va_list. */
|
if (TREE_CODE (t) != RECORD_TYPE)
|
if (TREE_CODE (t) != RECORD_TYPE)
|
t = build_variant_type_copy (t);
|
t = build_variant_type_copy (t);
|
|
|
va_list_type_node = t;
|
va_list_type_node = t;
|
}
|
}
|
}
|
}
|
|
|
/* A subroutine of build_common_builtin_nodes. Define a builtin function. */
|
/* A subroutine of build_common_builtin_nodes. Define a builtin function. */
|
|
|
static void
|
static void
|
local_define_builtin (const char *name, tree type, enum built_in_function code,
|
local_define_builtin (const char *name, tree type, enum built_in_function code,
|
const char *library_name, int ecf_flags)
|
const char *library_name, int ecf_flags)
|
{
|
{
|
tree decl;
|
tree decl;
|
|
|
decl = lang_hooks.builtin_function (name, type, code, BUILT_IN_NORMAL,
|
decl = lang_hooks.builtin_function (name, type, code, BUILT_IN_NORMAL,
|
library_name, NULL_TREE);
|
library_name, NULL_TREE);
|
if (ecf_flags & ECF_CONST)
|
if (ecf_flags & ECF_CONST)
|
TREE_READONLY (decl) = 1;
|
TREE_READONLY (decl) = 1;
|
if (ecf_flags & ECF_PURE)
|
if (ecf_flags & ECF_PURE)
|
DECL_IS_PURE (decl) = 1;
|
DECL_IS_PURE (decl) = 1;
|
if (ecf_flags & ECF_NORETURN)
|
if (ecf_flags & ECF_NORETURN)
|
TREE_THIS_VOLATILE (decl) = 1;
|
TREE_THIS_VOLATILE (decl) = 1;
|
if (ecf_flags & ECF_NOTHROW)
|
if (ecf_flags & ECF_NOTHROW)
|
TREE_NOTHROW (decl) = 1;
|
TREE_NOTHROW (decl) = 1;
|
if (ecf_flags & ECF_MALLOC)
|
if (ecf_flags & ECF_MALLOC)
|
DECL_IS_MALLOC (decl) = 1;
|
DECL_IS_MALLOC (decl) = 1;
|
|
|
built_in_decls[code] = decl;
|
built_in_decls[code] = decl;
|
implicit_built_in_decls[code] = decl;
|
implicit_built_in_decls[code] = decl;
|
}
|
}
|
|
|
/* Call this function after instantiating all builtins that the language
|
/* Call this function after instantiating all builtins that the language
|
front end cares about. This will build the rest of the builtins that
|
front end cares about. This will build the rest of the builtins that
|
are relied upon by the tree optimizers and the middle-end. */
|
are relied upon by the tree optimizers and the middle-end. */
|
|
|
void
|
void
|
build_common_builtin_nodes (void)
|
build_common_builtin_nodes (void)
|
{
|
{
|
tree tmp, ftype;
|
tree tmp, ftype;
|
|
|
if (built_in_decls[BUILT_IN_MEMCPY] == NULL
|
if (built_in_decls[BUILT_IN_MEMCPY] == NULL
|
|| built_in_decls[BUILT_IN_MEMMOVE] == NULL)
|
|| built_in_decls[BUILT_IN_MEMMOVE] == NULL)
|
{
|
{
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
|
|
if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
|
if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
|
local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
|
local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
|
"memcpy", ECF_NOTHROW);
|
"memcpy", ECF_NOTHROW);
|
if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
|
if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
|
local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
|
local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
|
"memmove", ECF_NOTHROW);
|
"memmove", ECF_NOTHROW);
|
}
|
}
|
|
|
if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
|
if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
|
{
|
{
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
|
ftype = build_function_type (integer_type_node, tmp);
|
ftype = build_function_type (integer_type_node, tmp);
|
local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
|
local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
|
"memcmp", ECF_PURE | ECF_NOTHROW);
|
"memcmp", ECF_PURE | ECF_NOTHROW);
|
}
|
}
|
|
|
if (built_in_decls[BUILT_IN_MEMSET] == NULL)
|
if (built_in_decls[BUILT_IN_MEMSET] == NULL)
|
{
|
{
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
|
local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
|
"memset", ECF_NOTHROW);
|
"memset", ECF_NOTHROW);
|
}
|
}
|
|
|
if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
|
if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
|
{
|
{
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
|
ftype = build_function_type (ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
|
local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
|
"alloca", ECF_NOTHROW | ECF_MALLOC);
|
"alloca", ECF_NOTHROW | ECF_MALLOC);
|
}
|
}
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
local_define_builtin ("__builtin_init_trampoline", ftype,
|
local_define_builtin ("__builtin_init_trampoline", ftype,
|
BUILT_IN_INIT_TRAMPOLINE,
|
BUILT_IN_INIT_TRAMPOLINE,
|
"__builtin_init_trampoline", ECF_NOTHROW);
|
"__builtin_init_trampoline", ECF_NOTHROW);
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
ftype = build_function_type (ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
local_define_builtin ("__builtin_adjust_trampoline", ftype,
|
local_define_builtin ("__builtin_adjust_trampoline", ftype,
|
BUILT_IN_ADJUST_TRAMPOLINE,
|
BUILT_IN_ADJUST_TRAMPOLINE,
|
"__builtin_adjust_trampoline",
|
"__builtin_adjust_trampoline",
|
ECF_CONST | ECF_NOTHROW);
|
ECF_CONST | ECF_NOTHROW);
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
local_define_builtin ("__builtin_nonlocal_goto", ftype,
|
local_define_builtin ("__builtin_nonlocal_goto", ftype,
|
BUILT_IN_NONLOCAL_GOTO,
|
BUILT_IN_NONLOCAL_GOTO,
|
"__builtin_nonlocal_goto",
|
"__builtin_nonlocal_goto",
|
ECF_NORETURN | ECF_NOTHROW);
|
ECF_NORETURN | ECF_NOTHROW);
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
local_define_builtin ("__builtin_setjmp_setup", ftype,
|
local_define_builtin ("__builtin_setjmp_setup", ftype,
|
BUILT_IN_SETJMP_SETUP,
|
BUILT_IN_SETJMP_SETUP,
|
"__builtin_setjmp_setup", ECF_NOTHROW);
|
"__builtin_setjmp_setup", ECF_NOTHROW);
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
ftype = build_function_type (ptr_type_node, tmp);
|
ftype = build_function_type (ptr_type_node, tmp);
|
local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
|
local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
|
BUILT_IN_SETJMP_DISPATCHER,
|
BUILT_IN_SETJMP_DISPATCHER,
|
"__builtin_setjmp_dispatcher",
|
"__builtin_setjmp_dispatcher",
|
ECF_PURE | ECF_NOTHROW);
|
ECF_PURE | ECF_NOTHROW);
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
ftype = build_function_type (void_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
local_define_builtin ("__builtin_setjmp_receiver", ftype,
|
local_define_builtin ("__builtin_setjmp_receiver", ftype,
|
BUILT_IN_SETJMP_RECEIVER,
|
BUILT_IN_SETJMP_RECEIVER,
|
"__builtin_setjmp_receiver", ECF_NOTHROW);
|
"__builtin_setjmp_receiver", ECF_NOTHROW);
|
|
|
ftype = build_function_type (ptr_type_node, void_list_node);
|
ftype = build_function_type (ptr_type_node, void_list_node);
|
local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
|
local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
|
"__builtin_stack_save", ECF_NOTHROW);
|
"__builtin_stack_save", ECF_NOTHROW);
|
|
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
|
ftype = build_function_type (void_type_node, tmp);
|
ftype = build_function_type (void_type_node, tmp);
|
local_define_builtin ("__builtin_stack_restore", ftype,
|
local_define_builtin ("__builtin_stack_restore", ftype,
|
BUILT_IN_STACK_RESTORE,
|
BUILT_IN_STACK_RESTORE,
|
"__builtin_stack_restore", ECF_NOTHROW);
|
"__builtin_stack_restore", ECF_NOTHROW);
|
|
|
ftype = build_function_type (void_type_node, void_list_node);
|
ftype = build_function_type (void_type_node, void_list_node);
|
local_define_builtin ("__builtin_profile_func_enter", ftype,
|
local_define_builtin ("__builtin_profile_func_enter", ftype,
|
BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
|
BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
|
local_define_builtin ("__builtin_profile_func_exit", ftype,
|
local_define_builtin ("__builtin_profile_func_exit", ftype,
|
BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
|
BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
|
|
|
/* Complex multiplication and division. These are handled as builtins
|
/* Complex multiplication and division. These are handled as builtins
|
rather than optabs because emit_library_call_value doesn't support
|
rather than optabs because emit_library_call_value doesn't support
|
complex. Further, we can do slightly better with folding these
|
complex. Further, we can do slightly better with folding these
|
beasties if the real and complex parts of the arguments are separate. */
|
beasties if the real and complex parts of the arguments are separate. */
|
{
|
{
|
enum machine_mode mode;
|
enum machine_mode mode;
|
|
|
for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
|
for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
|
{
|
{
|
char mode_name_buf[4], *q;
|
char mode_name_buf[4], *q;
|
const char *p;
|
const char *p;
|
enum built_in_function mcode, dcode;
|
enum built_in_function mcode, dcode;
|
tree type, inner_type;
|
tree type, inner_type;
|
|
|
type = lang_hooks.types.type_for_mode (mode, 0);
|
type = lang_hooks.types.type_for_mode (mode, 0);
|
if (type == NULL)
|
if (type == NULL)
|
continue;
|
continue;
|
inner_type = TREE_TYPE (type);
|
inner_type = TREE_TYPE (type);
|
|
|
tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
|
tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
|
tmp = tree_cons (NULL_TREE, inner_type, tmp);
|
tmp = tree_cons (NULL_TREE, inner_type, tmp);
|
tmp = tree_cons (NULL_TREE, inner_type, tmp);
|
tmp = tree_cons (NULL_TREE, inner_type, tmp);
|
tmp = tree_cons (NULL_TREE, inner_type, tmp);
|
tmp = tree_cons (NULL_TREE, inner_type, tmp);
|
ftype = build_function_type (type, tmp);
|
ftype = build_function_type (type, tmp);
|
|
|
mcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
|
mcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
|
dcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
|
dcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT;
|
|
|
for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
|
for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
|
*q = TOLOWER (*p);
|
*q = TOLOWER (*p);
|
*q = '\0';
|
*q = '\0';
|
|
|
built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
|
built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
|
local_define_builtin (built_in_names[mcode], ftype, mcode,
|
local_define_builtin (built_in_names[mcode], ftype, mcode,
|
built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
|
built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
|
|
|
built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
|
built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
|
local_define_builtin (built_in_names[dcode], ftype, dcode,
|
local_define_builtin (built_in_names[dcode], ftype, dcode,
|
built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
|
built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* HACK. GROSS. This is absolutely disgusting. I wish there was a
|
/* HACK. GROSS. This is absolutely disgusting. I wish there was a
|
better way.
|
better way.
|
|
|
If we requested a pointer to a vector, build up the pointers that
|
If we requested a pointer to a vector, build up the pointers that
|
we stripped off while looking for the inner type. Similarly for
|
we stripped off while looking for the inner type. Similarly for
|
return values from functions.
|
return values from functions.
|
|
|
The argument TYPE is the top of the chain, and BOTTOM is the
|
The argument TYPE is the top of the chain, and BOTTOM is the
|
new type which we will point to. */
|
new type which we will point to. */
|
|
|
tree
|
tree
|
reconstruct_complex_type (tree type, tree bottom)
|
reconstruct_complex_type (tree type, tree bottom)
|
{
|
{
|
tree inner, outer;
|
tree inner, outer;
|
|
|
if (POINTER_TYPE_P (type))
|
if (POINTER_TYPE_P (type))
|
{
|
{
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
outer = build_pointer_type (inner);
|
outer = build_pointer_type (inner);
|
}
|
}
|
else if (TREE_CODE (type) == ARRAY_TYPE)
|
else if (TREE_CODE (type) == ARRAY_TYPE)
|
{
|
{
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
outer = build_array_type (inner, TYPE_DOMAIN (type));
|
outer = build_array_type (inner, TYPE_DOMAIN (type));
|
}
|
}
|
else if (TREE_CODE (type) == FUNCTION_TYPE)
|
else if (TREE_CODE (type) == FUNCTION_TYPE)
|
{
|
{
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
outer = build_function_type (inner, TYPE_ARG_TYPES (type));
|
outer = build_function_type (inner, TYPE_ARG_TYPES (type));
|
}
|
}
|
else if (TREE_CODE (type) == METHOD_TYPE)
|
else if (TREE_CODE (type) == METHOD_TYPE)
|
{
|
{
|
tree argtypes;
|
tree argtypes;
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
|
/* The build_method_type_directly() routine prepends 'this' to argument list,
|
/* The build_method_type_directly() routine prepends 'this' to argument list,
|
so we must compensate by getting rid of it. */
|
so we must compensate by getting rid of it. */
|
argtypes = TYPE_ARG_TYPES (type);
|
argtypes = TYPE_ARG_TYPES (type);
|
outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type),
|
outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type),
|
inner,
|
inner,
|
TYPE_ARG_TYPES (type));
|
TYPE_ARG_TYPES (type));
|
TYPE_ARG_TYPES (outer) = argtypes;
|
TYPE_ARG_TYPES (outer) = argtypes;
|
}
|
}
|
else
|
else
|
return bottom;
|
return bottom;
|
|
|
TYPE_READONLY (outer) = TYPE_READONLY (type);
|
TYPE_READONLY (outer) = TYPE_READONLY (type);
|
TYPE_VOLATILE (outer) = TYPE_VOLATILE (type);
|
TYPE_VOLATILE (outer) = TYPE_VOLATILE (type);
|
|
|
return outer;
|
return outer;
|
}
|
}
|
|
|
/* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
|
/* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
|
the inner type. */
|
the inner type. */
|
tree
|
tree
|
build_vector_type_for_mode (tree innertype, enum machine_mode mode)
|
build_vector_type_for_mode (tree innertype, enum machine_mode mode)
|
{
|
{
|
int nunits;
|
int nunits;
|
|
|
switch (GET_MODE_CLASS (mode))
|
switch (GET_MODE_CLASS (mode))
|
{
|
{
|
case MODE_VECTOR_INT:
|
case MODE_VECTOR_INT:
|
case MODE_VECTOR_FLOAT:
|
case MODE_VECTOR_FLOAT:
|
nunits = GET_MODE_NUNITS (mode);
|
nunits = GET_MODE_NUNITS (mode);
|
break;
|
break;
|
|
|
case MODE_INT:
|
case MODE_INT:
|
/* Check that there are no leftover bits. */
|
/* Check that there are no leftover bits. */
|
gcc_assert (GET_MODE_BITSIZE (mode)
|
gcc_assert (GET_MODE_BITSIZE (mode)
|
% TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
|
% TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
|
|
|
nunits = GET_MODE_BITSIZE (mode)
|
nunits = GET_MODE_BITSIZE (mode)
|
/ TREE_INT_CST_LOW (TYPE_SIZE (innertype));
|
/ TREE_INT_CST_LOW (TYPE_SIZE (innertype));
|
break;
|
break;
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
return make_vector_type (innertype, nunits, mode);
|
return make_vector_type (innertype, nunits, mode);
|
}
|
}
|
|
|
/* Similarly, but takes the inner type and number of units, which must be
|
/* Similarly, but takes the inner type and number of units, which must be
|
a power of two. */
|
a power of two. */
|
|
|
tree
|
tree
|
build_vector_type (tree innertype, int nunits)
|
build_vector_type (tree innertype, int nunits)
|
{
|
{
|
return make_vector_type (innertype, nunits, VOIDmode);
|
return make_vector_type (innertype, nunits, VOIDmode);
|
}
|
}
|
|
|
|
|
/* Build RESX_EXPR with given REGION_NUMBER. */
|
/* Build RESX_EXPR with given REGION_NUMBER. */
|
tree
|
tree
|
build_resx (int region_number)
|
build_resx (int region_number)
|
{
|
{
|
tree t;
|
tree t;
|
t = build1 (RESX_EXPR, void_type_node,
|
t = build1 (RESX_EXPR, void_type_node,
|
build_int_cst (NULL_TREE, region_number));
|
build_int_cst (NULL_TREE, region_number));
|
return t;
|
return t;
|
}
|
}
|
|
|
/* Given an initializer INIT, return TRUE if INIT is zero or some
|
/* Given an initializer INIT, return TRUE if INIT is zero or some
|
aggregate of zeros. Otherwise return FALSE. */
|
aggregate of zeros. Otherwise return FALSE. */
|
bool
|
bool
|
initializer_zerop (tree init)
|
initializer_zerop (tree init)
|
{
|
{
|
tree elt;
|
tree elt;
|
|
|
STRIP_NOPS (init);
|
STRIP_NOPS (init);
|
|
|
switch (TREE_CODE (init))
|
switch (TREE_CODE (init))
|
{
|
{
|
case INTEGER_CST:
|
case INTEGER_CST:
|
return integer_zerop (init);
|
return integer_zerop (init);
|
|
|
case REAL_CST:
|
case REAL_CST:
|
/* ??? Note that this is not correct for C4X float formats. There,
|
/* ??? Note that this is not correct for C4X float formats. There,
|
a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
|
a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
|
negative exponent. */
|
negative exponent. */
|
return real_zerop (init)
|
return real_zerop (init)
|
&& ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
|
&& ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
|
|
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
return integer_zerop (init)
|
return integer_zerop (init)
|
|| (real_zerop (init)
|
|| (real_zerop (init)
|
&& ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
|
&& ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
|
&& ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
|
&& ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
|
|
|
case VECTOR_CST:
|
case VECTOR_CST:
|
for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
|
for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
|
if (!initializer_zerop (TREE_VALUE (elt)))
|
if (!initializer_zerop (TREE_VALUE (elt)))
|
return false;
|
return false;
|
return true;
|
return true;
|
|
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
{
|
{
|
unsigned HOST_WIDE_INT idx;
|
unsigned HOST_WIDE_INT idx;
|
|
|
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
|
FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
|
if (!initializer_zerop (elt))
|
if (!initializer_zerop (elt))
|
return false;
|
return false;
|
return true;
|
return true;
|
}
|
}
|
|
|
default:
|
default:
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
|
|
/* Build an empty statement. */
|
/* Build an empty statement. */
|
|
|
tree
|
tree
|
build_empty_stmt (void)
|
build_empty_stmt (void)
|
{
|
{
|
return build1 (NOP_EXPR, void_type_node, size_zero_node);
|
return build1 (NOP_EXPR, void_type_node, size_zero_node);
|
}
|
}
|
|
|
|
|
/* Build an OpenMP clause with code CODE. */
|
/* Build an OpenMP clause with code CODE. */
|
|
|
tree
|
tree
|
build_omp_clause (enum omp_clause_code code)
|
build_omp_clause (enum omp_clause_code code)
|
{
|
{
|
tree t;
|
tree t;
|
int size, length;
|
int size, length;
|
|
|
length = omp_clause_num_ops[code];
|
length = omp_clause_num_ops[code];
|
size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
|
size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
|
|
|
t = ggc_alloc (size);
|
t = ggc_alloc (size);
|
memset (t, 0, size);
|
memset (t, 0, size);
|
TREE_SET_CODE (t, OMP_CLAUSE);
|
TREE_SET_CODE (t, OMP_CLAUSE);
|
OMP_CLAUSE_SET_CODE (t, code);
|
OMP_CLAUSE_SET_CODE (t, code);
|
|
|
#ifdef GATHER_STATISTICS
|
#ifdef GATHER_STATISTICS
|
tree_node_counts[(int) omp_clause_kind]++;
|
tree_node_counts[(int) omp_clause_kind]++;
|
tree_node_sizes[(int) omp_clause_kind] += size;
|
tree_node_sizes[(int) omp_clause_kind] += size;
|
#endif
|
#endif
|
|
|
return t;
|
return t;
|
}
|
}
|
|
|
|
|
/* Returns true if it is possible to prove that the index of
|
/* Returns true if it is possible to prove that the index of
|
an array access REF (an ARRAY_REF expression) falls into the
|
an array access REF (an ARRAY_REF expression) falls into the
|
array bounds. */
|
array bounds. */
|
|
|
bool
|
bool
|
in_array_bounds_p (tree ref)
|
in_array_bounds_p (tree ref)
|
{
|
{
|
tree idx = TREE_OPERAND (ref, 1);
|
tree idx = TREE_OPERAND (ref, 1);
|
tree min, max;
|
tree min, max;
|
|
|
if (TREE_CODE (idx) != INTEGER_CST)
|
if (TREE_CODE (idx) != INTEGER_CST)
|
return false;
|
return false;
|
|
|
min = array_ref_low_bound (ref);
|
min = array_ref_low_bound (ref);
|
max = array_ref_up_bound (ref);
|
max = array_ref_up_bound (ref);
|
if (!min
|
if (!min
|
|| !max
|
|| !max
|
|| TREE_CODE (min) != INTEGER_CST
|
|| TREE_CODE (min) != INTEGER_CST
|
|| TREE_CODE (max) != INTEGER_CST)
|
|| TREE_CODE (max) != INTEGER_CST)
|
return false;
|
return false;
|
|
|
if (tree_int_cst_lt (idx, min)
|
if (tree_int_cst_lt (idx, min)
|
|| tree_int_cst_lt (max, idx))
|
|| tree_int_cst_lt (max, idx))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Returns true if it is possible to prove that the range of
|
/* Returns true if it is possible to prove that the range of
|
an array access REF (an ARRAY_RANGE_REF expression) falls
|
an array access REF (an ARRAY_RANGE_REF expression) falls
|
into the array bounds. */
|
into the array bounds. */
|
|
|
bool
|
bool
|
range_in_array_bounds_p (tree ref)
|
range_in_array_bounds_p (tree ref)
|
{
|
{
|
tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
|
tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
|
tree range_min, range_max, min, max;
|
tree range_min, range_max, min, max;
|
|
|
range_min = TYPE_MIN_VALUE (domain_type);
|
range_min = TYPE_MIN_VALUE (domain_type);
|
range_max = TYPE_MAX_VALUE (domain_type);
|
range_max = TYPE_MAX_VALUE (domain_type);
|
if (!range_min
|
if (!range_min
|
|| !range_max
|
|| !range_max
|
|| TREE_CODE (range_min) != INTEGER_CST
|
|| TREE_CODE (range_min) != INTEGER_CST
|
|| TREE_CODE (range_max) != INTEGER_CST)
|
|| TREE_CODE (range_max) != INTEGER_CST)
|
return false;
|
return false;
|
|
|
min = array_ref_low_bound (ref);
|
min = array_ref_low_bound (ref);
|
max = array_ref_up_bound (ref);
|
max = array_ref_up_bound (ref);
|
if (!min
|
if (!min
|
|| !max
|
|| !max
|
|| TREE_CODE (min) != INTEGER_CST
|
|| TREE_CODE (min) != INTEGER_CST
|
|| TREE_CODE (max) != INTEGER_CST)
|
|| TREE_CODE (max) != INTEGER_CST)
|
return false;
|
return false;
|
|
|
if (tree_int_cst_lt (range_min, min)
|
if (tree_int_cst_lt (range_min, min)
|
|| tree_int_cst_lt (max, range_max))
|
|| tree_int_cst_lt (max, range_max))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Return true if T (assumed to be a DECL) is a global variable. */
|
/* Return true if T (assumed to be a DECL) is a global variable. */
|
|
|
bool
|
bool
|
is_global_var (tree t)
|
is_global_var (tree t)
|
{
|
{
|
if (MTAG_P (t))
|
if (MTAG_P (t))
|
return (TREE_STATIC (t) || MTAG_GLOBAL (t));
|
return (TREE_STATIC (t) || MTAG_GLOBAL (t));
|
else
|
else
|
return (TREE_STATIC (t) || DECL_EXTERNAL (t));
|
return (TREE_STATIC (t) || DECL_EXTERNAL (t));
|
}
|
}
|
|
|
/* Return true if T (assumed to be a DECL) must be assigned a memory
|
/* Return true if T (assumed to be a DECL) must be assigned a memory
|
location. */
|
location. */
|
|
|
bool
|
bool
|
needs_to_live_in_memory (tree t)
|
needs_to_live_in_memory (tree t)
|
{
|
{
|
return (TREE_ADDRESSABLE (t)
|
return (TREE_ADDRESSABLE (t)
|
|| is_global_var (t)
|
|| is_global_var (t)
|
|| (TREE_CODE (t) == RESULT_DECL
|
|| (TREE_CODE (t) == RESULT_DECL
|
&& aggregate_value_p (t, current_function_decl)));
|
&& aggregate_value_p (t, current_function_decl)));
|
}
|
}
|
|
|
/* There are situations in which a language considers record types
|
/* There are situations in which a language considers record types
|
compatible which have different field lists. Decide if two fields
|
compatible which have different field lists. Decide if two fields
|
are compatible. It is assumed that the parent records are compatible. */
|
are compatible. It is assumed that the parent records are compatible. */
|
|
|
bool
|
bool
|
fields_compatible_p (tree f1, tree f2)
|
fields_compatible_p (tree f1, tree f2)
|
{
|
{
|
if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
|
if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
|
DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
|
DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
|
return false;
|
return false;
|
|
|
if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
|
if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
|
DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
|
DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
|
return false;
|
return false;
|
|
|
if (!lang_hooks.types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
|
if (!lang_hooks.types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
/* Locate within RECORD a field that is compatible with ORIG_FIELD. */
|
/* Locate within RECORD a field that is compatible with ORIG_FIELD. */
|
|
|
tree
|
tree
|
find_compatible_field (tree record, tree orig_field)
|
find_compatible_field (tree record, tree orig_field)
|
{
|
{
|
tree f;
|
tree f;
|
|
|
for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
|
for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
|
if (TREE_CODE (f) == FIELD_DECL
|
if (TREE_CODE (f) == FIELD_DECL
|
&& fields_compatible_p (f, orig_field))
|
&& fields_compatible_p (f, orig_field))
|
return f;
|
return f;
|
|
|
/* ??? Why isn't this on the main fields list? */
|
/* ??? Why isn't this on the main fields list? */
|
f = TYPE_VFIELD (record);
|
f = TYPE_VFIELD (record);
|
if (f && TREE_CODE (f) == FIELD_DECL
|
if (f && TREE_CODE (f) == FIELD_DECL
|
&& fields_compatible_p (f, orig_field))
|
&& fields_compatible_p (f, orig_field))
|
return f;
|
return f;
|
|
|
/* ??? We should abort here, but Java appears to do Bad Things
|
/* ??? We should abort here, but Java appears to do Bad Things
|
with inherited fields. */
|
with inherited fields. */
|
return orig_field;
|
return orig_field;
|
}
|
}
|
|
|
/* Return value of a constant X. */
|
/* Return value of a constant X. */
|
|
|
HOST_WIDE_INT
|
HOST_WIDE_INT
|
int_cst_value (tree x)
|
int_cst_value (tree x)
|
{
|
{
|
unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
|
unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
|
unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
|
unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
|
bool negative = ((val >> (bits - 1)) & 1) != 0;
|
bool negative = ((val >> (bits - 1)) & 1) != 0;
|
|
|
gcc_assert (bits <= HOST_BITS_PER_WIDE_INT);
|
gcc_assert (bits <= HOST_BITS_PER_WIDE_INT);
|
|
|
if (negative)
|
if (negative)
|
val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
|
val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
|
else
|
else
|
val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
|
val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
|
|
|
return val;
|
return val;
|
}
|
}
|
|
|
/* Returns the greatest common divisor of A and B, which must be
|
/* Returns the greatest common divisor of A and B, which must be
|
INTEGER_CSTs. */
|
INTEGER_CSTs. */
|
|
|
tree
|
tree
|
tree_fold_gcd (tree a, tree b)
|
tree_fold_gcd (tree a, tree b)
|
{
|
{
|
tree a_mod_b;
|
tree a_mod_b;
|
tree type = TREE_TYPE (a);
|
tree type = TREE_TYPE (a);
|
|
|
gcc_assert (TREE_CODE (a) == INTEGER_CST);
|
gcc_assert (TREE_CODE (a) == INTEGER_CST);
|
gcc_assert (TREE_CODE (b) == INTEGER_CST);
|
gcc_assert (TREE_CODE (b) == INTEGER_CST);
|
|
|
if (integer_zerop (a))
|
if (integer_zerop (a))
|
return b;
|
return b;
|
|
|
if (integer_zerop (b))
|
if (integer_zerop (b))
|
return a;
|
return a;
|
|
|
if (tree_int_cst_sgn (a) == -1)
|
if (tree_int_cst_sgn (a) == -1)
|
a = fold_build2 (MULT_EXPR, type, a,
|
a = fold_build2 (MULT_EXPR, type, a,
|
build_int_cst (type, -1));
|
build_int_cst (type, -1));
|
|
|
if (tree_int_cst_sgn (b) == -1)
|
if (tree_int_cst_sgn (b) == -1)
|
b = fold_build2 (MULT_EXPR, type, b,
|
b = fold_build2 (MULT_EXPR, type, b,
|
build_int_cst (type, -1));
|
build_int_cst (type, -1));
|
|
|
while (1)
|
while (1)
|
{
|
{
|
a_mod_b = fold_build2 (FLOOR_MOD_EXPR, type, a, b);
|
a_mod_b = fold_build2 (FLOOR_MOD_EXPR, type, a, b);
|
|
|
if (!TREE_INT_CST_LOW (a_mod_b)
|
if (!TREE_INT_CST_LOW (a_mod_b)
|
&& !TREE_INT_CST_HIGH (a_mod_b))
|
&& !TREE_INT_CST_HIGH (a_mod_b))
|
return b;
|
return b;
|
|
|
a = b;
|
a = b;
|
b = a_mod_b;
|
b = a_mod_b;
|
}
|
}
|
}
|
}
|
|
|
/* Returns unsigned variant of TYPE. */
|
/* Returns unsigned variant of TYPE. */
|
|
|
tree
|
tree
|
unsigned_type_for (tree type)
|
unsigned_type_for (tree type)
|
{
|
{
|
if (POINTER_TYPE_P (type))
|
if (POINTER_TYPE_P (type))
|
return lang_hooks.types.unsigned_type (size_type_node);
|
return lang_hooks.types.unsigned_type (size_type_node);
|
return lang_hooks.types.unsigned_type (type);
|
return lang_hooks.types.unsigned_type (type);
|
}
|
}
|
|
|
/* Returns signed variant of TYPE. */
|
/* Returns signed variant of TYPE. */
|
|
|
tree
|
tree
|
signed_type_for (tree type)
|
signed_type_for (tree type)
|
{
|
{
|
if (POINTER_TYPE_P (type))
|
if (POINTER_TYPE_P (type))
|
return lang_hooks.types.signed_type (size_type_node);
|
return lang_hooks.types.signed_type (size_type_node);
|
return lang_hooks.types.signed_type (type);
|
return lang_hooks.types.signed_type (type);
|
}
|
}
|
|
|
/* Returns the largest value obtainable by casting something in INNER type to
|
/* Returns the largest value obtainable by casting something in INNER type to
|
OUTER type. */
|
OUTER type. */
|
|
|
tree
|
tree
|
upper_bound_in_type (tree outer, tree inner)
|
upper_bound_in_type (tree outer, tree inner)
|
{
|
{
|
unsigned HOST_WIDE_INT lo, hi;
|
unsigned HOST_WIDE_INT lo, hi;
|
unsigned int det = 0;
|
unsigned int det = 0;
|
unsigned oprec = TYPE_PRECISION (outer);
|
unsigned oprec = TYPE_PRECISION (outer);
|
unsigned iprec = TYPE_PRECISION (inner);
|
unsigned iprec = TYPE_PRECISION (inner);
|
unsigned prec;
|
unsigned prec;
|
|
|
/* Compute a unique number for every combination. */
|
/* Compute a unique number for every combination. */
|
det |= (oprec > iprec) ? 4 : 0;
|
det |= (oprec > iprec) ? 4 : 0;
|
det |= TYPE_UNSIGNED (outer) ? 2 : 0;
|
det |= TYPE_UNSIGNED (outer) ? 2 : 0;
|
det |= TYPE_UNSIGNED (inner) ? 1 : 0;
|
det |= TYPE_UNSIGNED (inner) ? 1 : 0;
|
|
|
/* Determine the exponent to use. */
|
/* Determine the exponent to use. */
|
switch (det)
|
switch (det)
|
{
|
{
|
case 0:
|
case 0:
|
case 1:
|
case 1:
|
/* oprec <= iprec, outer: signed, inner: don't care. */
|
/* oprec <= iprec, outer: signed, inner: don't care. */
|
prec = oprec - 1;
|
prec = oprec - 1;
|
break;
|
break;
|
case 2:
|
case 2:
|
case 3:
|
case 3:
|
/* oprec <= iprec, outer: unsigned, inner: don't care. */
|
/* oprec <= iprec, outer: unsigned, inner: don't care. */
|
prec = oprec;
|
prec = oprec;
|
break;
|
break;
|
case 4:
|
case 4:
|
/* oprec > iprec, outer: signed, inner: signed. */
|
/* oprec > iprec, outer: signed, inner: signed. */
|
prec = iprec - 1;
|
prec = iprec - 1;
|
break;
|
break;
|
case 5:
|
case 5:
|
/* oprec > iprec, outer: signed, inner: unsigned. */
|
/* oprec > iprec, outer: signed, inner: unsigned. */
|
prec = iprec;
|
prec = iprec;
|
break;
|
break;
|
case 6:
|
case 6:
|
/* oprec > iprec, outer: unsigned, inner: signed. */
|
/* oprec > iprec, outer: unsigned, inner: signed. */
|
prec = oprec;
|
prec = oprec;
|
break;
|
break;
|
case 7:
|
case 7:
|
/* oprec > iprec, outer: unsigned, inner: unsigned. */
|
/* oprec > iprec, outer: unsigned, inner: unsigned. */
|
prec = iprec;
|
prec = iprec;
|
break;
|
break;
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
|
|
/* Compute 2^^prec - 1. */
|
/* Compute 2^^prec - 1. */
|
if (prec <= HOST_BITS_PER_WIDE_INT)
|
if (prec <= HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
hi = 0;
|
hi = 0;
|
lo = ((~(unsigned HOST_WIDE_INT) 0)
|
lo = ((~(unsigned HOST_WIDE_INT) 0)
|
>> (HOST_BITS_PER_WIDE_INT - prec));
|
>> (HOST_BITS_PER_WIDE_INT - prec));
|
}
|
}
|
else
|
else
|
{
|
{
|
hi = ((~(unsigned HOST_WIDE_INT) 0)
|
hi = ((~(unsigned HOST_WIDE_INT) 0)
|
>> (2 * HOST_BITS_PER_WIDE_INT - prec));
|
>> (2 * HOST_BITS_PER_WIDE_INT - prec));
|
lo = ~(unsigned HOST_WIDE_INT) 0;
|
lo = ~(unsigned HOST_WIDE_INT) 0;
|
}
|
}
|
|
|
return build_int_cst_wide (outer, lo, hi);
|
return build_int_cst_wide (outer, lo, hi);
|
}
|
}
|
|
|
/* Returns the smallest value obtainable by casting something in INNER type to
|
/* Returns the smallest value obtainable by casting something in INNER type to
|
OUTER type. */
|
OUTER type. */
|
|
|
tree
|
tree
|
lower_bound_in_type (tree outer, tree inner)
|
lower_bound_in_type (tree outer, tree inner)
|
{
|
{
|
unsigned HOST_WIDE_INT lo, hi;
|
unsigned HOST_WIDE_INT lo, hi;
|
unsigned oprec = TYPE_PRECISION (outer);
|
unsigned oprec = TYPE_PRECISION (outer);
|
unsigned iprec = TYPE_PRECISION (inner);
|
unsigned iprec = TYPE_PRECISION (inner);
|
|
|
/* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
|
/* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
|
and obtain 0. */
|
and obtain 0. */
|
if (TYPE_UNSIGNED (outer)
|
if (TYPE_UNSIGNED (outer)
|
/* If we are widening something of an unsigned type, OUTER type
|
/* If we are widening something of an unsigned type, OUTER type
|
contains all values of INNER type. In particular, both INNER
|
contains all values of INNER type. In particular, both INNER
|
and OUTER types have zero in common. */
|
and OUTER types have zero in common. */
|
|| (oprec > iprec && TYPE_UNSIGNED (inner)))
|
|| (oprec > iprec && TYPE_UNSIGNED (inner)))
|
lo = hi = 0;
|
lo = hi = 0;
|
else
|
else
|
{
|
{
|
/* If we are widening a signed type to another signed type, we
|
/* If we are widening a signed type to another signed type, we
|
want to obtain -2^^(iprec-1). If we are keeping the
|
want to obtain -2^^(iprec-1). If we are keeping the
|
precision or narrowing to a signed type, we want to obtain
|
precision or narrowing to a signed type, we want to obtain
|
-2^(oprec-1). */
|
-2^(oprec-1). */
|
unsigned prec = oprec > iprec ? iprec : oprec;
|
unsigned prec = oprec > iprec ? iprec : oprec;
|
|
|
if (prec <= HOST_BITS_PER_WIDE_INT)
|
if (prec <= HOST_BITS_PER_WIDE_INT)
|
{
|
{
|
hi = ~(unsigned HOST_WIDE_INT) 0;
|
hi = ~(unsigned HOST_WIDE_INT) 0;
|
lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
|
lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
|
}
|
}
|
else
|
else
|
{
|
{
|
hi = ((~(unsigned HOST_WIDE_INT) 0)
|
hi = ((~(unsigned HOST_WIDE_INT) 0)
|
<< (prec - HOST_BITS_PER_WIDE_INT - 1));
|
<< (prec - HOST_BITS_PER_WIDE_INT - 1));
|
lo = 0;
|
lo = 0;
|
}
|
}
|
}
|
}
|
|
|
return build_int_cst_wide (outer, lo, hi);
|
return build_int_cst_wide (outer, lo, hi);
|
}
|
}
|
|
|
/* Return nonzero if two operands that are suitable for PHI nodes are
|
/* Return nonzero if two operands that are suitable for PHI nodes are
|
necessarily equal. Specifically, both ARG0 and ARG1 must be either
|
necessarily equal. Specifically, both ARG0 and ARG1 must be either
|
SSA_NAME or invariant. Note that this is strictly an optimization.
|
SSA_NAME or invariant. Note that this is strictly an optimization.
|
That is, callers of this function can directly call operand_equal_p
|
That is, callers of this function can directly call operand_equal_p
|
and get the same result, only slower. */
|
and get the same result, only slower. */
|
|
|
int
|
int
|
operand_equal_for_phi_arg_p (tree arg0, tree arg1)
|
operand_equal_for_phi_arg_p (tree arg0, tree arg1)
|
{
|
{
|
if (arg0 == arg1)
|
if (arg0 == arg1)
|
return 1;
|
return 1;
|
if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
|
if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
|
return 0;
|
return 0;
|
return operand_equal_p (arg0, arg1, 0);
|
return operand_equal_p (arg0, arg1, 0);
|
}
|
}
|
|
|
/* Returns number of zeros at the end of binary representation of X.
|
/* Returns number of zeros at the end of binary representation of X.
|
|
|
??? Use ffs if available? */
|
??? Use ffs if available? */
|
|
|
tree
|
tree
|
num_ending_zeros (tree x)
|
num_ending_zeros (tree x)
|
{
|
{
|
unsigned HOST_WIDE_INT fr, nfr;
|
unsigned HOST_WIDE_INT fr, nfr;
|
unsigned num, abits;
|
unsigned num, abits;
|
tree type = TREE_TYPE (x);
|
tree type = TREE_TYPE (x);
|
|
|
if (TREE_INT_CST_LOW (x) == 0)
|
if (TREE_INT_CST_LOW (x) == 0)
|
{
|
{
|
num = HOST_BITS_PER_WIDE_INT;
|
num = HOST_BITS_PER_WIDE_INT;
|
fr = TREE_INT_CST_HIGH (x);
|
fr = TREE_INT_CST_HIGH (x);
|
}
|
}
|
else
|
else
|
{
|
{
|
num = 0;
|
num = 0;
|
fr = TREE_INT_CST_LOW (x);
|
fr = TREE_INT_CST_LOW (x);
|
}
|
}
|
|
|
for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
|
for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
|
{
|
{
|
nfr = fr >> abits;
|
nfr = fr >> abits;
|
if (nfr << abits == fr)
|
if (nfr << abits == fr)
|
{
|
{
|
num += abits;
|
num += abits;
|
fr = nfr;
|
fr = nfr;
|
}
|
}
|
}
|
}
|
|
|
if (num > TYPE_PRECISION (type))
|
if (num > TYPE_PRECISION (type))
|
num = TYPE_PRECISION (type);
|
num = TYPE_PRECISION (type);
|
|
|
return build_int_cst_type (type, num);
|
return build_int_cst_type (type, num);
|
}
|
}
|
|
|
|
|
#define WALK_SUBTREE(NODE) \
|
#define WALK_SUBTREE(NODE) \
|
do \
|
do \
|
{ \
|
{ \
|
result = walk_tree (&(NODE), func, data, pset); \
|
result = walk_tree (&(NODE), func, data, pset); \
|
if (result) \
|
if (result) \
|
return result; \
|
return result; \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
/* This is a subroutine of walk_tree that walks field of TYPE that are to
|
/* This is a subroutine of walk_tree that walks field of TYPE that are to
|
be walked whenever a type is seen in the tree. Rest of operands and return
|
be walked whenever a type is seen in the tree. Rest of operands and return
|
value are as for walk_tree. */
|
value are as for walk_tree. */
|
|
|
static tree
|
static tree
|
walk_type_fields (tree type, walk_tree_fn func, void *data,
|
walk_type_fields (tree type, walk_tree_fn func, void *data,
|
struct pointer_set_t *pset)
|
struct pointer_set_t *pset)
|
{
|
{
|
tree result = NULL_TREE;
|
tree result = NULL_TREE;
|
|
|
switch (TREE_CODE (type))
|
switch (TREE_CODE (type))
|
{
|
{
|
case POINTER_TYPE:
|
case POINTER_TYPE:
|
case REFERENCE_TYPE:
|
case REFERENCE_TYPE:
|
/* We have to worry about mutually recursive pointers. These can't
|
/* We have to worry about mutually recursive pointers. These can't
|
be written in C. They can in Ada. It's pathological, but
|
be written in C. They can in Ada. It's pathological, but
|
there's an ACATS test (c38102a) that checks it. Deal with this
|
there's an ACATS test (c38102a) that checks it. Deal with this
|
by checking if we're pointing to another pointer, that one
|
by checking if we're pointing to another pointer, that one
|
points to another pointer, that one does too, and we have no htab.
|
points to another pointer, that one does too, and we have no htab.
|
If so, get a hash table. We check three levels deep to avoid
|
If so, get a hash table. We check three levels deep to avoid
|
the cost of the hash table if we don't need one. */
|
the cost of the hash table if we don't need one. */
|
if (POINTER_TYPE_P (TREE_TYPE (type))
|
if (POINTER_TYPE_P (TREE_TYPE (type))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
|
&& POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
|
&& !pset)
|
&& !pset)
|
{
|
{
|
result = walk_tree_without_duplicates (&TREE_TYPE (type),
|
result = walk_tree_without_duplicates (&TREE_TYPE (type),
|
func, data);
|
func, data);
|
if (result)
|
if (result)
|
return result;
|
return result;
|
|
|
break;
|
break;
|
}
|
}
|
|
|
/* ... fall through ... */
|
/* ... fall through ... */
|
|
|
case COMPLEX_TYPE:
|
case COMPLEX_TYPE:
|
WALK_SUBTREE (TREE_TYPE (type));
|
WALK_SUBTREE (TREE_TYPE (type));
|
break;
|
break;
|
|
|
case METHOD_TYPE:
|
case METHOD_TYPE:
|
WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
|
WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
|
|
|
/* Fall through. */
|
/* Fall through. */
|
|
|
case FUNCTION_TYPE:
|
case FUNCTION_TYPE:
|
WALK_SUBTREE (TREE_TYPE (type));
|
WALK_SUBTREE (TREE_TYPE (type));
|
{
|
{
|
tree arg;
|
tree arg;
|
|
|
/* We never want to walk into default arguments. */
|
/* We never want to walk into default arguments. */
|
for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
|
for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
|
WALK_SUBTREE (TREE_VALUE (arg));
|
WALK_SUBTREE (TREE_VALUE (arg));
|
}
|
}
|
break;
|
break;
|
|
|
case ARRAY_TYPE:
|
case ARRAY_TYPE:
|
/* Don't follow this nodes's type if a pointer for fear that
|
/* Don't follow this nodes's type if a pointer for fear that
|
we'll have infinite recursion. If we have a PSET, then we
|
we'll have infinite recursion. If we have a PSET, then we
|
need not fear. */
|
need not fear. */
|
if (pset
|
if (pset
|
|| (!POINTER_TYPE_P (TREE_TYPE (type))
|
|| (!POINTER_TYPE_P (TREE_TYPE (type))
|
&& TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
|
&& TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
|
WALK_SUBTREE (TREE_TYPE (type));
|
WALK_SUBTREE (TREE_TYPE (type));
|
WALK_SUBTREE (TYPE_DOMAIN (type));
|
WALK_SUBTREE (TYPE_DOMAIN (type));
|
break;
|
break;
|
|
|
case BOOLEAN_TYPE:
|
case BOOLEAN_TYPE:
|
case ENUMERAL_TYPE:
|
case ENUMERAL_TYPE:
|
case INTEGER_TYPE:
|
case INTEGER_TYPE:
|
case REAL_TYPE:
|
case REAL_TYPE:
|
WALK_SUBTREE (TYPE_MIN_VALUE (type));
|
WALK_SUBTREE (TYPE_MIN_VALUE (type));
|
WALK_SUBTREE (TYPE_MAX_VALUE (type));
|
WALK_SUBTREE (TYPE_MAX_VALUE (type));
|
break;
|
break;
|
|
|
case OFFSET_TYPE:
|
case OFFSET_TYPE:
|
WALK_SUBTREE (TREE_TYPE (type));
|
WALK_SUBTREE (TREE_TYPE (type));
|
WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
|
WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
|
break;
|
break;
|
|
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
/* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
|
/* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
|
called with the DATA and the address of each sub-tree. If FUNC returns a
|
called with the DATA and the address of each sub-tree. If FUNC returns a
|
non-NULL value, the traversal is stopped, and the value returned by FUNC
|
non-NULL value, the traversal is stopped, and the value returned by FUNC
|
is returned. If PSET is non-NULL it is used to record the nodes visited,
|
is returned. If PSET is non-NULL it is used to record the nodes visited,
|
and to avoid visiting a node more than once. */
|
and to avoid visiting a node more than once. */
|
|
|
tree
|
tree
|
walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset)
|
walk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset)
|
{
|
{
|
enum tree_code code;
|
enum tree_code code;
|
int walk_subtrees;
|
int walk_subtrees;
|
tree result;
|
tree result;
|
|
|
#define WALK_SUBTREE_TAIL(NODE) \
|
#define WALK_SUBTREE_TAIL(NODE) \
|
do \
|
do \
|
{ \
|
{ \
|
tp = & (NODE); \
|
tp = & (NODE); \
|
goto tail_recurse; \
|
goto tail_recurse; \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
tail_recurse:
|
tail_recurse:
|
/* Skip empty subtrees. */
|
/* Skip empty subtrees. */
|
if (!*tp)
|
if (!*tp)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Don't walk the same tree twice, if the user has requested
|
/* Don't walk the same tree twice, if the user has requested
|
that we avoid doing so. */
|
that we avoid doing so. */
|
if (pset && pointer_set_insert (pset, *tp))
|
if (pset && pointer_set_insert (pset, *tp))
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
/* Call the function. */
|
/* Call the function. */
|
walk_subtrees = 1;
|
walk_subtrees = 1;
|
result = (*func) (tp, &walk_subtrees, data);
|
result = (*func) (tp, &walk_subtrees, data);
|
|
|
/* If we found something, return it. */
|
/* If we found something, return it. */
|
if (result)
|
if (result)
|
return result;
|
return result;
|
|
|
code = TREE_CODE (*tp);
|
code = TREE_CODE (*tp);
|
|
|
/* Even if we didn't, FUNC may have decided that there was nothing
|
/* Even if we didn't, FUNC may have decided that there was nothing
|
interesting below this point in the tree. */
|
interesting below this point in the tree. */
|
if (!walk_subtrees)
|
if (!walk_subtrees)
|
{
|
{
|
/* But we still need to check our siblings. */
|
/* But we still need to check our siblings. */
|
if (code == TREE_LIST)
|
if (code == TREE_LIST)
|
WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
|
WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
|
else if (code == OMP_CLAUSE)
|
else if (code == OMP_CLAUSE)
|
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
|
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
|
else
|
else
|
return NULL_TREE;
|
return NULL_TREE;
|
}
|
}
|
|
|
result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func,
|
result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func,
|
data, pset);
|
data, pset);
|
if (result || ! walk_subtrees)
|
if (result || ! walk_subtrees)
|
return result;
|
return result;
|
|
|
switch (code)
|
switch (code)
|
{
|
{
|
case ERROR_MARK:
|
case ERROR_MARK:
|
case IDENTIFIER_NODE:
|
case IDENTIFIER_NODE:
|
case INTEGER_CST:
|
case INTEGER_CST:
|
case REAL_CST:
|
case REAL_CST:
|
case VECTOR_CST:
|
case VECTOR_CST:
|
case STRING_CST:
|
case STRING_CST:
|
case BLOCK:
|
case BLOCK:
|
case PLACEHOLDER_EXPR:
|
case PLACEHOLDER_EXPR:
|
case SSA_NAME:
|
case SSA_NAME:
|
case FIELD_DECL:
|
case FIELD_DECL:
|
case RESULT_DECL:
|
case RESULT_DECL:
|
/* None of these have subtrees other than those already walked
|
/* None of these have subtrees other than those already walked
|
above. */
|
above. */
|
break;
|
break;
|
|
|
case TREE_LIST:
|
case TREE_LIST:
|
WALK_SUBTREE (TREE_VALUE (*tp));
|
WALK_SUBTREE (TREE_VALUE (*tp));
|
WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
|
WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
|
break;
|
break;
|
|
|
case TREE_VEC:
|
case TREE_VEC:
|
{
|
{
|
int len = TREE_VEC_LENGTH (*tp);
|
int len = TREE_VEC_LENGTH (*tp);
|
|
|
if (len == 0)
|
if (len == 0)
|
break;
|
break;
|
|
|
/* Walk all elements but the first. */
|
/* Walk all elements but the first. */
|
while (--len)
|
while (--len)
|
WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
|
WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
|
|
|
/* Now walk the first one as a tail call. */
|
/* Now walk the first one as a tail call. */
|
WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
|
WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
|
}
|
}
|
|
|
case COMPLEX_CST:
|
case COMPLEX_CST:
|
WALK_SUBTREE (TREE_REALPART (*tp));
|
WALK_SUBTREE (TREE_REALPART (*tp));
|
WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
|
WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
|
|
|
case CONSTRUCTOR:
|
case CONSTRUCTOR:
|
{
|
{
|
unsigned HOST_WIDE_INT idx;
|
unsigned HOST_WIDE_INT idx;
|
constructor_elt *ce;
|
constructor_elt *ce;
|
|
|
for (idx = 0;
|
for (idx = 0;
|
VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
|
VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
|
idx++)
|
idx++)
|
WALK_SUBTREE (ce->value);
|
WALK_SUBTREE (ce->value);
|
}
|
}
|
break;
|
break;
|
|
|
case SAVE_EXPR:
|
case SAVE_EXPR:
|
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
|
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
|
|
|
case BIND_EXPR:
|
case BIND_EXPR:
|
{
|
{
|
tree decl;
|
tree decl;
|
for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
|
for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
|
{
|
{
|
/* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
|
/* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
|
into declarations that are just mentioned, rather than
|
into declarations that are just mentioned, rather than
|
declared; they don't really belong to this part of the tree.
|
declared; they don't really belong to this part of the tree.
|
And, we can see cycles: the initializer for a declaration
|
And, we can see cycles: the initializer for a declaration
|
can refer to the declaration itself. */
|
can refer to the declaration itself. */
|
WALK_SUBTREE (DECL_INITIAL (decl));
|
WALK_SUBTREE (DECL_INITIAL (decl));
|
WALK_SUBTREE (DECL_SIZE (decl));
|
WALK_SUBTREE (DECL_SIZE (decl));
|
WALK_SUBTREE (DECL_SIZE_UNIT (decl));
|
WALK_SUBTREE (DECL_SIZE_UNIT (decl));
|
}
|
}
|
WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
|
WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
|
}
|
}
|
|
|
case STATEMENT_LIST:
|
case STATEMENT_LIST:
|
{
|
{
|
tree_stmt_iterator i;
|
tree_stmt_iterator i;
|
for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
|
for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
|
WALK_SUBTREE (*tsi_stmt_ptr (i));
|
WALK_SUBTREE (*tsi_stmt_ptr (i));
|
}
|
}
|
break;
|
break;
|
|
|
case OMP_CLAUSE:
|
case OMP_CLAUSE:
|
switch (OMP_CLAUSE_CODE (*tp))
|
switch (OMP_CLAUSE_CODE (*tp))
|
{
|
{
|
case OMP_CLAUSE_PRIVATE:
|
case OMP_CLAUSE_PRIVATE:
|
case OMP_CLAUSE_SHARED:
|
case OMP_CLAUSE_SHARED:
|
case OMP_CLAUSE_FIRSTPRIVATE:
|
case OMP_CLAUSE_FIRSTPRIVATE:
|
case OMP_CLAUSE_LASTPRIVATE:
|
case OMP_CLAUSE_LASTPRIVATE:
|
case OMP_CLAUSE_COPYIN:
|
case OMP_CLAUSE_COPYIN:
|
case OMP_CLAUSE_COPYPRIVATE:
|
case OMP_CLAUSE_COPYPRIVATE:
|
case OMP_CLAUSE_IF:
|
case OMP_CLAUSE_IF:
|
case OMP_CLAUSE_NUM_THREADS:
|
case OMP_CLAUSE_NUM_THREADS:
|
case OMP_CLAUSE_SCHEDULE:
|
case OMP_CLAUSE_SCHEDULE:
|
WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
|
WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
case OMP_CLAUSE_NOWAIT:
|
case OMP_CLAUSE_NOWAIT:
|
case OMP_CLAUSE_ORDERED:
|
case OMP_CLAUSE_ORDERED:
|
case OMP_CLAUSE_DEFAULT:
|
case OMP_CLAUSE_DEFAULT:
|
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
|
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
|
|
|
case OMP_CLAUSE_REDUCTION:
|
case OMP_CLAUSE_REDUCTION:
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < 4; i++)
|
for (i = 0; i < 4; i++)
|
WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
|
WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
|
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
|
WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
|
}
|
}
|
|
|
default:
|
default:
|
gcc_unreachable ();
|
gcc_unreachable ();
|
}
|
}
|
break;
|
break;
|
|
|
case TARGET_EXPR:
|
case TARGET_EXPR:
|
{
|
{
|
int i, len;
|
int i, len;
|
|
|
/* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
|
/* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
|
But, we only want to walk once. */
|
But, we only want to walk once. */
|
len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
|
len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
|
for (i = 0; i < len; ++i)
|
for (i = 0; i < len; ++i)
|
WALK_SUBTREE (TREE_OPERAND (*tp, i));
|
WALK_SUBTREE (TREE_OPERAND (*tp, i));
|
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
|
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
|
}
|
}
|
|
|
case DECL_EXPR:
|
case DECL_EXPR:
|
/* Walk into various fields of the type that it's defining. We only
|
/* Walk into various fields of the type that it's defining. We only
|
want to walk into these fields of a type in this case. Note that
|
want to walk into these fields of a type in this case. Note that
|
decls get walked as part of the processing of a BIND_EXPR.
|
decls get walked as part of the processing of a BIND_EXPR.
|
|
|
??? Precisely which fields of types that we are supposed to walk in
|
??? Precisely which fields of types that we are supposed to walk in
|
this case vs. the normal case aren't well defined. */
|
this case vs. the normal case aren't well defined. */
|
if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL
|
if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL
|
&& TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp))) != ERROR_MARK)
|
&& TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp))) != ERROR_MARK)
|
{
|
{
|
tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
|
tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
|
|
|
/* Call the function for the type. See if it returns anything or
|
/* Call the function for the type. See if it returns anything or
|
doesn't want us to continue. If we are to continue, walk both
|
doesn't want us to continue. If we are to continue, walk both
|
the normal fields and those for the declaration case. */
|
the normal fields and those for the declaration case. */
|
result = (*func) (type_p, &walk_subtrees, data);
|
result = (*func) (type_p, &walk_subtrees, data);
|
if (result || !walk_subtrees)
|
if (result || !walk_subtrees)
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
result = walk_type_fields (*type_p, func, data, pset);
|
result = walk_type_fields (*type_p, func, data, pset);
|
if (result)
|
if (result)
|
return result;
|
return result;
|
|
|
/* If this is a record type, also walk the fields. */
|
/* If this is a record type, also walk the fields. */
|
if (TREE_CODE (*type_p) == RECORD_TYPE
|
if (TREE_CODE (*type_p) == RECORD_TYPE
|
|| TREE_CODE (*type_p) == UNION_TYPE
|
|| TREE_CODE (*type_p) == UNION_TYPE
|
|| TREE_CODE (*type_p) == QUAL_UNION_TYPE)
|
|| TREE_CODE (*type_p) == QUAL_UNION_TYPE)
|
{
|
{
|
tree field;
|
tree field;
|
|
|
for (field = TYPE_FIELDS (*type_p); field;
|
for (field = TYPE_FIELDS (*type_p); field;
|
field = TREE_CHAIN (field))
|
field = TREE_CHAIN (field))
|
{
|
{
|
/* We'd like to look at the type of the field, but we can
|
/* We'd like to look at the type of the field, but we can
|
easily get infinite recursion. So assume it's pointed
|
easily get infinite recursion. So assume it's pointed
|
to elsewhere in the tree. Also, ignore things that
|
to elsewhere in the tree. Also, ignore things that
|
aren't fields. */
|
aren't fields. */
|
if (TREE_CODE (field) != FIELD_DECL)
|
if (TREE_CODE (field) != FIELD_DECL)
|
continue;
|
continue;
|
|
|
WALK_SUBTREE (DECL_FIELD_OFFSET (field));
|
WALK_SUBTREE (DECL_FIELD_OFFSET (field));
|
WALK_SUBTREE (DECL_SIZE (field));
|
WALK_SUBTREE (DECL_SIZE (field));
|
WALK_SUBTREE (DECL_SIZE_UNIT (field));
|
WALK_SUBTREE (DECL_SIZE_UNIT (field));
|
if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
|
if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
|
WALK_SUBTREE (DECL_QUALIFIER (field));
|
WALK_SUBTREE (DECL_QUALIFIER (field));
|
}
|
}
|
}
|
}
|
|
|
WALK_SUBTREE (TYPE_SIZE (*type_p));
|
WALK_SUBTREE (TYPE_SIZE (*type_p));
|
WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
|
WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
|
}
|
}
|
/* FALLTHRU */
|
/* FALLTHRU */
|
|
|
default:
|
default:
|
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
|
if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
|
{
|
{
|
int i, len;
|
int i, len;
|
|
|
/* Walk over all the sub-trees of this operand. */
|
/* Walk over all the sub-trees of this operand. */
|
len = TREE_CODE_LENGTH (code);
|
len = TREE_CODE_LENGTH (code);
|
|
|
/* Go through the subtrees. We need to do this in forward order so
|
/* Go through the subtrees. We need to do this in forward order so
|
that the scope of a FOR_EXPR is handled properly. */
|
that the scope of a FOR_EXPR is handled properly. */
|
if (len)
|
if (len)
|
{
|
{
|
for (i = 0; i < len - 1; ++i)
|
for (i = 0; i < len - 1; ++i)
|
WALK_SUBTREE (TREE_OPERAND (*tp, i));
|
WALK_SUBTREE (TREE_OPERAND (*tp, i));
|
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
|
WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
|
}
|
}
|
}
|
}
|
|
|
/* If this is a type, walk the needed fields in the type. */
|
/* If this is a type, walk the needed fields in the type. */
|
else if (TYPE_P (*tp))
|
else if (TYPE_P (*tp))
|
return walk_type_fields (*tp, func, data, pset);
|
return walk_type_fields (*tp, func, data, pset);
|
break;
|
break;
|
}
|
}
|
|
|
/* We didn't find what we were looking for. */
|
/* We didn't find what we were looking for. */
|
return NULL_TREE;
|
return NULL_TREE;
|
|
|
#undef WALK_SUBTREE_TAIL
|
#undef WALK_SUBTREE_TAIL
|
}
|
}
|
#undef WALK_SUBTREE
|
#undef WALK_SUBTREE
|
|
|
/* Like walk_tree, but does not walk duplicate nodes more than once. */
|
/* Like walk_tree, but does not walk duplicate nodes more than once. */
|
|
|
tree
|
tree
|
walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
|
walk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data)
|
{
|
{
|
tree result;
|
tree result;
|
struct pointer_set_t *pset;
|
struct pointer_set_t *pset;
|
|
|
pset = pointer_set_create ();
|
pset = pointer_set_create ();
|
result = walk_tree (tp, func, data, pset);
|
result = walk_tree (tp, func, data, pset);
|
pointer_set_destroy (pset);
|
pointer_set_destroy (pset);
|
return result;
|
return result;
|
}
|
}
|
|
|
|
|
/* Return true if STMT is an empty statement or contains nothing but
|
/* Return true if STMT is an empty statement or contains nothing but
|
empty statements. */
|
empty statements. */
|
|
|
bool
|
bool
|
empty_body_p (tree stmt)
|
empty_body_p (tree stmt)
|
{
|
{
|
tree_stmt_iterator i;
|
tree_stmt_iterator i;
|
tree body;
|
tree body;
|
|
|
if (IS_EMPTY_STMT (stmt))
|
if (IS_EMPTY_STMT (stmt))
|
return true;
|
return true;
|
else if (TREE_CODE (stmt) == BIND_EXPR)
|
else if (TREE_CODE (stmt) == BIND_EXPR)
|
body = BIND_EXPR_BODY (stmt);
|
body = BIND_EXPR_BODY (stmt);
|
else if (TREE_CODE (stmt) == STATEMENT_LIST)
|
else if (TREE_CODE (stmt) == STATEMENT_LIST)
|
body = stmt;
|
body = stmt;
|
else
|
else
|
return false;
|
return false;
|
|
|
for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
|
for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i))
|
if (!empty_body_p (tsi_stmt (i)))
|
if (!empty_body_p (tsi_stmt (i)))
|
return false;
|
return false;
|
|
|
return true;
|
return true;
|
}
|
}
|
|
|
#include "gt-tree.h"
|
#include "gt-tree.h"
|
|
|
