Mercurial > hg > CbC > CbC_gcc
diff gcc/tree.c @ 111:04ced10e8804
gcc 7
| author | kono |
|---|---|
| date | Fri, 27 Oct 2017 22:46:09 +0900 |
| parents | f6334be47118 |
| children | ab0bcb71f44d 84e7813d76e9 |
line wrap: on
line diff
--- a/gcc/tree.c Sun Aug 21 07:07:55 2011 +0900 +++ b/gcc/tree.c Fri Oct 27 22:46:09 2017 +0900 @@ -1,7 +1,5 @@ /* Language-independent node constructors for parse phase of GNU compiler. - Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, - 2011 Free Software Foundation, Inc. + Copyright (C) 1987-2017 Free Software Foundation, Inc. This file is part of GCC. @@ -26,40 +24,48 @@ tables index by tree code that describe how to take apart nodes of that code. - It is intended to be language-independent, but occasionally - calls language-dependent routines defined (for C) in typecheck.c. */ + It is intended to be language-independent but can occasionally + calls language-dependent routines. */ #include "config.h" #include "system.h" #include "coretypes.h" -#include "tm.h" -#include "flags.h" +#include "backend.h" +#include "target.h" #include "tree.h" -#include "tm_p.h" -#include "function.h" -#include "obstack.h" -#include "toplev.h" -#include "ggc.h" -#include "hashtab.h" +#include "gimple.h" +#include "tree-pass.h" +#include "ssa.h" +#include "cgraph.h" +#include "diagnostic.h" +#include "flags.h" +#include "alias.h" +#include "fold-const.h" +#include "stor-layout.h" +#include "calls.h" +#include "attribs.h" +#include "toplev.h" /* get_random_seed */ #include "output.h" -#include "target.h" +#include "common/common-target.h" #include "langhooks.h" #include "tree-inline.h" #include "tree-iterator.h" -#include "basic-block.h" -#include "tree-flow.h" +#include "internal-fn.h" +#include "gimple-iterator.h" +#include "gimplify.h" +#include "tree-dfa.h" #include "params.h" -#include "pointer-set.h" -#include "tree-pass.h" #include "langhooks-def.h" -#include "diagnostic.h" #include "tree-diagnostic.h" -#include "tree-pretty-print.h" -#include "cgraph.h" -#include "timevar.h" #include "except.h" -#include "debug.h" -#include "intl.h" +#include "builtins.h" +#include "print-tree.h" +#include "ipa-utils.h" +#include "selftest.h" +#include "stringpool.h" +#include "attribs.h" +#include "rtl.h" +#include "regs.h" /* Tree code classes. */ @@ -92,7 +98,7 @@ #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME, #define END_OF_BASE_TREE_CODES "@dummy", -const char *const tree_code_name[] = { +static const char *const tree_code_name[] = { #include "all-tree.def" }; @@ -120,9 +126,9 @@ /* obstack.[ch] explicitly declined to prototype this. */ extern int _obstack_allocated_p (struct obstack *h, void *obj); -#ifdef GATHER_STATISTICS /* Statistics-gathering stuff. */ +static int tree_code_counts[MAX_TREE_CODES]; int tree_node_counts[(int) all_kinds]; int tree_node_sizes[(int) all_kinds]; @@ -145,12 +151,11 @@ "lang_type kinds", "omp clauses", }; -#endif /* GATHER_STATISTICS */ /* Unique id for next decl created. */ static GTY(()) int next_decl_uid; /* Unique id for next type created. */ -static GTY(()) int next_type_uid = 1; +static GTY(()) unsigned next_type_uid = 1; /* Unique id for next debug decl created. Use negative numbers, to catch erroneous uses. */ static GTY(()) int next_debug_decl_uid; @@ -158,7 +163,7 @@ /* Since we cannot rehash a type after it is in the table, we have to keep the hash code. */ -struct GTY(()) type_hash { +struct GTY((for_user)) type_hash { unsigned long hash; tree type; }; @@ -166,6 +171,18 @@ /* Initial size of the hash table (rounded to next prime). */ #define TYPE_HASH_INITIAL_SIZE 1000 +struct type_cache_hasher : ggc_cache_ptr_hash<type_hash> +{ + static hashval_t hash (type_hash *t) { return t->hash; } + static bool equal (type_hash *a, type_hash *b); + + static int + keep_cache_entry (type_hash *&t) + { + return ggc_marked_p (t->type); + } +}; + /* 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 used for several kinds of types (function types, array types and @@ -173,13 +190,18 @@ same table, they are completely independent, and the hash code is computed differently for each of these. */ -static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash))) - htab_t type_hash_table; +static GTY ((cache)) hash_table<type_cache_hasher> *type_hash_table; /* Hash table and temporary node for larger integer const values. */ static GTY (()) tree int_cst_node; -static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node))) - htab_t int_cst_hash_table; + +struct int_cst_hasher : ggc_cache_ptr_hash<tree_node> +{ + static hashval_t hash (tree t); + static bool equal (tree x, tree y); +}; + +static GTY ((cache)) hash_table<int_cst_hasher> *int_cst_hash_table; /* Hash table for optimization flags and target option flags. Use the same hash table for both sets of options. Nodes for building the current @@ -188,40 +210,56 @@ allocating and freeing up a node repeatably. */ static GTY (()) tree cl_optimization_node; static GTY (()) tree cl_target_option_node; -static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node))) - htab_t cl_option_hash_table; + +struct cl_option_hasher : ggc_cache_ptr_hash<tree_node> +{ + static hashval_t hash (tree t); + static bool equal (tree x, tree y); +}; + +static GTY ((cache)) hash_table<cl_option_hasher> *cl_option_hash_table; /* General tree->tree mapping structure for use in hash tables. */ -static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map))) - htab_t debug_expr_for_decl; - -static GTY ((if_marked ("tree_decl_map_marked_p"), param_is (struct tree_decl_map))) - htab_t value_expr_for_decl; - -static GTY ((if_marked ("tree_priority_map_marked_p"), - param_is (struct tree_priority_map))) - htab_t init_priority_for_decl; +static GTY ((cache)) + hash_table<tree_decl_map_cache_hasher> *debug_expr_for_decl; + +static GTY ((cache)) + hash_table<tree_decl_map_cache_hasher> *value_expr_for_decl; + +struct tree_vec_map_cache_hasher : ggc_cache_ptr_hash<tree_vec_map> +{ + static hashval_t hash (tree_vec_map *m) { return DECL_UID (m->base.from); } + + static bool + equal (tree_vec_map *a, tree_vec_map *b) + { + return a->base.from == b->base.from; + } + + static int + keep_cache_entry (tree_vec_map *&m) + { + return ggc_marked_p (m->base.from); + } +}; + +static GTY ((cache)) + hash_table<tree_vec_map_cache_hasher> *debug_args_for_decl; static void set_type_quals (tree, int); -static int type_hash_eq (const void *, const void *); -static hashval_t type_hash_hash (const void *); -static hashval_t int_cst_hash_hash (const void *); -static int int_cst_hash_eq (const void *, const void *); -static hashval_t cl_option_hash_hash (const void *); -static int cl_option_hash_eq (const void *, const void *); static void print_type_hash_statistics (void); static void print_debug_expr_statistics (void); static void print_value_expr_statistics (void); -static int type_hash_marked_p (const void *); -static unsigned int type_hash_list (const_tree, hashval_t); -static unsigned int attribute_hash_list (const_tree, hashval_t); tree global_trees[TI_MAX]; tree integer_types[itk_none]; -unsigned char tree_contains_struct[MAX_TREE_CODES][64]; +bool int_n_enabled_p[NUM_INT_N_ENTS]; +struct int_n_trees_t int_n_trees [NUM_INT_N_ENTS]; + +bool tree_contains_struct[MAX_TREE_CODES][64]; /* Number of operands for each OpenMP clause. */ unsigned const char omp_clause_num_ops[] = @@ -231,17 +269,69 @@ 1, /* OMP_CLAUSE_SHARED */ 1, /* OMP_CLAUSE_FIRSTPRIVATE */ 2, /* OMP_CLAUSE_LASTPRIVATE */ - 4, /* OMP_CLAUSE_REDUCTION */ + 5, /* OMP_CLAUSE_REDUCTION */ 1, /* OMP_CLAUSE_COPYIN */ 1, /* OMP_CLAUSE_COPYPRIVATE */ + 3, /* OMP_CLAUSE_LINEAR */ + 2, /* OMP_CLAUSE_ALIGNED */ + 1, /* OMP_CLAUSE_DEPEND */ + 1, /* OMP_CLAUSE_UNIFORM */ + 1, /* OMP_CLAUSE_TO_DECLARE */ + 1, /* OMP_CLAUSE_LINK */ + 2, /* OMP_CLAUSE_FROM */ + 2, /* OMP_CLAUSE_TO */ + 2, /* OMP_CLAUSE_MAP */ + 1, /* OMP_CLAUSE_USE_DEVICE_PTR */ + 1, /* OMP_CLAUSE_IS_DEVICE_PTR */ + 2, /* OMP_CLAUSE__CACHE_ */ + 2, /* OMP_CLAUSE_GANG */ + 1, /* OMP_CLAUSE_ASYNC */ + 1, /* OMP_CLAUSE_WAIT */ + 0, /* OMP_CLAUSE_AUTO */ + 0, /* OMP_CLAUSE_SEQ */ + 1, /* OMP_CLAUSE__LOOPTEMP_ */ 1, /* OMP_CLAUSE_IF */ 1, /* OMP_CLAUSE_NUM_THREADS */ 1, /* OMP_CLAUSE_SCHEDULE */ 0, /* OMP_CLAUSE_NOWAIT */ - 0, /* OMP_CLAUSE_ORDERED */ + 1, /* OMP_CLAUSE_ORDERED */ 0, /* OMP_CLAUSE_DEFAULT */ 3, /* OMP_CLAUSE_COLLAPSE */ - 0 /* OMP_CLAUSE_UNTIED */ + 0, /* OMP_CLAUSE_UNTIED */ + 1, /* OMP_CLAUSE_FINAL */ + 0, /* OMP_CLAUSE_MERGEABLE */ + 1, /* OMP_CLAUSE_DEVICE */ + 1, /* OMP_CLAUSE_DIST_SCHEDULE */ + 0, /* OMP_CLAUSE_INBRANCH */ + 0, /* OMP_CLAUSE_NOTINBRANCH */ + 1, /* OMP_CLAUSE_NUM_TEAMS */ + 1, /* OMP_CLAUSE_THREAD_LIMIT */ + 0, /* OMP_CLAUSE_PROC_BIND */ + 1, /* OMP_CLAUSE_SAFELEN */ + 1, /* OMP_CLAUSE_SIMDLEN */ + 0, /* OMP_CLAUSE_FOR */ + 0, /* OMP_CLAUSE_PARALLEL */ + 0, /* OMP_CLAUSE_SECTIONS */ + 0, /* OMP_CLAUSE_TASKGROUP */ + 1, /* OMP_CLAUSE_PRIORITY */ + 1, /* OMP_CLAUSE_GRAINSIZE */ + 1, /* OMP_CLAUSE_NUM_TASKS */ + 0, /* OMP_CLAUSE_NOGROUP */ + 0, /* OMP_CLAUSE_THREADS */ + 0, /* OMP_CLAUSE_SIMD */ + 1, /* OMP_CLAUSE_HINT */ + 0, /* OMP_CLAUSE_DEFALTMAP */ + 1, /* OMP_CLAUSE__SIMDUID_ */ + 0, /* OMP_CLAUSE__SIMT_ */ + 1, /* OMP_CLAUSE__CILK_FOR_COUNT_ */ + 0, /* OMP_CLAUSE_INDEPENDENT */ + 1, /* OMP_CLAUSE_WORKER */ + 1, /* OMP_CLAUSE_VECTOR */ + 1, /* OMP_CLAUSE_NUM_GANGS */ + 1, /* OMP_CLAUSE_NUM_WORKERS */ + 1, /* OMP_CLAUSE_VECTOR_LENGTH */ + 3, /* OMP_CLAUSE_TILE */ + 2, /* OMP_CLAUSE__GRIDDIM_ */ }; const char * const omp_clause_code_name[] = @@ -254,6 +344,24 @@ "reduction", "copyin", "copyprivate", + "linear", + "aligned", + "depend", + "uniform", + "to", + "link", + "from", + "to", + "map", + "use_device_ptr", + "is_device_ptr", + "_cache_", + "gang", + "async", + "wait", + "auto", + "seq", + "_looptemp_", "if", "num_threads", "schedule", @@ -261,7 +369,41 @@ "ordered", "default", "collapse", - "untied" + "untied", + "final", + "mergeable", + "device", + "dist_schedule", + "inbranch", + "notinbranch", + "num_teams", + "thread_limit", + "proc_bind", + "safelen", + "simdlen", + "for", + "parallel", + "sections", + "taskgroup", + "priority", + "grainsize", + "num_tasks", + "nogroup", + "threads", + "simd", + "hint", + "defaultmap", + "_simduid_", + "_simt_", + "_Cilk_for_count_", + "independent", + "worker", + "vector", + "num_gangs", + "num_workers", + "vector_length", + "tile", + "_griddim_" }; @@ -301,7 +443,7 @@ } } case tcc_type: - return TS_TYPE; + return TS_TYPE_NON_COMMON; case tcc_reference: case tcc_comparison: case tcc_unary: @@ -316,6 +458,7 @@ switch (code) { /* tcc_constant cases. */ + case VOID_CST: return TS_TYPED; case INTEGER_CST: return TS_INT_CST; case REAL_CST: return TS_REAL_CST; case FIXED_CST: return TS_FIXED_CST; @@ -351,47 +494,6 @@ { unsigned i; -#define MARK_TS_BASE(C) \ - do { \ - tree_contains_struct[C][TS_BASE] = 1; \ - } while (0) - -#define MARK_TS_COMMON(C) \ - do { \ - MARK_TS_BASE (C); \ - tree_contains_struct[C][TS_COMMON] = 1; \ - } while (0) - -#define MARK_TS_DECL_MINIMAL(C) \ - do { \ - MARK_TS_COMMON (C); \ - tree_contains_struct[C][TS_DECL_MINIMAL] = 1; \ - } while (0) - -#define MARK_TS_DECL_COMMON(C) \ - do { \ - MARK_TS_DECL_MINIMAL (C); \ - tree_contains_struct[C][TS_DECL_COMMON] = 1; \ - } while (0) - -#define MARK_TS_DECL_WRTL(C) \ - do { \ - MARK_TS_DECL_COMMON (C); \ - tree_contains_struct[C][TS_DECL_WRTL] = 1; \ - } while (0) - -#define MARK_TS_DECL_WITH_VIS(C) \ - do { \ - MARK_TS_DECL_WRTL (C); \ - tree_contains_struct[C][TS_DECL_WITH_VIS] = 1; \ - } while (0) - -#define MARK_TS_DECL_NON_COMMON(C) \ - do { \ - MARK_TS_DECL_WITH_VIS (C); \ - tree_contains_struct[C][TS_DECL_NON_COMMON] = 1; \ - } while (0) - for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++) { enum tree_code code; @@ -406,38 +508,51 @@ /* Mark all the structures that TS is derived from. */ switch (ts_code) { - case TS_COMMON: + case TS_TYPED: + case TS_BLOCK: + case TS_OPTIMIZATION: + case TS_TARGET_OPTION: MARK_TS_BASE (code); break; + case TS_COMMON: case TS_INT_CST: case TS_REAL_CST: case TS_FIXED_CST: case TS_VECTOR: case TS_STRING: case TS_COMPLEX: + case TS_SSA_NAME: + case TS_CONSTRUCTOR: + case TS_EXP: + case TS_STATEMENT_LIST: + MARK_TS_TYPED (code); + break; + case TS_IDENTIFIER: case TS_DECL_MINIMAL: - case TS_TYPE: + case TS_TYPE_COMMON: case TS_LIST: case TS_VEC: - case TS_EXP: - case TS_SSA_NAME: - case TS_BLOCK: case TS_BINFO: - case TS_STATEMENT_LIST: - case TS_CONSTRUCTOR: case TS_OMP_CLAUSE: - case TS_OPTIMIZATION: - case TS_TARGET_OPTION: MARK_TS_COMMON (code); break; + case TS_TYPE_WITH_LANG_SPECIFIC: + MARK_TS_TYPE_COMMON (code); + break; + + case TS_TYPE_NON_COMMON: + MARK_TS_TYPE_WITH_LANG_SPECIFIC (code); + break; + case TS_DECL_COMMON: MARK_TS_DECL_MINIMAL (code); break; case TS_DECL_WRTL: + case TS_CONST_DECL: MARK_TS_DECL_COMMON (code); break; @@ -449,7 +564,6 @@ case TS_PARM_DECL: case TS_LABEL_DECL: case TS_RESULT_DECL: - case TS_CONST_DECL: MARK_TS_DECL_WRTL (code); break; @@ -487,7 +601,6 @@ gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]); gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]); gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]); - gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]); gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]); gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]); gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]); @@ -515,14 +628,8 @@ gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]); gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]); gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]); - -#undef MARK_TS_BASE -#undef MARK_TS_COMMON -#undef MARK_TS_DECL_MINIMAL -#undef MARK_TS_DECL_COMMON -#undef MARK_TS_DECL_WRTL -#undef MARK_TS_DECL_WITH_VIS -#undef MARK_TS_DECL_NON_COMMON + gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]); + gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]); } @@ -532,24 +639,20 @@ init_ttree (void) { /* Initialize the hash table of types. */ - type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash, - type_hash_eq, 0); - - debug_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash, - tree_decl_map_eq, 0); - - value_expr_for_decl = htab_create_ggc (512, tree_decl_map_hash, - tree_decl_map_eq, 0); - init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash, - tree_priority_map_eq, 0); - - int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash, - int_cst_hash_eq, NULL); - - int_cst_node = make_node (INTEGER_CST); - - cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash, - cl_option_hash_eq, NULL); + type_hash_table + = hash_table<type_cache_hasher>::create_ggc (TYPE_HASH_INITIAL_SIZE); + + debug_expr_for_decl + = hash_table<tree_decl_map_cache_hasher>::create_ggc (512); + + value_expr_for_decl + = hash_table<tree_decl_map_cache_hasher>::create_ggc (512); + + int_cst_hash_table = hash_table<int_cst_hasher>::create_ggc (1024); + + int_cst_node = make_int_cst (1, 1); + + cl_option_hash_table = hash_table<cl_option_hasher>::create_ggc (64); cl_optimization_node = make_node (OPTIMIZATION_NODE); cl_target_option_node = make_node (TARGET_OPTION_NODE); @@ -568,122 +671,145 @@ { if (!DECL_ASSEMBLER_NAME_SET_P (decl)) lang_hooks.set_decl_assembler_name (decl); - return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name; -} - -/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL. */ - -bool -decl_assembler_name_equal (tree decl, const_tree asmname) -{ - tree decl_asmname = DECL_ASSEMBLER_NAME (decl); - const char *decl_str; - const char *asmname_str; - bool test = false; - - if (decl_asmname == asmname) - return true; - - decl_str = IDENTIFIER_POINTER (decl_asmname); - asmname_str = IDENTIFIER_POINTER (asmname); - - - /* If the target assembler name was set by the user, things are trickier. - We have a leading '*' to begin with. After that, it's arguable what - is the correct thing to do with -fleading-underscore. Arguably, we've - historically been doing the wrong thing in assemble_alias by always - printing the leading underscore. Since we're not changing that, make - sure user_label_prefix follows the '*' before matching. */ - if (decl_str[0] == '*') - { - size_t ulp_len = strlen (user_label_prefix); - - decl_str ++; - - if (ulp_len == 0) - test = true; - else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0) - decl_str += ulp_len, test=true; - else - decl_str --; - } - if (asmname_str[0] == '*') - { - size_t ulp_len = strlen (user_label_prefix); - - asmname_str ++; - - if (ulp_len == 0) - test = true; - else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0) - asmname_str += ulp_len, test=true; - else - asmname_str --; - } - - if (!test) - return false; - return strcmp (decl_str, asmname_str) == 0; -} - -/* Hash asmnames ignoring the user specified marks. */ - -hashval_t -decl_assembler_name_hash (const_tree asmname) -{ - if (IDENTIFIER_POINTER (asmname)[0] == '*') - { - const char *decl_str = IDENTIFIER_POINTER (asmname) + 1; - size_t ulp_len = strlen (user_label_prefix); - - if (ulp_len == 0) - ; - else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0) - decl_str += ulp_len; - - return htab_hash_string (decl_str); - } - - return htab_hash_string (IDENTIFIER_POINTER (asmname)); + return DECL_ASSEMBLER_NAME_RAW (decl); +} + +/* When the target supports COMDAT groups, this indicates which group the + DECL is associated with. This can be either an IDENTIFIER_NODE or a + decl, in which case its DECL_ASSEMBLER_NAME identifies the group. */ +tree +decl_comdat_group (const_tree node) +{ + struct symtab_node *snode = symtab_node::get (node); + if (!snode) + return NULL; + return snode->get_comdat_group (); +} + +/* Likewise, but make sure it's been reduced to an IDENTIFIER_NODE. */ +tree +decl_comdat_group_id (const_tree node) +{ + struct symtab_node *snode = symtab_node::get (node); + if (!snode) + return NULL; + return snode->get_comdat_group_id (); +} + +/* When the target supports named section, return its name as IDENTIFIER_NODE + or NULL if it is in no section. */ +const char * +decl_section_name (const_tree node) +{ + struct symtab_node *snode = symtab_node::get (node); + if (!snode) + return NULL; + return snode->get_section (); +} + +/* Set section name of NODE to VALUE (that is expected to be + identifier node) */ +void +set_decl_section_name (tree node, const char *value) +{ + struct symtab_node *snode; + + if (value == NULL) + { + snode = symtab_node::get (node); + if (!snode) + return; + } + else if (VAR_P (node)) + snode = varpool_node::get_create (node); + else + snode = cgraph_node::get_create (node); + snode->set_section (value); +} + +/* Return TLS model of a variable NODE. */ +enum tls_model +decl_tls_model (const_tree node) +{ + struct varpool_node *snode = varpool_node::get (node); + if (!snode) + return TLS_MODEL_NONE; + return snode->tls_model; +} + +/* Set TLS model of variable NODE to MODEL. */ +void +set_decl_tls_model (tree node, enum tls_model model) +{ + struct varpool_node *vnode; + + if (model == TLS_MODEL_NONE) + { + vnode = varpool_node::get (node); + if (!vnode) + return; + } + else + vnode = varpool_node::get_create (node); + vnode->tls_model = model; } /* Compute the number of bytes occupied by a tree with code CODE. This function cannot be used for nodes that have variable sizes, - including TREE_VEC, STRING_CST, and CALL_EXPR. */ + including TREE_VEC, INTEGER_CST, STRING_CST, and CALL_EXPR. */ size_t tree_code_size (enum tree_code code) { switch (TREE_CODE_CLASS (code)) { case tcc_declaration: /* A decl node */ - { - switch (code) - { - case FIELD_DECL: - return sizeof (struct tree_field_decl); - case PARM_DECL: - return sizeof (struct tree_parm_decl); - case VAR_DECL: - return sizeof (struct tree_var_decl); - case LABEL_DECL: - return sizeof (struct tree_label_decl); - case RESULT_DECL: - return sizeof (struct tree_result_decl); - case CONST_DECL: - return sizeof (struct tree_const_decl); - case TYPE_DECL: - return sizeof (struct tree_type_decl); - case FUNCTION_DECL: - return sizeof (struct tree_function_decl); - case DEBUG_EXPR_DECL: - return sizeof (struct tree_decl_with_rtl); - default: - return sizeof (struct tree_decl_non_common); - } - } + switch (code) + { + case FIELD_DECL: return sizeof (tree_field_decl); + case PARM_DECL: return sizeof (tree_parm_decl); + case VAR_DECL: return sizeof (tree_var_decl); + case LABEL_DECL: return sizeof (tree_label_decl); + case RESULT_DECL: return sizeof (tree_result_decl); + case CONST_DECL: return sizeof (tree_const_decl); + case TYPE_DECL: return sizeof (tree_type_decl); + case FUNCTION_DECL: return sizeof (tree_function_decl); + case DEBUG_EXPR_DECL: return sizeof (tree_decl_with_rtl); + case TRANSLATION_UNIT_DECL: return sizeof (tree_translation_unit_decl); + case NAMESPACE_DECL: + case IMPORTED_DECL: + case NAMELIST_DECL: return sizeof (tree_decl_non_common); + default: + gcc_checking_assert (code >= NUM_TREE_CODES); + return lang_hooks.tree_size (code); + } case tcc_type: /* a type node */ - return sizeof (struct tree_type); + switch (code) + { + case OFFSET_TYPE: + case ENUMERAL_TYPE: + case BOOLEAN_TYPE: + case INTEGER_TYPE: + case REAL_TYPE: + case POINTER_TYPE: + case REFERENCE_TYPE: + case NULLPTR_TYPE: + case FIXED_POINT_TYPE: + case COMPLEX_TYPE: + case VECTOR_TYPE: + case ARRAY_TYPE: + case RECORD_TYPE: + case UNION_TYPE: + case QUAL_UNION_TYPE: + case VOID_TYPE: + case POINTER_BOUNDS_TYPE: + case FUNCTION_TYPE: + case METHOD_TYPE: + case LANG_TYPE: return sizeof (tree_type_non_common); + default: + gcc_checking_assert (code >= NUM_TREE_CODES); + return lang_hooks.tree_size (code); + } case tcc_reference: /* a reference */ case tcc_expression: /* an expression */ @@ -697,13 +823,15 @@ case tcc_constant: /* a constant */ switch (code) { - case INTEGER_CST: return sizeof (struct tree_int_cst); - case REAL_CST: return sizeof (struct tree_real_cst); - case FIXED_CST: return sizeof (struct tree_fixed_cst); - case COMPLEX_CST: return sizeof (struct tree_complex); - case VECTOR_CST: return sizeof (struct tree_vector); + case VOID_CST: return sizeof (tree_typed); + case INTEGER_CST: gcc_unreachable (); + case REAL_CST: return sizeof (tree_real_cst); + case FIXED_CST: return sizeof (tree_fixed_cst); + case COMPLEX_CST: return sizeof (tree_complex); + case VECTOR_CST: return sizeof (tree_vector); case STRING_CST: gcc_unreachable (); default: + gcc_checking_assert (code >= NUM_TREE_CODES); return lang_hooks.tree_size (code); } @@ -711,23 +839,24 @@ switch (code) { case IDENTIFIER_NODE: return lang_hooks.identifier_size; - case TREE_LIST: return sizeof (struct tree_list); + case TREE_LIST: return sizeof (tree_list); case ERROR_MARK: - case PLACEHOLDER_EXPR: return sizeof (struct tree_common); - - case TREE_VEC: + case PLACEHOLDER_EXPR: return sizeof (tree_common); + + case TREE_VEC: gcc_unreachable (); case OMP_CLAUSE: gcc_unreachable (); - case SSA_NAME: return sizeof (struct tree_ssa_name); - - case STATEMENT_LIST: return sizeof (struct tree_statement_list); + case SSA_NAME: return sizeof (tree_ssa_name); + + case STATEMENT_LIST: return sizeof (tree_statement_list); case BLOCK: return sizeof (struct tree_block); - case CONSTRUCTOR: return sizeof (struct tree_constructor); - case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option); - case TARGET_OPTION_NODE: return sizeof (struct tree_target_option); + case CONSTRUCTOR: return sizeof (tree_constructor); + case OPTIMIZATION_NODE: return sizeof (tree_optimization_option); + case TARGET_OPTION_NODE: return sizeof (tree_target_option); default: + gcc_checking_assert (code >= NUM_TREE_CODES); return lang_hooks.tree_size (code); } @@ -744,14 +873,23 @@ const enum tree_code code = TREE_CODE (node); switch (code) { + case INTEGER_CST: + return (sizeof (struct tree_int_cst) + + (TREE_INT_CST_EXT_NUNITS (node) - 1) * sizeof (HOST_WIDE_INT)); + case TREE_BINFO: return (offsetof (struct tree_binfo, base_binfos) - + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node))); + + vec<tree, va_gc> + ::embedded_size (BINFO_N_BASE_BINFOS (node))); case TREE_VEC: return (sizeof (struct tree_vec) + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree)); + case VECTOR_CST: + return (sizeof (struct tree_vector) + + (VECTOR_CST_NELTS (node) - 1) * sizeof (tree)); + case STRING_CST: return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1; @@ -769,22 +907,19 @@ } } -/* Return a newly allocated node of code CODE. For decl and type - nodes, some other fields are initialized. The rest of the node is - initialized to zero. This function cannot be used for TREE_VEC or - OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size. - - Achoo! I got a code in the node. */ - -tree -make_node_stat (enum tree_code code MEM_STAT_DECL) -{ - tree t; +/* Record interesting allocation statistics for a tree node with CODE + and LENGTH. */ + +static void +record_node_allocation_statistics (enum tree_code code ATTRIBUTE_UNUSED, + size_t length ATTRIBUTE_UNUSED) +{ enum tree_code_class type = TREE_CODE_CLASS (code); - size_t length = tree_code_size (code); -#ifdef GATHER_STATISTICS tree_node_kind kind; + if (!GATHER_STATISTICS) + return; + switch (type) { case tcc_declaration: /* A decl node */ @@ -841,23 +976,55 @@ kind = constr_kind; break; + case OMP_CLAUSE: + kind = omp_clause_kind; + break; + default: kind = x_kind; break; } break; + case tcc_vl_exp: + kind = e_kind; + break; + default: gcc_unreachable (); } + tree_code_counts[(int) code]++; tree_node_counts[(int) kind]++; tree_node_sizes[(int) kind] += length; -#endif - - t = ggc_alloc_zone_cleared_tree_node_stat ( - (code == IDENTIFIER_NODE) ? &tree_id_zone : &tree_zone, - length PASS_MEM_STAT); +} + +/* Allocate and return a new UID from the DECL_UID namespace. */ + +int +allocate_decl_uid (void) +{ + return next_decl_uid++; +} + +/* Return a newly allocated node of code CODE. For decl and type + nodes, some other fields are initialized. The rest of the node is + initialized to zero. This function cannot be used for TREE_VEC, + INTEGER_CST or OMP_CLAUSE nodes, which is enforced by asserts in + tree_code_size. + + Achoo! I got a code in the node. */ + +tree +make_node (enum tree_code code MEM_STAT_DECL) +{ + tree t; + enum tree_code_class type = TREE_CODE_CLASS (code); + size_t length = tree_code_size (code); + + record_node_allocation_statistics (code, length); + + t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT); TREE_SET_CODE (t, code); switch (type) @@ -871,18 +1038,18 @@ { if (code == FUNCTION_DECL) { - DECL_ALIGN (t) = FUNCTION_BOUNDARY; - DECL_MODE (t) = FUNCTION_MODE; + SET_DECL_ALIGN (t, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY)); + SET_DECL_MODE (t, FUNCTION_MODE); } else - DECL_ALIGN (t) = 1; + SET_DECL_ALIGN (t, 1); } DECL_SOURCE_LOCATION (t) = input_location; if (TREE_CODE (t) == DEBUG_EXPR_DECL) DECL_UID (t) = --next_debug_decl_uid; else { - DECL_UID (t) = next_decl_uid++; + DECL_UID (t) = allocate_decl_uid (); SET_DECL_PT_UID (t, -1); } if (TREE_CODE (t) == LABEL_DECL) @@ -892,7 +1059,7 @@ case tcc_type: TYPE_UID (t) = next_type_uid++; - TYPE_ALIGN (t) = BITS_PER_UNIT; + SET_TYPE_ALIGN (t, BITS_PER_UNIT); TYPE_USER_ALIGN (t) = 0; TYPE_MAIN_VARIANT (t) = t; TYPE_CANONICAL (t) = t; @@ -929,6 +1096,24 @@ } break; + case tcc_exceptional: + switch (code) + { + case TARGET_OPTION_NODE: + TREE_TARGET_OPTION(t) + = ggc_cleared_alloc<struct cl_target_option> (); + break; + + case OPTIMIZATION_NODE: + TREE_OPTIMIZATION (t) + = ggc_cleared_alloc<struct cl_optimization> (); + break; + + default: + break; + } + break; + default: /* Other classes need no special treatment. */ break; @@ -936,12 +1121,33 @@ return t; } + +/* Free tree node. */ + +void +free_node (tree node) +{ + enum tree_code code = TREE_CODE (node); + if (GATHER_STATISTICS) + { + tree_code_counts[(int) TREE_CODE (node)]--; + tree_node_counts[(int) t_kind]--; + tree_node_sizes[(int) t_kind] -= tree_size (node); + } + if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) + vec_free (CONSTRUCTOR_ELTS (node)); + else if (code == BLOCK) + vec_free (BLOCK_NONLOCALIZED_VARS (node)); + else if (code == TREE_BINFO) + vec_free (BINFO_BASE_ACCESSES (node)); + ggc_free (node); +} /* Return a new node with the same contents as NODE except that its - TREE_CHAIN is zero and it has a fresh uid. */ - -tree -copy_node_stat (tree node MEM_STAT_DECL) + TREE_CHAIN, if it has one, is zero and it has a fresh uid. */ + +tree +copy_node (tree node MEM_STAT_DECL) { tree t; enum tree_code code = TREE_CODE (node); @@ -950,14 +1156,14 @@ gcc_assert (code != STATEMENT_LIST); length = tree_size (node); - t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT); + record_node_allocation_statistics (code, length); + t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT); memcpy (t, node, length); - TREE_CHAIN (t) = 0; + if (CODE_CONTAINS_STRUCT (code, TS_COMMON)) + TREE_CHAIN (t) = 0; TREE_ASM_WRITTEN (t) = 0; TREE_VISITED (t) = 0; - if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) - *DECL_VAR_ANN_PTR (t) = 0; if (TREE_CODE_CLASS (code) == tcc_declaration) { @@ -965,21 +1171,32 @@ DECL_UID (t) = --next_debug_decl_uid; else { - DECL_UID (t) = next_decl_uid++; + DECL_UID (t) = allocate_decl_uid (); if (DECL_PT_UID_SET_P (node)) SET_DECL_PT_UID (t, DECL_PT_UID (node)); } - if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL) + if ((TREE_CODE (node) == PARM_DECL || VAR_P (node)) && DECL_HAS_VALUE_EXPR_P (node)) { SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node)); DECL_HAS_VALUE_EXPR_P (t) = 1; } - if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node)) + /* DECL_DEBUG_EXPR is copied explicitely by callers. */ + if (VAR_P (node)) + { + DECL_HAS_DEBUG_EXPR_P (t) = 0; + t->decl_with_vis.symtab_node = NULL; + } + if (VAR_P (node) && DECL_HAS_INIT_PRIORITY_P (node)) { SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node)); DECL_HAS_INIT_PRIORITY_P (t) = 1; } + if (TREE_CODE (node) == FUNCTION_DECL) + { + DECL_STRUCT_FUNCTION (t) = NULL; + t->decl_with_vis.symtab_node = NULL; + } } else if (TREE_CODE_CLASS (code) == tcc_type) { @@ -993,12 +1210,24 @@ TYPE_SYMTAB_ADDRESS (t) = 0; /* 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 (t) = NULL_TREE; } } + else if (code == TARGET_OPTION_NODE) + { + TREE_TARGET_OPTION (t) = ggc_alloc<struct cl_target_option>(); + memcpy (TREE_TARGET_OPTION (t), TREE_TARGET_OPTION (node), + sizeof (struct cl_target_option)); + } + else if (code == OPTIMIZATION_NODE) + { + TREE_OPTIMIZATION (t) = ggc_alloc<struct cl_optimization>(); + memcpy (TREE_OPTIMIZATION (t), TREE_OPTIMIZATION (node), + sizeof (struct cl_optimization)); + } return t; } @@ -1027,7 +1256,53 @@ } -/* Create an INT_CST node with a LOW value sign extended. */ +/* Return the value that TREE_INT_CST_EXT_NUNITS should have for an + INTEGER_CST with value CST and type TYPE. */ + +static unsigned int +get_int_cst_ext_nunits (tree type, const wide_int &cst) +{ + gcc_checking_assert (cst.get_precision () == TYPE_PRECISION (type)); + /* We need extra HWIs if CST is an unsigned integer with its + upper bit set. */ + if (TYPE_UNSIGNED (type) && wi::neg_p (cst)) + return cst.get_precision () / HOST_BITS_PER_WIDE_INT + 1; + return cst.get_len (); +} + +/* Return a new INTEGER_CST with value CST and type TYPE. */ + +static tree +build_new_int_cst (tree type, const wide_int &cst) +{ + unsigned int len = cst.get_len (); + unsigned int ext_len = get_int_cst_ext_nunits (type, cst); + tree nt = make_int_cst (len, ext_len); + + if (len < ext_len) + { + --ext_len; + TREE_INT_CST_ELT (nt, ext_len) + = zext_hwi (-1, cst.get_precision () % HOST_BITS_PER_WIDE_INT); + for (unsigned int i = len; i < ext_len; ++i) + TREE_INT_CST_ELT (nt, i) = -1; + } + else if (TYPE_UNSIGNED (type) + && cst.get_precision () < len * HOST_BITS_PER_WIDE_INT) + { + len--; + TREE_INT_CST_ELT (nt, len) + = zext_hwi (cst.elt (len), + cst.get_precision () % HOST_BITS_PER_WIDE_INT); + } + + for (unsigned int i = 0; i < len; i++) + TREE_INT_CST_ELT (nt, i) = cst.elt (i); + TREE_TYPE (nt) = type; + return nt; +} + +/* Create an INT_CST node with a LOW value sign extended to TYPE. */ tree build_int_cst (tree type, HOST_WIDE_INT low) @@ -1036,24 +1311,22 @@ if (!type) type = integer_type_node; - return build_int_cst_wide (type, low, low < 0 ? -1 : 0); -} - -/* 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 - the extra bits outside of the type precision are cleared. Constants - 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. - 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 - precision of the integer constants. */ + return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type))); +} + +tree +build_int_cstu (tree type, unsigned HOST_WIDE_INT cst) +{ + return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type))); +} + +/* Create an INT_CST node with a LOW value sign extended to TYPE. */ tree build_int_cst_type (tree type, HOST_WIDE_INT low) { gcc_assert (type); - - return double_int_to_tree (type, shwi_to_double_int (low)); + return wide_int_to_tree (type, wi::shwi (low, TYPE_PRECISION (type))); } /* Constructs tree in type TYPE from with value given by CST. Signedness @@ -1062,34 +1335,10 @@ tree double_int_to_tree (tree type, double_int cst) { - /* Size types *are* sign extended. */ - bool sign_extended_type = (!TYPE_UNSIGNED (type) - || (TREE_CODE (type) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (type))); - - cst = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type); - - return build_int_cst_wide (type, cst.low, cst.high); -} - -/* Returns true if CST fits into range of TYPE. Signedness of CST is assumed - to be the same as the signedness of TYPE. */ - -bool -double_int_fits_to_tree_p (const_tree type, double_int cst) -{ - /* Size types *are* sign extended. */ - bool sign_extended_type = (!TYPE_UNSIGNED (type) - || (TREE_CODE (type) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (type))); - - double_int ext - = double_int_ext (cst, TYPE_PRECISION (type), !sign_extended_type); - - return double_int_equal_p (cst, ext); -} - -/* We force the double_int CST to the range of the type TYPE by sign or + return wide_int_to_tree (type, widest_int::from (cst, TYPE_SIGN (type))); +} + +/* We force the wide_int CST to the range of the type TYPE by sign or zero extending it. OVERFLOWABLE indicates if we are interested in overflow of the value, when >0 we are only interested in signed overflow, for <0 we are interested in any overflow. OVERFLOWED @@ -1100,92 +1349,247 @@ OVERFLOWED is nonzero, or OVERFLOWABLE is >0 and signed overflow occurs or OVERFLOWABLE is <0 and any overflow occurs - We return a new tree node for the extended double_int. The node + We return a new tree node for the extended wide_int. The node is shared if no overflow flags are set. */ tree -force_fit_type_double (tree type, double_int cst, int overflowable, - bool overflowed) -{ - bool sign_extended_type; - - /* Size types *are* sign extended. */ - sign_extended_type = (!TYPE_UNSIGNED (type) - || (TREE_CODE (type) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (type))); +force_fit_type (tree type, const wide_int_ref &cst, + int overflowable, bool overflowed) +{ + signop sign = TYPE_SIGN (type); /* If we need to set overflow flags, return a new unshared node. */ - if (overflowed || !double_int_fits_to_tree_p(type, cst)) + if (overflowed || !wi::fits_to_tree_p (cst, type)) { if (overflowed || overflowable < 0 - || (overflowable > 0 && sign_extended_type)) - { - tree t = make_node (INTEGER_CST); - TREE_INT_CST (t) = double_int_ext (cst, TYPE_PRECISION (type), - !sign_extended_type); - TREE_TYPE (t) = type; + || (overflowable > 0 && sign == SIGNED)) + { + wide_int tmp = wide_int::from (cst, TYPE_PRECISION (type), sign); + tree t = build_new_int_cst (type, tmp); TREE_OVERFLOW (t) = 1; return t; } } /* Else build a shared node. */ - return double_int_to_tree (type, cst); + return wide_int_to_tree (type, cst); } /* These are the hash table functions for the hash table of INTEGER_CST nodes of a sizetype. */ -/* Return the hash code code X, an INTEGER_CST. */ - -static hashval_t -int_cst_hash_hash (const void *x) -{ - const_tree const t = (const_tree) x; - - return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t) - ^ htab_hash_pointer (TREE_TYPE (t))); +/* Return the hash code X, an INTEGER_CST. */ + +hashval_t +int_cst_hasher::hash (tree x) +{ + const_tree const t = x; + hashval_t code = TYPE_UID (TREE_TYPE (t)); + int i; + + for (i = 0; i < TREE_INT_CST_NUNITS (t); i++) + code = iterative_hash_host_wide_int (TREE_INT_CST_ELT(t, i), code); + + return code; } /* 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. */ -static int -int_cst_hash_eq (const void *x, const void *y) -{ - const_tree const xt = (const_tree) x; - const_tree const yt = (const_tree) y; - - return (TREE_TYPE (xt) == TREE_TYPE (yt) - && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt) - && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt)); -} - -/* Create an INT_CST node of TYPE and value HI:LOW. +bool +int_cst_hasher::equal (tree x, tree y) +{ + const_tree const xt = x; + const_tree const yt = y; + + if (TREE_TYPE (xt) != TREE_TYPE (yt) + || TREE_INT_CST_NUNITS (xt) != TREE_INT_CST_NUNITS (yt) + || TREE_INT_CST_EXT_NUNITS (xt) != TREE_INT_CST_EXT_NUNITS (yt)) + return false; + + for (int i = 0; i < TREE_INT_CST_NUNITS (xt); i++) + if (TREE_INT_CST_ELT (xt, i) != TREE_INT_CST_ELT (yt, i)) + return false; + + return true; +} + +/* Create an INT_CST node of TYPE and value CST. The returned node is always shared. For small integers we use a - per-type vector cache, for larger ones we use a single hash table. */ - -tree -build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi) + per-type vector cache, for larger ones we use a single hash table. + The value is extended from its precision according to the sign of + the type to be a multiple of HOST_BITS_PER_WIDE_INT. This defines + the upper bits and ensures that hashing and value equality based + upon the underlying HOST_WIDE_INTs works without masking. */ + +tree +wide_int_to_tree (tree type, const wide_int_ref &pcst) { tree t; int ix = -1; int limit = 0; gcc_assert (type); + unsigned int prec = TYPE_PRECISION (type); + signop sgn = TYPE_SIGN (type); + + /* Verify that everything is canonical. */ + int l = pcst.get_len (); + if (l > 1) + { + if (pcst.elt (l - 1) == 0) + gcc_checking_assert (pcst.elt (l - 2) < 0); + if (pcst.elt (l - 1) == HOST_WIDE_INT_M1) + gcc_checking_assert (pcst.elt (l - 2) >= 0); + } + + wide_int cst = wide_int::from (pcst, prec, sgn); + unsigned int ext_len = get_int_cst_ext_nunits (type, cst); + + if (ext_len == 1) + { + /* We just need to store a single HOST_WIDE_INT. */ + HOST_WIDE_INT hwi; + if (TYPE_UNSIGNED (type)) + hwi = cst.to_uhwi (); + else + hwi = cst.to_shwi (); + + switch (TREE_CODE (type)) + { + case NULLPTR_TYPE: + gcc_assert (hwi == 0); + /* Fallthru. */ + + case POINTER_TYPE: + case REFERENCE_TYPE: + case POINTER_BOUNDS_TYPE: + /* Cache NULL pointer and zero bounds. */ + if (hwi == 0) + { + limit = 1; + ix = 0; + } + break; + + case BOOLEAN_TYPE: + /* Cache false or true. */ + limit = 2; + if (IN_RANGE (hwi, 0, 1)) + ix = hwi; + break; + + case INTEGER_TYPE: + case OFFSET_TYPE: + if (TYPE_SIGN (type) == UNSIGNED) + { + /* Cache [0, N). */ + limit = INTEGER_SHARE_LIMIT; + if (IN_RANGE (hwi, 0, INTEGER_SHARE_LIMIT - 1)) + ix = hwi; + } + else + { + /* Cache [-1, N). */ + limit = INTEGER_SHARE_LIMIT + 1; + if (IN_RANGE (hwi, -1, INTEGER_SHARE_LIMIT - 1)) + ix = hwi + 1; + } + break; + + case ENUMERAL_TYPE: + break; + + default: + gcc_unreachable (); + } + + if (ix >= 0) + { + /* Look for it in the type's vector of small shared ints. */ + if (!TYPE_CACHED_VALUES_P (type)) + { + TYPE_CACHED_VALUES_P (type) = 1; + TYPE_CACHED_VALUES (type) = make_tree_vec (limit); + } + + t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix); + if (t) + /* Make sure no one is clobbering the shared constant. */ + gcc_checking_assert (TREE_TYPE (t) == type + && TREE_INT_CST_NUNITS (t) == 1 + && TREE_INT_CST_OFFSET_NUNITS (t) == 1 + && TREE_INT_CST_EXT_NUNITS (t) == 1 + && TREE_INT_CST_ELT (t, 0) == hwi); + else + { + /* Create a new shared int. */ + t = build_new_int_cst (type, cst); + TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t; + } + } + else + { + /* Use the cache of larger shared ints, using int_cst_node as + a temporary. */ + + TREE_INT_CST_ELT (int_cst_node, 0) = hwi; + TREE_TYPE (int_cst_node) = type; + + tree *slot = int_cst_hash_table->find_slot (int_cst_node, INSERT); + t = *slot; + if (!t) + { + /* Insert this one into the hash table. */ + t = int_cst_node; + *slot = t; + /* Make a new node for next time round. */ + int_cst_node = make_int_cst (1, 1); + } + } + } + else + { + /* The value either hashes properly or we drop it on the floor + for the gc to take care of. There will not be enough of them + to worry about. */ + + tree nt = build_new_int_cst (type, cst); + tree *slot = int_cst_hash_table->find_slot (nt, INSERT); + t = *slot; + if (!t) + { + /* Insert this one into the hash table. */ + t = nt; + *slot = t; + } + } + + return t; +} + +void +cache_integer_cst (tree t) +{ + tree type = TREE_TYPE (t); + int ix = -1; + int limit = 0; + int prec = TYPE_PRECISION (type); + + gcc_assert (!TREE_OVERFLOW (t)); switch (TREE_CODE (type)) { case NULLPTR_TYPE: - gcc_assert (hi == 0 && low == 0); + gcc_assert (integer_zerop (t)); /* Fallthru. */ case POINTER_TYPE: case REFERENCE_TYPE: /* Cache NULL pointer. */ - if (!hi && !low) + if (integer_zerop (t)) { limit = 1; ix = 0; @@ -1195,8 +1599,8 @@ case BOOLEAN_TYPE: /* Cache false or true. */ limit = 2; - if (!hi && low < 2) - ix = low; + if (wi::ltu_p (wi::to_wide (t), 2)) + ix = TREE_INT_CST_ELT (t, 0); break; case INTEGER_TYPE: @@ -1205,17 +1609,35 @@ { /* Cache 0..N */ limit = INTEGER_SHARE_LIMIT; - if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT) - ix = low; + + /* This is a little hokie, but if the prec is smaller than + what is necessary to hold INTEGER_SHARE_LIMIT, then the + obvious test will not get the correct answer. */ + if (prec < HOST_BITS_PER_WIDE_INT) + { + if (tree_to_uhwi (t) < (unsigned HOST_WIDE_INT) INTEGER_SHARE_LIMIT) + ix = tree_to_uhwi (t); + } + else if (wi::ltu_p (wi::to_wide (t), INTEGER_SHARE_LIMIT)) + ix = tree_to_uhwi (t); } else { /* Cache -1..N */ limit = INTEGER_SHARE_LIMIT + 1; - if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT) - ix = low + 1; - else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1) + + if (integer_minus_onep (t)) ix = 0; + else if (!wi::neg_p (wi::to_wide (t))) + { + if (prec < HOST_BITS_PER_WIDE_INT) + { + if (tree_to_shwi (t) < INTEGER_SHARE_LIMIT) + ix = tree_to_shwi (t) + 1; + } + else if (wi::ltu_p (wi::to_wide (t), INTEGER_SHARE_LIMIT)) + ix = tree_to_shwi (t) + 1; + } } break; @@ -1235,49 +1657,23 @@ TYPE_CACHED_VALUES (type) = make_tree_vec (limit); } - t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix); - if (t) - { - /* Make sure no one is clobbering the shared constant. */ - gcc_assert (TREE_TYPE (t) == type); - gcc_assert (TREE_INT_CST_LOW (t) == low); - gcc_assert (TREE_INT_CST_HIGH (t) == hi); - } - else - { - /* Create a new shared int. */ - t = make_node (INTEGER_CST); - - TREE_INT_CST_LOW (t) = low; - TREE_INT_CST_HIGH (t) = hi; - TREE_TYPE (t) = type; - - TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t; - } + gcc_assert (TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) == NULL_TREE); + TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t; } else { /* Use the cache of larger shared ints. */ - void **slot; - - TREE_INT_CST_LOW (int_cst_node) = low; - TREE_INT_CST_HIGH (int_cst_node) = hi; - TREE_TYPE (int_cst_node) = type; - - slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT); - t = (tree) *slot; - if (!t) - { - /* Insert this one into the hash table. */ - t = int_cst_node; - *slot = t; - /* Make a new node for next time round. */ - int_cst_node = make_node (INTEGER_CST); - } - } - - return t; -} + tree *slot = int_cst_hash_table->find_slot (t, INSERT); + /* If there is already an entry for the number verify it's the + same. */ + if (*slot) + gcc_assert (wi::to_wide (tree (*slot)) == wi::to_wide (t)); + else + /* Otherwise insert this one into the hash table. */ + *slot = t; + } +} + /* Builds an integer constant in TYPE such that lowest BITS bits are ones and the rest are zeros. */ @@ -1285,18 +1681,10 @@ tree build_low_bits_mask (tree type, unsigned bits) { - double_int mask; - gcc_assert (bits <= TYPE_PRECISION (type)); - if (bits == TYPE_PRECISION (type) - && !TYPE_UNSIGNED (type)) - /* Sign extended all-ones mask. */ - mask = double_int_minus_one; - else - mask = double_int_mask (bits); - - return build_int_cst_wide (type, mask.low, mask.high); + return wide_int_to_tree (type, wi::mask (bits, false, + TYPE_PRECISION (type))); } /* Checks that X is integer constant that can be expressed in (unsigned) @@ -1305,35 +1693,48 @@ bool cst_and_fits_in_hwi (const_tree x) { - if (TREE_CODE (x) != INTEGER_CST) - return false; - - if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT) - return false; - - return (TREE_INT_CST_HIGH (x) == 0 - || TREE_INT_CST_HIGH (x) == -1); + return (TREE_CODE (x) == INTEGER_CST + && (tree_fits_shwi_p (x) || tree_fits_uhwi_p (x))); +} + +/* Build a newly constructed VECTOR_CST node of length LEN. */ + +tree +make_vector (unsigned len MEM_STAT_DECL) +{ + tree t; + unsigned length = (len - 1) * sizeof (tree) + sizeof (struct tree_vector); + + record_node_allocation_statistics (VECTOR_CST, length); + + t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT); + + TREE_SET_CODE (t, VECTOR_CST); + TREE_CONSTANT (t) = 1; + VECTOR_CST_NELTS (t) = len; + + return t; } /* Return a new VECTOR_CST node whose type is TYPE and whose values - are in a list pointed to by VALS. */ - -tree -build_vector (tree type, tree vals) -{ - tree v = make_node (VECTOR_CST); + are given by VALS. */ + +tree +build_vector (tree type, vec<tree> vals MEM_STAT_DECL) +{ + unsigned int nelts = vals.length (); + gcc_assert (nelts == TYPE_VECTOR_SUBPARTS (type)); int over = 0; - tree link; unsigned cnt = 0; - - TREE_VECTOR_CST_ELTS (v) = vals; + tree v = make_vector (nelts); TREE_TYPE (v) = type; /* Iterate through elements and check for overflow. */ - for (link = vals; link; link = TREE_CHAIN (link)) - { - tree value = TREE_VALUE (link); - cnt++; + for (cnt = 0; cnt < nelts; ++cnt) + { + tree value = vals[cnt]; + + VECTOR_CST_ELT (v, cnt) = value; /* Don't crash if we get an address constant. */ if (!CONSTANT_CLASS_P (value)) @@ -1342,8 +1743,6 @@ over |= TREE_OVERFLOW (value); } - gcc_assert (cnt == TYPE_VECTOR_SUBPARTS (type)); - TREE_OVERFLOW (v) = over; return v; } @@ -1352,18 +1751,25 @@ are extracted from V, a vector of CONSTRUCTOR_ELT. */ tree -build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v) -{ - tree list = NULL_TREE; +build_vector_from_ctor (tree type, vec<constructor_elt, va_gc> *v) +{ + unsigned int nelts = TYPE_VECTOR_SUBPARTS (type); unsigned HOST_WIDE_INT idx; tree value; + auto_vec<tree, 32> vec (nelts); FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) - list = tree_cons (NULL_TREE, value, list); - for (; idx < TYPE_VECTOR_SUBPARTS (type); ++idx) - list = tree_cons (NULL_TREE, - build_zero_cst (TREE_TYPE (type)), list); - return build_vector (type, nreverse (list)); + { + if (TREE_CODE (value) == VECTOR_CST) + for (unsigned i = 0; i < VECTOR_CST_NELTS (value); ++i) + vec.quick_push (VECTOR_CST_ELT (value, i)); + else + vec.quick_push (value); + } + while (vec.length () < nelts) + vec.quick_push (build_zero_cst (TREE_TYPE (type))); + + return build_vector (type, vec); } /* Build a vector of type VECTYPE where all the elements are SCs. */ @@ -1371,7 +1777,6 @@ build_vector_from_val (tree vectype, tree sc) { int i, nunits = TYPE_VECTOR_SUBPARTS (vectype); - VEC(constructor_elt, gc) *v = NULL; if (sc == error_mark_node) return sc; @@ -1385,37 +1790,83 @@ gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)), TREE_TYPE (vectype))); - v = VEC_alloc (constructor_elt, gc, nunits); - for (i = 0; i < nunits; ++i) - CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc); - if (CONSTANT_CLASS_P (sc)) - return build_vector_from_ctor (vectype, v); - else - return build_constructor (vectype, v); + { + auto_vec<tree, 32> v (nunits); + for (i = 0; i < nunits; ++i) + v.quick_push (sc); + return build_vector (vectype, v); + } + else + { + vec<constructor_elt, va_gc> *v; + vec_alloc (v, nunits); + for (i = 0; i < nunits; ++i) + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, sc); + return build_constructor (vectype, v); + } +} + +/* Something has messed with the elements of CONSTRUCTOR C after it was built; + calculate TREE_CONSTANT and TREE_SIDE_EFFECTS. */ + +void +recompute_constructor_flags (tree c) +{ + unsigned int i; + tree val; + bool constant_p = true; + bool side_effects_p = false; + vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c); + + FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val) + { + /* Mostly ctors will have elts that don't have side-effects, so + the usual case is to scan all the elements. Hence a single + loop for both const and side effects, rather than one loop + each (with early outs). */ + if (!TREE_CONSTANT (val)) + constant_p = false; + if (TREE_SIDE_EFFECTS (val)) + side_effects_p = true; + } + + TREE_SIDE_EFFECTS (c) = side_effects_p; + TREE_CONSTANT (c) = constant_p; +} + +/* Make sure that TREE_CONSTANT and TREE_SIDE_EFFECTS are correct for + CONSTRUCTOR C. */ + +void +verify_constructor_flags (tree c) +{ + unsigned int i; + tree val; + bool constant_p = TREE_CONSTANT (c); + bool side_effects_p = TREE_SIDE_EFFECTS (c); + vec<constructor_elt, va_gc> *vals = CONSTRUCTOR_ELTS (c); + + FOR_EACH_CONSTRUCTOR_VALUE (vals, i, val) + { + if (constant_p && !TREE_CONSTANT (val)) + internal_error ("non-constant element in constant CONSTRUCTOR"); + if (!side_effects_p && TREE_SIDE_EFFECTS (val)) + internal_error ("side-effects element in no-side-effects CONSTRUCTOR"); + } } /* Return a new CONSTRUCTOR node whose type is TYPE and whose values - are in the VEC pointed to by VALS. */ -tree -build_constructor (tree type, VEC(constructor_elt,gc) *vals) + are in the vec pointed to by VALS. */ +tree +build_constructor (tree type, vec<constructor_elt, va_gc> *vals) { tree c = make_node (CONSTRUCTOR); - unsigned int i; - constructor_elt *elt; - bool constant_p = true; TREE_TYPE (c) = type; CONSTRUCTOR_ELTS (c) = vals; - FOR_EACH_VEC_ELT (constructor_elt, vals, i, elt) - if (!TREE_CONSTANT (elt->value)) - { - constant_p = false; - break; - } - - TREE_CONSTANT (c) = constant_p; + recompute_constructor_flags (c); return c; } @@ -1425,13 +1876,11 @@ tree build_constructor_single (tree type, tree index, tree value) { - VEC(constructor_elt,gc) *v; - constructor_elt *elt; - - v = VEC_alloc (constructor_elt, gc, 1); - elt = VEC_quick_push (constructor_elt, v, NULL); - elt->index = index; - elt->value = value; + vec<constructor_elt, va_gc> *v; + constructor_elt elt = {index, value}; + + vec_alloc (v, 1); + v->quick_push (elt); return build_constructor (type, v); } @@ -1443,11 +1892,11 @@ build_constructor_from_list (tree type, tree vals) { tree t; - VEC(constructor_elt,gc) *v = NULL; + vec<constructor_elt, va_gc> *v = NULL; if (vals) { - v = VEC_alloc (constructor_elt, gc, list_length (vals)); + vec_alloc (v, list_length (vals)); for (t = vals; t; t = TREE_CHAIN (t)) CONSTRUCTOR_APPEND_ELT (v, TREE_PURPOSE (t), TREE_VALUE (t)); } @@ -1455,6 +1904,27 @@ return build_constructor (type, v); } +/* Return a new CONSTRUCTOR node whose type is TYPE. NELTS is the number + of elements, provided as index/value pairs. */ + +tree +build_constructor_va (tree type, int nelts, ...) +{ + vec<constructor_elt, va_gc> *v = NULL; + va_list p; + + va_start (p, nelts); + vec_alloc (v, nelts); + while (nelts--) + { + tree index = va_arg (p, tree); + tree value = va_arg (p, tree); + CONSTRUCTOR_APPEND_ELT (v, index, value); + } + va_end (p); + return build_constructor (type, v); +} + /* Return a new FIXED_CST node whose type is TYPE and value is F. */ tree @@ -1464,7 +1934,7 @@ FIXED_VALUE_TYPE *fp; v = make_node (FIXED_CST); - fp = ggc_alloc_fixed_value (); + fp = ggc_alloc<fixed_value> (); memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE)); TREE_TYPE (v) = type; @@ -1485,7 +1955,7 @@ Consider doing it via real_convert now. */ v = make_node (REAL_CST); - dp = ggc_alloc_real_value (); + dp = ggc_alloc<real_value> (); memcpy (dp, &d, sizeof (REAL_VALUE_TYPE)); TREE_TYPE (v) = type; @@ -1494,6 +1964,14 @@ return v; } +/* Like build_real, but first truncate D to the type. */ + +tree +build_real_truncate (tree type, REAL_VALUE_TYPE d) +{ + return build_real (type, real_value_truncate (TYPE_MODE (type), d)); +} + /* Return a new REAL_CST node whose type is TYPE and whose value is the integer value of the INTEGER_CST node I. */ @@ -1506,9 +1984,8 @@ bitwise comparisons to see if two values are the same. */ memset (&d, 0, sizeof d); - real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, - TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i), - TYPE_UNSIGNED (TREE_TYPE (i))); + real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, wi::to_wide (i), + TYPE_SIGN (TREE_TYPE (i))); return d; } @@ -1529,6 +2006,7 @@ /* Return a newly constructed STRING_CST node whose value is the LEN characters at STR. + Note that for a C string literal, LEN should include the trailing NUL. The TREE_TYPE is not initialized. */ tree @@ -1540,14 +2018,11 @@ /* Do not waste bytes provided by padding of struct tree_string. */ length = len + offsetof (struct tree_string, str) + 1; -#ifdef GATHER_STATISTICS - tree_node_counts[(int) c_kind]++; - tree_node_sizes[(int) c_kind] += length; -#endif - - s = ggc_alloc_tree_node (length); - - memset (s, 0, sizeof (struct tree_common)); + record_node_allocation_statistics (STRING_CST, length); + + s = (tree) ggc_internal_alloc (length); + + memset (s, 0, sizeof (struct tree_typed)); TREE_SET_CODE (s, STRING_CST); TREE_CONSTANT (s) = 1; TREE_STRING_LENGTH (s) = len; @@ -1574,6 +2049,36 @@ return t; } +/* Build a complex (inf +- 0i), such as for the result of cproj. + TYPE is the complex tree type of the result. If NEG is true, the + imaginary zero is negative. */ + +tree +build_complex_inf (tree type, bool neg) +{ + REAL_VALUE_TYPE rinf, rzero = dconst0; + + real_inf (&rinf); + rzero.sign = neg; + return build_complex (type, build_real (TREE_TYPE (type), rinf), + build_real (TREE_TYPE (type), rzero)); +} + +/* Return the constant 1 in type TYPE. If TYPE has several elements, each + element is set to 1. In particular, this is 1 + i for complex types. */ + +tree +build_each_one_cst (tree type) +{ + if (TREE_CODE (type) == COMPLEX_TYPE) + { + tree scalar = build_one_cst (TREE_TYPE (type)); + return build_complex (type, scalar, scalar); + } + else + return build_one_cst (type); +} + /* Return a constant of arithmetic type TYPE which is the multiplicative identity of the set TYPE. */ @@ -1593,7 +2098,7 @@ case FIXED_POINT_TYPE: /* We can only generate 1 for accum types. */ gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type))); - return build_fixed (type, FCONST1(TYPE_MODE (type))); + return build_fixed (type, FCONST1 (TYPE_MODE (type))); case VECTOR_TYPE: { @@ -1612,6 +2117,61 @@ } } +/* Return an integer of type TYPE containing all 1's in as much precision as + it contains, or a complex or vector whose subparts are such integers. */ + +tree +build_all_ones_cst (tree type) +{ + if (TREE_CODE (type) == COMPLEX_TYPE) + { + tree scalar = build_all_ones_cst (TREE_TYPE (type)); + return build_complex (type, scalar, scalar); + } + else + return build_minus_one_cst (type); +} + +/* Return a constant of arithmetic type TYPE which is the + opposite of the multiplicative identity of the set TYPE. */ + +tree +build_minus_one_cst (tree type) +{ + switch (TREE_CODE (type)) + { + case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: + case POINTER_TYPE: case REFERENCE_TYPE: + case OFFSET_TYPE: + return build_int_cst (type, -1); + + case REAL_TYPE: + return build_real (type, dconstm1); + + case FIXED_POINT_TYPE: + /* We can only generate 1 for accum types. */ + gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type))); + return build_fixed (type, + fixed_from_double_int (double_int_minus_one, + SCALAR_TYPE_MODE (type))); + + case VECTOR_TYPE: + { + tree scalar = build_minus_one_cst (TREE_TYPE (type)); + + return build_vector_from_val (type, scalar); + } + + case COMPLEX_TYPE: + return build_complex (type, + build_minus_one_cst (TREE_TYPE (type)), + build_zero_cst (TREE_TYPE (type))); + + default: + gcc_unreachable (); + } +} + /* Build 0 constant of type TYPE. This is used by constructor folding and thus the constant should be represented in memory by zero(es). */ @@ -1623,7 +2183,7 @@ { case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: case POINTER_TYPE: case REFERENCE_TYPE: - case OFFSET_TYPE: + case OFFSET_TYPE: case NULLPTR_TYPE: return build_int_cst (type, 0); case REAL_TYPE: @@ -1657,64 +2217,150 @@ /* Build a BINFO with LEN language slots. */ tree -make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL) +make_tree_binfo (unsigned base_binfos MEM_STAT_DECL) { tree t; size_t length = (offsetof (struct tree_binfo, base_binfos) - + VEC_embedded_size (tree, base_binfos)); - -#ifdef GATHER_STATISTICS - tree_node_counts[(int) binfo_kind]++; - tree_node_sizes[(int) binfo_kind] += length; -#endif - - t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT); + + vec<tree, va_gc>::embedded_size (base_binfos)); + + record_node_allocation_statistics (TREE_BINFO, length); + + t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT); memset (t, 0, offsetof (struct tree_binfo, base_binfos)); TREE_SET_CODE (t, TREE_BINFO); - VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos); + BINFO_BASE_BINFOS (t)->embedded_init (base_binfos); + + return t; +} + +/* Create a CASE_LABEL_EXPR tree node and return it. */ + +tree +build_case_label (tree low_value, tree high_value, tree label_decl) +{ + tree t = make_node (CASE_LABEL_EXPR); + + TREE_TYPE (t) = void_type_node; + SET_EXPR_LOCATION (t, DECL_SOURCE_LOCATION (label_decl)); + + CASE_LOW (t) = low_value; + CASE_HIGH (t) = high_value; + CASE_LABEL (t) = label_decl; + CASE_CHAIN (t) = NULL_TREE; return t; } +/* Build a newly constructed INTEGER_CST node. LEN and EXT_LEN are the + values of TREE_INT_CST_NUNITS and TREE_INT_CST_EXT_NUNITS respectively. + The latter determines the length of the HOST_WIDE_INT vector. */ + +tree +make_int_cst (int len, int ext_len MEM_STAT_DECL) +{ + tree t; + int length = ((ext_len - 1) * sizeof (HOST_WIDE_INT) + + sizeof (struct tree_int_cst)); + + gcc_assert (len); + record_node_allocation_statistics (INTEGER_CST, length); + + t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT); + + TREE_SET_CODE (t, INTEGER_CST); + TREE_INT_CST_NUNITS (t) = len; + TREE_INT_CST_EXT_NUNITS (t) = ext_len; + /* to_offset can only be applied to trees that are offset_int-sized + or smaller. EXT_LEN is correct if it fits, otherwise the constant + must be exactly the precision of offset_int and so LEN is correct. */ + if (ext_len <= OFFSET_INT_ELTS) + TREE_INT_CST_OFFSET_NUNITS (t) = ext_len; + else + TREE_INT_CST_OFFSET_NUNITS (t) = len; + + TREE_CONSTANT (t) = 1; + + return t; +} /* Build a newly constructed TREE_VEC node of length LEN. */ tree -make_tree_vec_stat (int len MEM_STAT_DECL) +make_tree_vec (int len MEM_STAT_DECL) { tree t; - int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec); - -#ifdef GATHER_STATISTICS - tree_node_counts[(int) vec_kind]++; - tree_node_sizes[(int) vec_kind] += length; -#endif - - t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT); + size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec); + + record_node_allocation_statistics (TREE_VEC, length); + + t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT); TREE_SET_CODE (t, TREE_VEC); TREE_VEC_LENGTH (t) = len; return t; } + +/* Grow a TREE_VEC node to new length LEN. */ + +tree +grow_tree_vec (tree v, int len MEM_STAT_DECL) +{ + gcc_assert (TREE_CODE (v) == TREE_VEC); + + int oldlen = TREE_VEC_LENGTH (v); + gcc_assert (len > oldlen); + + size_t oldlength = (oldlen - 1) * sizeof (tree) + sizeof (struct tree_vec); + size_t length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec); + + record_node_allocation_statistics (TREE_VEC, length - oldlength); + + v = (tree) ggc_realloc (v, length PASS_MEM_STAT); + + TREE_VEC_LENGTH (v) = len; + + return v; +} +/* Return 1 if EXPR is the constant zero, whether it is integral, float or + fixed, and scalar, complex or vector. */ + +int +zerop (const_tree expr) +{ + return (integer_zerop (expr) + || real_zerop (expr) + || fixed_zerop (expr)); +} + /* Return 1 if EXPR is the integer constant zero or a complex constant of zero. */ int integer_zerop (const_tree expr) { - STRIP_NOPS (expr); - - return ((TREE_CODE (expr) == INTEGER_CST - && TREE_INT_CST_LOW (expr) == 0 - && TREE_INT_CST_HIGH (expr) == 0) - || (TREE_CODE (expr) == COMPLEX_CST - && integer_zerop (TREE_REALPART (expr)) - && integer_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case INTEGER_CST: + return wi::to_wide (expr) == 0; + case COMPLEX_CST: + return (integer_zerop (TREE_REALPART (expr)) + && integer_zerop (TREE_IMAGPART (expr))); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!integer_zerop (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Return 1 if EXPR is the integer constant one or the corresponding @@ -1723,66 +2369,76 @@ int integer_onep (const_tree expr) { - STRIP_NOPS (expr); - - return ((TREE_CODE (expr) == INTEGER_CST - && TREE_INT_CST_LOW (expr) == 1 - && TREE_INT_CST_HIGH (expr) == 0) - || (TREE_CODE (expr) == COMPLEX_CST - && integer_onep (TREE_REALPART (expr)) - && integer_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case INTEGER_CST: + return wi::eq_p (wi::to_widest (expr), 1); + case COMPLEX_CST: + return (integer_onep (TREE_REALPART (expr)) + && integer_zerop (TREE_IMAGPART (expr))); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!integer_onep (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } +} + +/* Return 1 if EXPR is the integer constant one. For complex and vector, + return 1 if every piece is the integer constant one. */ + +int +integer_each_onep (const_tree expr) +{ + if (TREE_CODE (expr) == COMPLEX_CST) + return (integer_onep (TREE_REALPART (expr)) + && integer_onep (TREE_IMAGPART (expr))); + else + return integer_onep (expr); } /* 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, or a complex or vector whose subparts are such integers. */ int integer_all_onesp (const_tree expr) { - int prec; - int uns; - - STRIP_NOPS (expr); - if (TREE_CODE (expr) == COMPLEX_CST && integer_all_onesp (TREE_REALPART (expr)) - && integer_zerop (TREE_IMAGPART (expr))) + && integer_all_onesp (TREE_IMAGPART (expr))) return 1; + else if (TREE_CODE (expr) == VECTOR_CST) + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!integer_all_onesp (VECTOR_CST_ELT (expr, i))) + return 0; + return 1; + } + else if (TREE_CODE (expr) != INTEGER_CST) return 0; - uns = TYPE_UNSIGNED (TREE_TYPE (expr)); - if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0 - && TREE_INT_CST_HIGH (expr) == -1) - return 1; - if (!uns) - return 0; - - /* Note that using TYPE_PRECISION here is wrong. We care about the - actual bits, not the (arbitrary) range of the type. */ - prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))); - if (prec >= HOST_BITS_PER_WIDE_INT) - { - HOST_WIDE_INT high_value; - int shift_amount; - - shift_amount = prec - HOST_BITS_PER_WIDE_INT; - - /* Can not handle precisions greater than twice the host int size. */ - gcc_assert (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 - standard, so we must handle this as a special case. */ - high_value = -1; - else - high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1; - - return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0 - && TREE_INT_CST_HIGH (expr) == high_value); - } + return (wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED) + == wi::to_wide (expr)); +} + +/* Return 1 if EXPR is the integer constant minus one. */ + +int +integer_minus_onep (const_tree expr) +{ + if (TREE_CODE (expr) == COMPLEX_CST) + return (integer_all_onesp (TREE_REALPART (expr)) + && integer_zerop (TREE_IMAGPART (expr))); else - return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1; + return integer_all_onesp (expr); } /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only @@ -1791,11 +2447,6 @@ int integer_pow2p (const_tree expr) { - int prec; - HOST_WIDE_INT high, low; - - STRIP_NOPS (expr); - if (TREE_CODE (expr) == COMPLEX_CST && integer_pow2p (TREE_REALPART (expr)) && integer_zerop (TREE_IMAGPART (expr))) @@ -1804,29 +2455,7 @@ if (TREE_CODE (expr) != INTEGER_CST) return 0; - prec = TYPE_PRECISION (TREE_TYPE (expr)); - high = TREE_INT_CST_HIGH (expr); - low = TREE_INT_CST_LOW (expr); - - /* First clear all bits that are beyond the type's precision in case - we've been sign extended. */ - - if (prec == 2 * HOST_BITS_PER_WIDE_INT) - ; - else if (prec > HOST_BITS_PER_WIDE_INT) - high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); - else - { - high = 0; - if (prec < HOST_BITS_PER_WIDE_INT) - low &= ~((HOST_WIDE_INT) (-1) << prec); - } - - if (high == 0 && low == 0) - return 0; - - return ((high == 0 && (low & (low - 1)) == 0) - || (low == 0 && (high & (high - 1)) == 0)); + return wi::popcount (wi::to_wide (expr)) == 1; } /* Return 1 if EXPR is an integer constant other than zero or a @@ -1835,23 +2464,32 @@ int integer_nonzerop (const_tree expr) { - STRIP_NOPS (expr); - return ((TREE_CODE (expr) == INTEGER_CST - && (TREE_INT_CST_LOW (expr) != 0 - || TREE_INT_CST_HIGH (expr) != 0)) + && wi::to_wide (expr) != 0) || (TREE_CODE (expr) == COMPLEX_CST && (integer_nonzerop (TREE_REALPART (expr)) || integer_nonzerop (TREE_IMAGPART (expr))))); } +/* Return 1 if EXPR is the integer constant one. For vector, + return 1 if every piece is the integer constant minus one + (representing the value TRUE). */ + +int +integer_truep (const_tree expr) +{ + if (TREE_CODE (expr) == VECTOR_CST) + return integer_all_onesp (expr); + return integer_onep (expr); +} + /* Return 1 if EXPR is the fixed-point constant zero. */ int fixed_zerop (const_tree expr) { return (TREE_CODE (expr) == FIXED_CST - && double_int_zero_p (TREE_FIXED_CST (expr).data)); + && TREE_FIXED_CST (expr).data.is_zero ()); } /* Return the power of two represented by a tree node known to be a @@ -1860,34 +2498,10 @@ int tree_log2 (const_tree expr) { - int prec; - HOST_WIDE_INT high, low; - - STRIP_NOPS (expr); - if (TREE_CODE (expr) == COMPLEX_CST) return tree_log2 (TREE_REALPART (expr)); - prec = TYPE_PRECISION (TREE_TYPE (expr)); - high = TREE_INT_CST_HIGH (expr); - low = TREE_INT_CST_LOW (expr); - - /* First clear all bits that are beyond the type's precision in case - we've been sign extended. */ - - if (prec == 2 * HOST_BITS_PER_WIDE_INT) - ; - else if (prec > HOST_BITS_PER_WIDE_INT) - high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); - else - { - high = 0; - if (prec < HOST_BITS_PER_WIDE_INT) - low &= ~((HOST_WIDE_INT) (-1) << prec); - } - - return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high) - : exact_log2 (low)); + return wi::exact_log2 (wi::to_wide (expr)); } /* Similar, but return the largest integer Y such that 2 ** Y is less @@ -1896,35 +2510,121 @@ int tree_floor_log2 (const_tree expr) { - int prec; - HOST_WIDE_INT high, low; - - STRIP_NOPS (expr); - if (TREE_CODE (expr) == COMPLEX_CST) return tree_log2 (TREE_REALPART (expr)); - prec = TYPE_PRECISION (TREE_TYPE (expr)); - high = TREE_INT_CST_HIGH (expr); - low = TREE_INT_CST_LOW (expr); - - /* 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 - since what we are doing is setting it. */ - - if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0) - ; - else if (prec > HOST_BITS_PER_WIDE_INT) - high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); - else - { - high = 0; - if (prec < HOST_BITS_PER_WIDE_INT) - low &= ~((HOST_WIDE_INT) (-1) << prec); - } - - return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high) - : floor_log2 (low)); + return wi::floor_log2 (wi::to_wide (expr)); +} + +/* Return number of known trailing zero bits in EXPR, or, if the value of + EXPR is known to be zero, the precision of it's type. */ + +unsigned int +tree_ctz (const_tree expr) +{ + if (!INTEGRAL_TYPE_P (TREE_TYPE (expr)) + && !POINTER_TYPE_P (TREE_TYPE (expr))) + return 0; + + unsigned int ret1, ret2, prec = TYPE_PRECISION (TREE_TYPE (expr)); + switch (TREE_CODE (expr)) + { + case INTEGER_CST: + ret1 = wi::ctz (wi::to_wide (expr)); + return MIN (ret1, prec); + case SSA_NAME: + ret1 = wi::ctz (get_nonzero_bits (expr)); + return MIN (ret1, prec); + case PLUS_EXPR: + case MINUS_EXPR: + case BIT_IOR_EXPR: + case BIT_XOR_EXPR: + case MIN_EXPR: + case MAX_EXPR: + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + if (ret1 == 0) + return ret1; + ret2 = tree_ctz (TREE_OPERAND (expr, 1)); + return MIN (ret1, ret2); + case POINTER_PLUS_EXPR: + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + ret2 = tree_ctz (TREE_OPERAND (expr, 1)); + /* Second operand is sizetype, which could be in theory + wider than pointer's precision. Make sure we never + return more than prec. */ + ret2 = MIN (ret2, prec); + return MIN (ret1, ret2); + case BIT_AND_EXPR: + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + ret2 = tree_ctz (TREE_OPERAND (expr, 1)); + return MAX (ret1, ret2); + case MULT_EXPR: + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + ret2 = tree_ctz (TREE_OPERAND (expr, 1)); + return MIN (ret1 + ret2, prec); + case LSHIFT_EXPR: + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1)) + && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec)) + { + ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1)); + return MIN (ret1 + ret2, prec); + } + return ret1; + case RSHIFT_EXPR: + if (tree_fits_uhwi_p (TREE_OPERAND (expr, 1)) + && (tree_to_uhwi (TREE_OPERAND (expr, 1)) < prec)) + { + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + ret2 = tree_to_uhwi (TREE_OPERAND (expr, 1)); + if (ret1 > ret2) + return ret1 - ret2; + } + return 0; + case TRUNC_DIV_EXPR: + case CEIL_DIV_EXPR: + case FLOOR_DIV_EXPR: + case ROUND_DIV_EXPR: + case EXACT_DIV_EXPR: + if (TREE_CODE (TREE_OPERAND (expr, 1)) == INTEGER_CST + && tree_int_cst_sgn (TREE_OPERAND (expr, 1)) == 1) + { + int l = tree_log2 (TREE_OPERAND (expr, 1)); + if (l >= 0) + { + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + ret2 = l; + if (ret1 > ret2) + return ret1 - ret2; + } + } + return 0; + CASE_CONVERT: + ret1 = tree_ctz (TREE_OPERAND (expr, 0)); + if (ret1 && ret1 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) + ret1 = prec; + return MIN (ret1, prec); + case SAVE_EXPR: + return tree_ctz (TREE_OPERAND (expr, 0)); + case COND_EXPR: + ret1 = tree_ctz (TREE_OPERAND (expr, 1)); + if (ret1 == 0) + return 0; + ret2 = tree_ctz (TREE_OPERAND (expr, 2)); + return MIN (ret1, ret2); + case COMPOUND_EXPR: + return tree_ctz (TREE_OPERAND (expr, 1)); + case ADDR_EXPR: + ret1 = get_pointer_alignment (CONST_CAST_TREE (expr)); + if (ret1 > BITS_PER_UNIT) + { + ret1 = ctz_hwi (ret1 / BITS_PER_UNIT); + return MIN (ret1, prec); + } + return 0; + default: + return 0; + } } /* Return 1 if EXPR is the real constant zero. Trailing zeroes matter for @@ -1933,14 +2633,25 @@ int real_zerop (const_tree expr) { - STRIP_NOPS (expr); - - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_zerop (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return real_equal (&TREE_REAL_CST (expr), &dconst0) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_zerop (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_zerop (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Return 1 if EXPR is the real constant one in real or complex form. @@ -1950,30 +2661,25 @@ int real_onep (const_tree expr) { - STRIP_NOPS (expr); - - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_onep (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); -} - -/* Return 1 if EXPR is the real constant two. Trailing zeroes matter - for decimal float constants, so don't return 1 for them. */ - -int -real_twop (const_tree expr) -{ - STRIP_NOPS (expr); - - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_twop (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return real_equal (&TREE_REAL_CST (expr), &dconst1) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_onep (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_onep (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Return 1 if EXPR is the real constant minus one. Trailing zeroes @@ -1982,14 +2688,25 @@ int real_minus_onep (const_tree expr) { - STRIP_NOPS (expr); - - return ((TREE_CODE (expr) == REAL_CST - && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1) - && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr))))) - || (TREE_CODE (expr) == COMPLEX_CST - && real_minus_onep (TREE_REALPART (expr)) - && real_zerop (TREE_IMAGPART (expr)))); + switch (TREE_CODE (expr)) + { + case REAL_CST: + return real_equal (&TREE_REAL_CST (expr), &dconstm1) + && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))); + case COMPLEX_CST: + return real_minus_onep (TREE_REALPART (expr)) + && real_zerop (TREE_IMAGPART (expr)); + case VECTOR_CST: + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (expr); ++i) + if (!real_minus_onep (VECTOR_CST_ELT (expr, i))) + return false; + return true; + } + default: + return false; + } } /* Nonzero if EXP is a constant or a cast of a constant. */ @@ -2037,11 +2754,11 @@ /* Return true if ELEM is in V. */ bool -vec_member (const_tree elem, VEC(tree,gc) *v) +vec_member (const_tree elem, vec<tree, va_gc> *v) { unsigned ix; tree t; - FOR_EACH_VEC_ELT (tree, v, ix, t) + FOR_EACH_VEC_SAFE_ELT (v, ix, t) if (elem == t) return true; return false; @@ -2100,21 +2817,6 @@ return len; } -/* Returns the number of FIELD_DECLs in TYPE. */ - -int -fields_length (const_tree type) -{ - tree t = TYPE_FIELDS (type); - int count = 0; - - for (; t; t = DECL_CHAIN (t)) - if (TREE_CODE (t) == FIELD_DECL) - ++count; - - return count; -} - /* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or UNION_TYPE TYPE, or NULL_TREE if none. */ @@ -2191,9 +2893,9 @@ purpose and value fields are PARM and VALUE. */ tree -build_tree_list_stat (tree parm, tree value MEM_STAT_DECL) -{ - tree t = make_node_stat (TREE_LIST PASS_MEM_STAT); +build_tree_list (tree parm, tree value MEM_STAT_DECL) +{ + tree t = make_node (TREE_LIST PASS_MEM_STAT); TREE_PURPOSE (t) = parm; TREE_VALUE (t) = value; return t; @@ -2202,15 +2904,15 @@ /* Build a chain of TREE_LIST nodes from a vector. */ tree -build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL) +build_tree_list_vec (const vec<tree, va_gc> *vec MEM_STAT_DECL) { tree ret = NULL_TREE; tree *pp = &ret; unsigned int i; tree t; - FOR_EACH_VEC_ELT (tree, vec, i, t) - { - *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT); + FOR_EACH_VEC_SAFE_ELT (vec, i, t) + { + *pp = build_tree_list (NULL, t PASS_MEM_STAT); pp = &TREE_CHAIN (*pp); } return ret; @@ -2221,18 +2923,14 @@ and whose TREE_CHAIN is CHAIN. */ tree -tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL) +tree_cons (tree purpose, tree value, tree chain MEM_STAT_DECL) { tree node; - node = ggc_alloc_zone_tree_node_stat (&tree_zone, sizeof (struct tree_list) - PASS_MEM_STAT); + node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT); memset (node, 0, sizeof (struct tree_common)); -#ifdef GATHER_STATISTICS - tree_node_counts[(int) x_kind]++; - tree_node_sizes[(int) x_kind] += sizeof (struct tree_list); -#endif + record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list)); TREE_SET_CODE (node, TREE_LIST); TREE_CHAIN (node) = chain; @@ -2244,15 +2942,16 @@ /* Return the values of the elements of a CONSTRUCTOR as a vector of trees. */ -VEC(tree,gc) * +vec<tree, va_gc> * ctor_to_vec (tree ctor) { - VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor)); + vec<tree, va_gc> *vec; + vec_alloc (vec, CONSTRUCTOR_NELTS (ctor)); unsigned int ix; tree val; FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val) - VEC_quick_push (tree, vec, val); + vec->quick_push (val); return vec; } @@ -2264,7 +2963,7 @@ make_unsigned_type). */ tree -size_in_bytes (const_tree type) +size_in_bytes_loc (location_t loc, const_tree type) { tree t; @@ -2276,7 +2975,7 @@ if (t == 0) { - lang_hooks.types.incomplete_type_error (NULL_TREE, type); + lang_hooks.types.incomplete_type_error (loc, NULL_TREE, type); return size_zero_node; } @@ -2296,14 +2995,11 @@ type = TYPE_MAIN_VARIANT (type); t = TYPE_SIZE_UNIT (type); - if (t == 0 - || TREE_CODE (t) != INTEGER_CST - || TREE_INT_CST_HIGH (t) != 0 - /* If the result would appear negative, it's too big to represent. */ - || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0) + + if (t && tree_fits_uhwi_p (t)) + return TREE_INT_CST_LOW (t); + else return -1; - - return TREE_INT_CST_LOW (t); } /* Return the maximum size of TYPE (in bytes) as a wide integer @@ -2321,8 +3017,8 @@ { size_tree = TYPE_ARRAY_MAX_SIZE (type); - if (size_tree && host_integerp (size_tree, 1)) - size = tree_low_cst (size_tree, 1); + if (size_tree && tree_fits_uhwi_p (size_tree)) + size = tree_to_uhwi (size_tree); } /* If we still haven't been able to get a size, see if the language @@ -2332,24 +3028,12 @@ { size_tree = lang_hooks.types.max_size (type); - if (size_tree && host_integerp (size_tree, 1)) - size = tree_low_cst (size_tree, 1); + if (size_tree && tree_fits_uhwi_p (size_tree)) + size = tree_to_uhwi (size_tree); } return size; } - -/* Returns a tree for the size of EXP in bytes. */ - -tree -tree_expr_size (const_tree exp) -{ - if (DECL_P (exp) - && DECL_SIZE_UNIT (exp) != 0) - return DECL_SIZE_UNIT (exp); - else - return size_in_bytes (TREE_TYPE (exp)); -} /* Return the bit position of FIELD, in bits from the start of the record. This is a tree of type bitsizetype. */ @@ -2360,16 +3044,6 @@ return bit_from_pos (DECL_FIELD_OFFSET (field), DECL_FIELD_BIT_OFFSET (field)); } - -/* 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 - option of returning -1 like int_size_in_byte can. */ - -HOST_WIDE_INT -int_bit_position (const_tree field) -{ - return tree_low_cst (bit_position (field), 0); -} /* Return the byte position of FIELD, in bytes from the start of the record. This is a tree of type sizetype. */ @@ -2388,7 +3062,7 @@ HOST_WIDE_INT int_byte_position (const_tree field) { - return tree_low_cst (byte_position (field), 0); + return tree_to_shwi (byte_position (field)); } /* Return the strictest alignment, in bits, that T is known to have. */ @@ -2453,6 +3127,10 @@ min = TYPE_MIN_VALUE (index_type); max = TYPE_MAX_VALUE (index_type); + /* TYPE_MAX_VALUE may not be set if the array has unknown length. */ + if (!max) + return error_mark_node; + return (integer_zerop (min) ? max : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min)); @@ -2603,8 +3281,6 @@ not handle arithmetic; that's handled in skip_simple_arithmetic and tree_invariant_p). */ -static bool tree_invariant_p (tree t); - static bool tree_invariant_p_1 (tree t) { @@ -2654,7 +3330,7 @@ /* Return true if T is function-invariant. */ -static bool +bool tree_invariant_p (tree t) { tree inner = skip_simple_arithmetic (t); @@ -2686,7 +3362,6 @@ tree save_expr (tree expr) { - tree t = fold (expr); tree inner; /* If the tree evaluates to a constant, then we don't want to hide that @@ -2694,43 +3369,40 @@ However, a read-only object that has side effects cannot be bypassed. Since it is no problem to reevaluate literals, we just return the literal node. */ - inner = skip_simple_arithmetic (t); + inner = skip_simple_arithmetic (expr); if (TREE_CODE (inner) == ERROR_MARK) return inner; if (tree_invariant_p_1 (inner)) - return t; + return expr; /* 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 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 EXPR contains both a PLACEHOLDER_EXPR 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 happen by surrounding any such subexpressions in their own SAVE_EXPR and forcing evaluation at the proper time. */ if (contains_placeholder_p (inner)) - return t; - - t = build1 (SAVE_EXPR, TREE_TYPE (expr), t); - SET_EXPR_LOCATION (t, EXPR_LOCATION (expr)); + return expr; + + expr = build1_loc (EXPR_LOCATION (expr), SAVE_EXPR, TREE_TYPE (expr), expr); /* 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 eliminated as dead. */ - TREE_SIDE_EFFECTS (t) = 1; - return t; -} - -/* Look inside EXPR and into any simple arithmetic operations. Return - the innermost non-arithmetic node. */ + TREE_SIDE_EFFECTS (expr) = 1; + return expr; +} + +/* Look inside EXPR into any simple arithmetic operations. Return the + outermost non-arithmetic or non-invariant node. */ tree skip_simple_arithmetic (tree expr) { - tree inner; - /* We don't care about whether this can be used as an lvalue in this context. */ while (TREE_CODE (expr) == NON_LVALUE_EXPR) @@ -2740,17 +3412,16 @@ 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 computations if they actually occur. */ - inner = expr; - while (1) - { - if (UNARY_CLASS_P (inner)) - inner = TREE_OPERAND (inner, 0); - else if (BINARY_CLASS_P (inner)) - { - if (tree_invariant_p (TREE_OPERAND (inner, 1))) - inner = TREE_OPERAND (inner, 0); - else if (tree_invariant_p (TREE_OPERAND (inner, 0))) - inner = TREE_OPERAND (inner, 1); + while (true) + { + if (UNARY_CLASS_P (expr)) + expr = TREE_OPERAND (expr, 0); + else if (BINARY_CLASS_P (expr)) + { + if (tree_invariant_p (TREE_OPERAND (expr, 1))) + expr = TREE_OPERAND (expr, 0); + else if (tree_invariant_p (TREE_OPERAND (expr, 0))) + expr = TREE_OPERAND (expr, 1); else break; } @@ -2758,9 +3429,37 @@ break; } - return inner; -} - + return expr; +} + +/* Look inside EXPR into simple arithmetic operations involving constants. + Return the outermost non-arithmetic or non-constant node. */ + +tree +skip_simple_constant_arithmetic (tree expr) +{ + while (TREE_CODE (expr) == NON_LVALUE_EXPR) + expr = TREE_OPERAND (expr, 0); + + while (true) + { + if (UNARY_CLASS_P (expr)) + expr = TREE_OPERAND (expr, 0); + else if (BINARY_CLASS_P (expr)) + { + if (TREE_CONSTANT (TREE_OPERAND (expr, 1))) + expr = TREE_OPERAND (expr, 0); + else if (TREE_CONSTANT (TREE_OPERAND (expr, 0))) + expr = TREE_OPERAND (expr, 1); + else + break; + } + else + break; + } + + return expr; +} /* Return which tree structure is used by T. */ @@ -2909,6 +3608,7 @@ switch (TREE_CODE (type)) { case VOID_TYPE: + case POINTER_BOUNDS_TYPE: case COMPLEX_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: @@ -2918,6 +3618,7 @@ case METHOD_TYPE: case FUNCTION_TYPE: case VECTOR_TYPE: + case NULLPTR_TYPE: return false; case INTEGER_TYPE: @@ -2928,9 +3629,10 @@ || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type))); case ARRAY_TYPE: - /* We have already checked the component type above, so just check the - domain type. */ - return type_contains_placeholder_p (TYPE_DOMAIN (type)); + /* We have already checked the component type above, so just check + the domain type. Flexible array members have a null domain. */ + return TYPE_DOMAIN (type) ? + type_contains_placeholder_p (TYPE_DOMAIN (type)) : false; case RECORD_TYPE: case UNION_TYPE: @@ -2982,20 +3684,20 @@ /* Push tree EXP onto vector QUEUE if it is not already present. */ static void -push_without_duplicates (tree exp, VEC (tree, heap) **queue) +push_without_duplicates (tree exp, vec<tree> *queue) { unsigned int i; tree iter; - FOR_EACH_VEC_ELT (tree, *queue, i, iter) + FOR_EACH_VEC_ELT (*queue, i, iter) if (simple_cst_equal (iter, exp) == 1) break; if (!iter) - VEC_safe_push (tree, heap, *queue, exp); -} - -/* Given a tree EXP, find all occurences of references to fields + queue->safe_push (exp); +} + +/* Given a tree EXP, find all occurrences of references to fields in a PLACEHOLDER_EXPR and place them in vector REFS without duplicates. Also record VAR_DECLs and CONST_DECLs. Note that we assume here that EXP contains only arithmetic expressions @@ -3003,7 +3705,7 @@ argument list. */ void -find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs) +find_placeholder_in_expr (tree exp, vec<tree> *refs) { enum tree_code code = TREE_CODE (exp); tree inner; @@ -3048,7 +3750,7 @@ break; } - /* Fall through... */ + /* Fall through. */ case tcc_exceptional: case tcc_unary: @@ -3137,7 +3839,7 @@ if (exp == f) return r; - /* Fall through... */ + /* Fall through. */ case tcc_exceptional: case tcc_unary: @@ -3205,15 +3907,29 @@ new_tree = NULL_TREE; - /* If we are trying to replace F with a constant, inline back + /* If we are trying to replace F with a constant or with another + instance of one of the arguments of the call, inline back functions which do nothing else than computing a value from the arguments they are passed. This makes it possible to fold partially or entirely the replacement expression. */ - if (CONSTANT_CLASS_P (r) && code == CALL_EXPR) + if (code == CALL_EXPR) { - tree t = maybe_inline_call_in_expr (exp); - if (t) - return SUBSTITUTE_IN_EXPR (t, f, r); + bool maybe_inline = false; + if (CONSTANT_CLASS_P (r)) + maybe_inline = true; + else + for (i = 3; i < TREE_OPERAND_LENGTH (exp); i++) + if (operand_equal_p (TREE_OPERAND (exp, i), r, 0)) + { + maybe_inline = true; + break; + } + if (maybe_inline) + { + tree t = maybe_inline_call_in_expr (exp); + if (t) + return SUBSTITUTE_IN_EXPR (t, f, r); + } } for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++) @@ -3422,88 +4138,6 @@ return new_tree; } -/* Stabilize a reference so that we can use it any number of times - without causing its operands to be evaluated more than once. - Returns the stabilized reference. This works by means of save_expr, - so see the caveats in the comments about save_expr. - - Also allows conversion expressions whose operands are references. - Any other kind of expression is returned unchanged. */ - -tree -stabilize_reference (tree ref) -{ - tree result; - enum tree_code code = TREE_CODE (ref); - - switch (code) - { - case VAR_DECL: - case PARM_DECL: - case RESULT_DECL: - /* No action is needed in this case. */ - return ref; - - CASE_CONVERT: - case FLOAT_EXPR: - case FIX_TRUNC_EXPR: - result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0))); - break; - - case INDIRECT_REF: - result = build_nt (INDIRECT_REF, - stabilize_reference_1 (TREE_OPERAND (ref, 0))); - break; - - case COMPONENT_REF: - result = build_nt (COMPONENT_REF, - stabilize_reference (TREE_OPERAND (ref, 0)), - TREE_OPERAND (ref, 1), NULL_TREE); - break; - - case BIT_FIELD_REF: - result = build_nt (BIT_FIELD_REF, - stabilize_reference (TREE_OPERAND (ref, 0)), - stabilize_reference_1 (TREE_OPERAND (ref, 1)), - stabilize_reference_1 (TREE_OPERAND (ref, 2))); - break; - - case ARRAY_REF: - result = build_nt (ARRAY_REF, - stabilize_reference (TREE_OPERAND (ref, 0)), - stabilize_reference_1 (TREE_OPERAND (ref, 1)), - TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); - break; - - case ARRAY_RANGE_REF: - result = build_nt (ARRAY_RANGE_REF, - stabilize_reference (TREE_OPERAND (ref, 0)), - stabilize_reference_1 (TREE_OPERAND (ref, 1)), - TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); - break; - - case COMPOUND_EXPR: - /* We cannot wrap the first expression in a SAVE_EXPR, as then - it wouldn't be ignored. This matters when dealing with - volatiles. */ - return stabilize_reference_1 (ref); - - /* If arg isn't a kind of lvalue we recognize, make no change. - Caller should recognize the error for an invalid lvalue. */ - default: - return ref; - - case ERROR_MARK: - return error_mark_node; - } - - TREE_TYPE (result) = TREE_TYPE (ref); - TREE_READONLY (result) = TREE_READONLY (ref); - TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref); - TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref); - - return result; -} /* Subroutine of stabilize_reference; this is called for subtrees of references. Any expression with side-effects must be put in a SAVE_EXPR @@ -3518,7 +4152,7 @@ operator should be allowed, and that cse should take care of coalescing multiple utterances of the same expression should that prove fruitful. */ -tree +static tree stabilize_reference_1 (tree e) { tree result; @@ -3585,6 +4219,89 @@ return result; } + +/* Stabilize a reference so that we can use it any number of times + without causing its operands to be evaluated more than once. + Returns the stabilized reference. This works by means of save_expr, + so see the caveats in the comments about save_expr. + + Also allows conversion expressions whose operands are references. + Any other kind of expression is returned unchanged. */ + +tree +stabilize_reference (tree ref) +{ + tree result; + enum tree_code code = TREE_CODE (ref); + + switch (code) + { + case VAR_DECL: + case PARM_DECL: + case RESULT_DECL: + /* No action is needed in this case. */ + return ref; + + CASE_CONVERT: + case FLOAT_EXPR: + case FIX_TRUNC_EXPR: + result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0))); + break; + + case INDIRECT_REF: + result = build_nt (INDIRECT_REF, + stabilize_reference_1 (TREE_OPERAND (ref, 0))); + break; + + case COMPONENT_REF: + result = build_nt (COMPONENT_REF, + stabilize_reference (TREE_OPERAND (ref, 0)), + TREE_OPERAND (ref, 1), NULL_TREE); + break; + + case BIT_FIELD_REF: + result = build_nt (BIT_FIELD_REF, + stabilize_reference (TREE_OPERAND (ref, 0)), + TREE_OPERAND (ref, 1), TREE_OPERAND (ref, 2)); + REF_REVERSE_STORAGE_ORDER (result) = REF_REVERSE_STORAGE_ORDER (ref); + break; + + case ARRAY_REF: + result = build_nt (ARRAY_REF, + stabilize_reference (TREE_OPERAND (ref, 0)), + stabilize_reference_1 (TREE_OPERAND (ref, 1)), + TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); + break; + + case ARRAY_RANGE_REF: + result = build_nt (ARRAY_RANGE_REF, + stabilize_reference (TREE_OPERAND (ref, 0)), + stabilize_reference_1 (TREE_OPERAND (ref, 1)), + TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); + break; + + case COMPOUND_EXPR: + /* We cannot wrap the first expression in a SAVE_EXPR, as then + it wouldn't be ignored. This matters when dealing with + volatiles. */ + return stabilize_reference_1 (ref); + + /* If arg isn't a kind of lvalue we recognize, make no change. + Caller should recognize the error for an invalid lvalue. */ + default: + return ref; + + case ERROR_MARK: + return error_mark_node; + } + + TREE_TYPE (result) = TREE_TYPE (ref); + TREE_READONLY (result) = TREE_READONLY (ref); + TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref); + TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref); + + return result; +} /* Low-level constructors for expressions. */ @@ -3597,6 +4314,8 @@ tree node; bool tc = true, se = false; + gcc_assert (TREE_CODE (t) == ADDR_EXPR); + /* 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 any of them involve offsets that are either non-constant or non-invariant. @@ -3635,8 +4354,6 @@ if (TREE_OPERAND (node, 2)) UPDATE_FLAGS (TREE_OPERAND (node, 2)); } - else if (TREE_CODE (node) == BIT_FIELD_REF) - UPDATE_FLAGS (TREE_OPERAND (node, 2)); } node = lang_hooks.expr_to_decl (node, &tc, &se); @@ -3673,48 +4390,29 @@ enough for all extant tree codes. */ tree -build0_stat (enum tree_code code, tree tt MEM_STAT_DECL) +build0 (enum tree_code code, tree tt MEM_STAT_DECL) { tree t; gcc_assert (TREE_CODE_LENGTH (code) == 0); - t = make_node_stat (code PASS_MEM_STAT); + t = make_node (code PASS_MEM_STAT); TREE_TYPE (t) = tt; return t; } tree -build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL) +build1 (enum tree_code code, tree type, tree node MEM_STAT_DECL) { int length = sizeof (struct tree_exp); -#ifdef GATHER_STATISTICS - tree_node_kind kind; -#endif tree t; -#ifdef GATHER_STATISTICS - switch (TREE_CODE_CLASS (code)) - { - case tcc_statement: /* an expression with side effects */ - kind = s_kind; - break; - case tcc_reference: /* a reference */ - kind = r_kind; - break; - default: - kind = e_kind; - break; - } - - tree_node_counts[(int) kind]++; - tree_node_sizes[(int) kind] += length; -#endif + record_node_allocation_statistics (code, length); gcc_assert (TREE_CODE_LENGTH (code) == 1); - t = ggc_alloc_zone_tree_node_stat (&tree_zone, length PASS_MEM_STAT); + t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT); memset (t, 0, sizeof (struct tree_common)); @@ -3723,7 +4421,6 @@ TREE_TYPE (t) = type; SET_EXPR_LOCATION (t, UNKNOWN_LOCATION); TREE_OPERAND (t, 0) = node; - TREE_BLOCK (t) = NULL_TREE; if (node && !TYPE_P (node)) { TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node); @@ -3782,9 +4479,9 @@ } while (0) tree -build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL) -{ - bool constant, read_only, side_effects; +build2 (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL) +{ + bool constant, read_only, side_effects, div_by_zero; tree t; gcc_assert (TREE_CODE_LENGTH (code) == 2); @@ -3800,10 +4497,9 @@ if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt) gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0)) - && INTEGRAL_TYPE_P (TREE_TYPE (arg1)) - && useless_type_conversion_p (sizetype, TREE_TYPE (arg1))); - - t = make_node_stat (code PASS_MEM_STAT); + && ptrofftype_p (TREE_TYPE (arg1))); + + t = make_node (code PASS_MEM_STAT); TREE_TYPE (t) = tt; /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the @@ -3818,23 +4514,53 @@ read_only = 1; side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - - TREE_READONLY (t) = read_only; - TREE_CONSTANT (t) = constant; + switch (code) + { + case TRUNC_DIV_EXPR: + case CEIL_DIV_EXPR: + case FLOOR_DIV_EXPR: + case ROUND_DIV_EXPR: + case EXACT_DIV_EXPR: + case CEIL_MOD_EXPR: + case FLOOR_MOD_EXPR: + case ROUND_MOD_EXPR: + case TRUNC_MOD_EXPR: + div_by_zero = integer_zerop (arg1); + break; + default: + div_by_zero = false; + } + + PROCESS_ARG (0); + PROCESS_ARG (1); + TREE_SIDE_EFFECTS (t) = side_effects; - TREE_THIS_VOLATILE (t) - = (TREE_CODE_CLASS (code) == tcc_reference - && arg0 && TREE_THIS_VOLATILE (arg0)); + if (code == MEM_REF) + { + if (arg0 && TREE_CODE (arg0) == ADDR_EXPR) + { + tree o = TREE_OPERAND (arg0, 0); + TREE_READONLY (t) = TREE_READONLY (o); + TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o); + } + } + else + { + TREE_READONLY (t) = read_only; + /* Don't mark X / 0 as constant. */ + TREE_CONSTANT (t) = constant && !div_by_zero; + TREE_THIS_VOLATILE (t) + = (TREE_CODE_CLASS (code) == tcc_reference + && arg0 && TREE_THIS_VOLATILE (arg0)); + } return t; } tree -build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1, - tree arg2 MEM_STAT_DECL) +build3 (enum tree_code code, tree tt, tree arg0, tree arg1, + tree arg2 MEM_STAT_DECL) { bool constant, read_only, side_effects; tree t; @@ -3842,7 +4568,7 @@ gcc_assert (TREE_CODE_LENGTH (code) == 3); gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp); - t = make_node_stat (code PASS_MEM_STAT); + t = make_node (code PASS_MEM_STAT); TREE_TYPE (t) = tt; read_only = 1; @@ -3858,9 +4584,9 @@ else side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); + PROCESS_ARG (0); + PROCESS_ARG (1); + PROCESS_ARG (2); if (code == COND_EXPR) TREE_READONLY (t) = read_only; @@ -3874,23 +4600,23 @@ } tree -build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1, - tree arg2, tree arg3 MEM_STAT_DECL) +build4 (enum tree_code code, tree tt, tree arg0, tree arg1, + tree arg2, tree arg3 MEM_STAT_DECL) { bool constant, read_only, side_effects; tree t; gcc_assert (TREE_CODE_LENGTH (code) == 4); - t = make_node_stat (code PASS_MEM_STAT); + t = make_node (code PASS_MEM_STAT); TREE_TYPE (t) = tt; side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); - PROCESS_ARG(3); + PROCESS_ARG (0); + PROCESS_ARG (1); + PROCESS_ARG (2); + PROCESS_ARG (3); TREE_SIDE_EFFECTS (t) = side_effects; TREE_THIS_VOLATILE (t) @@ -3901,60 +4627,39 @@ } tree -build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1, - tree arg2, tree arg3, tree arg4 MEM_STAT_DECL) +build5 (enum tree_code code, tree tt, tree arg0, tree arg1, + tree arg2, tree arg3, tree arg4 MEM_STAT_DECL) { bool constant, read_only, side_effects; tree t; gcc_assert (TREE_CODE_LENGTH (code) == 5); - t = make_node_stat (code PASS_MEM_STAT); + t = make_node (code PASS_MEM_STAT); TREE_TYPE (t) = tt; side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); - PROCESS_ARG(3); - PROCESS_ARG(4); + PROCESS_ARG (0); + PROCESS_ARG (1); + PROCESS_ARG (2); + PROCESS_ARG (3); + PROCESS_ARG (4); TREE_SIDE_EFFECTS (t) = side_effects; - TREE_THIS_VOLATILE (t) - = (TREE_CODE_CLASS (code) == tcc_reference - && arg0 && TREE_THIS_VOLATILE (arg0)); - - return t; -} - -tree -build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1, - tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL) -{ - bool constant, read_only, side_effects; - tree t; - - gcc_assert (code == TARGET_MEM_REF); - - t = make_node_stat (code PASS_MEM_STAT); - TREE_TYPE (t) = tt; - - side_effects = TREE_SIDE_EFFECTS (t); - - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); - PROCESS_ARG(3); - PROCESS_ARG(4); if (code == TARGET_MEM_REF) - side_effects = 0; - PROCESS_ARG(5); - - TREE_SIDE_EFFECTS (t) = side_effects; - TREE_THIS_VOLATILE (t) - = (code == TARGET_MEM_REF - && arg5 && TREE_THIS_VOLATILE (arg5)); + { + if (arg0 && TREE_CODE (arg0) == ADDR_EXPR) + { + tree o = TREE_OPERAND (arg0, 0); + TREE_READONLY (t) = TREE_READONLY (o); + TREE_THIS_VOLATILE (t) = TREE_THIS_VOLATILE (o); + } + } + else + TREE_THIS_VOLATILE (t) + = (TREE_CODE_CLASS (code) == tcc_reference + && arg0 && TREE_THIS_VOLATILE (arg0)); return t; } @@ -3987,30 +4692,24 @@ /* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */ -double_int +offset_int mem_ref_offset (const_tree t) { - tree toff = TREE_OPERAND (t, 1); - return double_int_sext (tree_to_double_int (toff), - TYPE_PRECISION (TREE_TYPE (toff))); -} - -/* Return the pointer-type relevant for TBAA purposes from the - gimple memory reference tree T. This is the type to be used for - the offset operand of MEM_REF or TARGET_MEM_REF replacements of T. */ - -tree -reference_alias_ptr_type (const_tree t) -{ - const_tree base = t; - while (handled_component_p (base)) - base = TREE_OPERAND (base, 0); - if (TREE_CODE (base) == MEM_REF) - return TREE_TYPE (TREE_OPERAND (base, 1)); - else if (TREE_CODE (base) == TARGET_MEM_REF) - return TREE_TYPE (TMR_OFFSET (base)); - else - return build_pointer_type (TYPE_MAIN_VARIANT (TREE_TYPE (base))); + return offset_int::from (wi::to_wide (TREE_OPERAND (t, 1)), SIGNED); +} + +/* Return an invariant ADDR_EXPR of type TYPE taking the address of BASE + offsetted by OFFSET units. */ + +tree +build_invariant_address (tree type, tree base, HOST_WIDE_INT offset) +{ + tree ref = fold_build2 (MEM_REF, TREE_TYPE (type), + build_fold_addr_expr (base), + build_int_cst (ptr_type_node, offset)); + tree addr = build1 (ADDR_EXPR, type, ref); + recompute_tree_invariant_for_addr_expr (addr); + return addr; } /* Similar except don't specify the TREE_TYPE @@ -4041,18 +4740,18 @@ } /* Similar to build_nt, but for creating a CALL_EXPR object with a - tree VEC. */ - -tree -build_nt_call_vec (tree fn, VEC(tree,gc) *args) + tree vec. */ + +tree +build_nt_call_vec (tree fn, vec<tree, va_gc> *args) { tree ret, t; unsigned int ix; - ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3); + ret = build_vl_exp (CALL_EXPR, vec_safe_length (args) + 3); CALL_EXPR_FN (ret) = fn; CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE; - FOR_EACH_VEC_ELT (tree, args, ix, t) + FOR_EACH_VEC_SAFE_ELT (args, ix, t) CALL_EXPR_ARG (ret, ix) = t; return ret; } @@ -4066,12 +4765,12 @@ Other slots are initialized to 0 or null pointers. */ tree -build_decl_stat (location_t loc, enum tree_code code, tree name, +build_decl (location_t loc, enum tree_code code, tree name, tree type MEM_STAT_DECL) { tree t; - t = make_node_stat (code PASS_MEM_STAT); + t = make_node (code PASS_MEM_STAT); DECL_SOURCE_LOCATION (t) = loc; /* if (type == error_mark_node) @@ -4104,7 +4803,7 @@ return decl; } -VEC(tree,gc) *all_translation_units; +vec<tree, va_gc> *all_translation_units; /* Builds a new translation-unit decl with name NAME, queues it in the global list of translation-unit decls and returns it. */ @@ -4115,7 +4814,7 @@ tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL, name, NULL_TREE); TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name; - VEC_safe_push (tree, gc, all_translation_units, tu); + vec_safe_push (all_translation_units, tu); return tu; } @@ -4144,172 +4843,10 @@ void protected_set_expr_location (tree t, location_t loc) { - if (t && CAN_HAVE_LOCATION_P (t)) + if (CAN_HAVE_LOCATION_P (t)) SET_EXPR_LOCATION (t, loc); } -/* Return a declaration like DDECL except that its DECL_ATTRIBUTES - is ATTRIBUTE. */ - -tree -build_decl_attribute_variant (tree ddecl, tree attribute) -{ - DECL_ATTRIBUTES (ddecl) = attribute; - return ddecl; -} - -/* Borrowed from hashtab.c iterative_hash implementation. */ -#define mix(a,b,c) \ -{ \ - a -= b; a -= c; a ^= (c>>13); \ - b -= c; b -= a; b ^= (a<< 8); \ - c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \ - a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \ - b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \ - c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \ - a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \ - b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \ - c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \ -} - - -/* Produce good hash value combining VAL and VAL2. */ -hashval_t -iterative_hash_hashval_t (hashval_t val, hashval_t val2) -{ - /* the golden ratio; an arbitrary value. */ - hashval_t a = 0x9e3779b9; - - mix (a, val, val2); - return val2; -} - -/* Produce good hash value combining VAL and VAL2. */ -hashval_t -iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2) -{ - if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t)) - return iterative_hash_hashval_t (val, val2); - else - { - hashval_t a = (hashval_t) val; - /* Avoid warnings about shifting of more than the width of the type on - hosts that won't execute this path. */ - int zero = 0; - hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero)); - mix (a, b, val2); - if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t)) - { - hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero)); - hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero)); - mix (a, b, val2); - } - return val2; - } -} - -/* Return a type like TTYPE except that its TYPE_ATTRIBUTE - is ATTRIBUTE and its qualifiers are QUALS. - - Record such modified types already made so we don't make duplicates. */ - -tree -build_type_attribute_qual_variant (tree ttype, tree attribute, int quals) -{ - if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute)) - { - hashval_t hashcode = 0; - tree ntype; - enum tree_code code = TREE_CODE (ttype); - - /* Building a distinct copy of a tagged type is inappropriate; it - causes breakage in code that expects there to be a one-to-one - relationship between a struct and its fields. - build_duplicate_type is another solution (as used in - handle_transparent_union_attribute), but that doesn't play well - with the stronger C++ type identity model. */ - if (TREE_CODE (ttype) == RECORD_TYPE - || TREE_CODE (ttype) == UNION_TYPE - || TREE_CODE (ttype) == QUAL_UNION_TYPE - || TREE_CODE (ttype) == ENUMERAL_TYPE) - { - warning (OPT_Wattributes, - "ignoring attributes applied to %qT after definition", - TYPE_MAIN_VARIANT (ttype)); - return build_qualified_type (ttype, quals); - } - - ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED); - ntype = build_distinct_type_copy (ttype); - - TYPE_ATTRIBUTES (ntype) = attribute; - - hashcode = iterative_hash_object (code, hashcode); - if (TREE_TYPE (ntype)) - hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)), - hashcode); - hashcode = attribute_hash_list (attribute, hashcode); - - switch (TREE_CODE (ntype)) - { - case FUNCTION_TYPE: - hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode); - break; - case ARRAY_TYPE: - if (TYPE_DOMAIN (ntype)) - hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)), - hashcode); - break; - case INTEGER_TYPE: - hashcode = iterative_hash_object - (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode); - hashcode = iterative_hash_object - (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode); - break; - case REAL_TYPE: - case FIXED_POINT_TYPE: - { - unsigned int precision = TYPE_PRECISION (ntype); - hashcode = iterative_hash_object (precision, hashcode); - } - break; - default: - break; - } - - ntype = type_hash_canon (hashcode, ntype); - - /* If the target-dependent attributes make NTYPE different from - its canonical type, we will need to use structural equality - checks for this type. */ - if (TYPE_STRUCTURAL_EQUALITY_P (ttype) - || !targetm.comp_type_attributes (ntype, ttype)) - SET_TYPE_STRUCTURAL_EQUALITY (ntype); - else if (TYPE_CANONICAL (ntype) == ntype) - TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype); - - ttype = build_qualified_type (ntype, quals); - } - else if (TYPE_QUALS (ttype) != quals) - ttype = build_qualified_type (ttype, quals); - - return ttype; -} - - -/* Return a type like TTYPE except that its TYPE_ATTRIBUTE - is ATTRIBUTE. - - Record such modified types already made so we don't make duplicates. */ - -tree -build_type_attribute_variant (tree ttype, tree attribute) -{ - return build_type_attribute_qual_variant (ttype, attribute, - TYPE_QUALS (ttype)); -} - - /* Reset the expression *EXPR_P, a size or position. ??? We could reset all non-constant sizes or positions. But it's cheap @@ -4331,7 +4868,7 @@ /* Reset all the fields in a binfo node BINFO. We only keep - BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref. */ + BINFO_VTABLE, which is used by gimple_fold_obj_type_ref. */ static void free_lang_data_in_binfo (tree binfo) @@ -4341,12 +4878,12 @@ gcc_assert (TREE_CODE (binfo) == TREE_BINFO); - BINFO_VTABLE (binfo) = NULL_TREE; + BINFO_VIRTUALS (binfo) = NULL_TREE; BINFO_BASE_ACCESSES (binfo) = NULL; BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE; BINFO_SUBVTT_INDEX (binfo) = NULL_TREE; - FOR_EACH_VEC_ELT (tree, BINFO_BASE_BINFOS (binfo), i, t) + FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (binfo), i, t) free_lang_data_in_binfo (t); } @@ -4376,9 +4913,7 @@ leading to false ODR violation errors when merging two instances of the same function signature compiled by different front ends. */ - tree p; - - for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p)) + for (tree p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p)) { tree arg_type = TREE_VALUE (p); @@ -4390,73 +4925,74 @@ TREE_VALUE (p) = build_qualified_type (arg_type, quals); free_lang_data_in_type (TREE_VALUE (p)); } - } - } - - /* Remove members that are not actually FIELD_DECLs from the field - list of an aggregate. These occur in C++. */ - if (RECORD_OR_UNION_TYPE_P (type)) - { - tree prev, member; - - /* Note that TYPE_FIELDS can be shared across distinct - TREE_TYPEs. Therefore, if the first field of TYPE_FIELDS is - to be removed, we cannot set its TREE_CHAIN to NULL. - Otherwise, we would not be able to find all the other fields - in the other instances of this TREE_TYPE. - - This was causing an ICE in testsuite/g++.dg/lto/20080915.C. */ - prev = NULL_TREE; - member = TYPE_FIELDS (type); - while (member) - { - if (TREE_CODE (member) == FIELD_DECL) - { - if (prev) - TREE_CHAIN (prev) = member; - else - TYPE_FIELDS (type) = member; - prev = member; - } - - member = TREE_CHAIN (member); - } - - if (prev) - TREE_CHAIN (prev) = NULL_TREE; - else - TYPE_FIELDS (type) = NULL_TREE; - - TYPE_METHODS (type) = NULL_TREE; + /* C++ FE uses TREE_PURPOSE to store initial values. */ + TREE_PURPOSE (p) = NULL; + } + } + else if (TREE_CODE (type) == METHOD_TYPE) + for (tree p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p)) + /* C++ FE uses TREE_PURPOSE to store initial values. */ + TREE_PURPOSE (p) = NULL; + else if (RECORD_OR_UNION_TYPE_P (type)) + { + /* Remove members that are not FIELD_DECLs (and maybe + TYPE_DECLs) from the field list of an aggregate. These occur + in C++. */ + for (tree *prev = &TYPE_FIELDS (type), member; (member = *prev);) + if (TREE_CODE (member) == FIELD_DECL + || (TREE_CODE (member) == TYPE_DECL + && !DECL_IGNORED_P (member) + && debug_info_level > DINFO_LEVEL_TERSE + && !is_redundant_typedef (member))) + prev = &DECL_CHAIN (member); + else + *prev = DECL_CHAIN (member); + + /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS + and danagle the pointer from time to time. */ + if (TYPE_VFIELD (type) && TREE_CODE (TYPE_VFIELD (type)) != FIELD_DECL) + TYPE_VFIELD (type) = NULL_TREE; + if (TYPE_BINFO (type)) - free_lang_data_in_binfo (TYPE_BINFO (type)); - } - else - { - /* For non-aggregate types, clear out the language slot (which - overloads TYPE_BINFO). */ - TYPE_LANG_SLOT_1 (type) = NULL_TREE; - - if (INTEGRAL_TYPE_P (type) - || SCALAR_FLOAT_TYPE_P (type) - || FIXED_POINT_TYPE_P (type)) - { - free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type)); - free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type)); - } - } + { + free_lang_data_in_binfo (TYPE_BINFO (type)); + /* We need to preserve link to bases and virtual table for all + polymorphic types to make devirtualization machinery working. + Debug output cares only about bases, but output also + virtual table pointers so merging of -fdevirtualize and + -fno-devirtualize units is easier. */ + if ((!BINFO_VTABLE (TYPE_BINFO (type)) + || !flag_devirtualize) + && ((!BINFO_N_BASE_BINFOS (TYPE_BINFO (type)) + && !BINFO_VTABLE (TYPE_BINFO (type))) + || debug_info_level != DINFO_LEVEL_NONE)) + TYPE_BINFO (type) = NULL; + } + } + else if (INTEGRAL_TYPE_P (type) + || SCALAR_FLOAT_TYPE_P (type) + || FIXED_POINT_TYPE_P (type)) + { + free_lang_data_in_one_sizepos (&TYPE_MIN_VALUE (type)); + free_lang_data_in_one_sizepos (&TYPE_MAX_VALUE (type)); + } + + TYPE_LANG_SLOT_1 (type) = NULL_TREE; free_lang_data_in_one_sizepos (&TYPE_SIZE (type)); free_lang_data_in_one_sizepos (&TYPE_SIZE_UNIT (type)); - if (debug_info_level < DINFO_LEVEL_TERSE - || (TYPE_CONTEXT (type) - && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL - && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL)) - TYPE_CONTEXT (type) = NULL_TREE; - - if (debug_info_level < DINFO_LEVEL_TERSE) - TYPE_STUB_DECL (type) = NULL_TREE; + if (TYPE_CONTEXT (type) + && TREE_CODE (TYPE_CONTEXT (type)) == BLOCK) + { + tree ctx = TYPE_CONTEXT (type); + do + { + ctx = BLOCK_SUPERCONTEXT (ctx); + } + while (ctx && TREE_CODE (ctx) == BLOCK); + TYPE_CONTEXT (type) = ctx; + } } @@ -4465,9 +5001,35 @@ static inline bool need_assembler_name_p (tree decl) { + /* We use DECL_ASSEMBLER_NAME to hold mangled type names for One Definition + Rule merging. This makes type_odr_p to return true on those types during + LTO and by comparing the mangled name, we can say what types are intended + to be equivalent across compilation unit. + + We do not store names of type_in_anonymous_namespace_p. + + Record, union and enumeration type have linkage that allows use + to check type_in_anonymous_namespace_p. We do not mangle compound types + that always can be compared structurally. + + Similarly for builtin types, we compare properties of their main variant. + A special case are integer types where mangling do make differences + between char/signed char/unsigned char etc. Storing name for these makes + e.g. -fno-signed-char/-fsigned-char mismatches to be handled well. + See cp/mangle.c:write_builtin_type for details. */ + + if (flag_lto_odr_type_mering + && TREE_CODE (decl) == TYPE_DECL + && DECL_NAME (decl) + && decl == TYPE_NAME (TREE_TYPE (decl)) + && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl) + && !TYPE_ARTIFICIAL (TREE_TYPE (decl)) + && (type_with_linkage_p (TREE_TYPE (decl)) + || TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE) + && !variably_modified_type_p (TREE_TYPE (decl), NULL_TREE)) + return !DECL_ASSEMBLER_NAME_SET_P (decl); /* Only FUNCTION_DECLs and VAR_DECLs are considered. */ - if (TREE_CODE (decl) != FUNCTION_DECL - && TREE_CODE (decl) != VAR_DECL) + if (!VAR_OR_FUNCTION_DECL_P (decl)) return false; /* If DECL already has its assembler name set, it does not need a @@ -4477,12 +5039,12 @@ return false; /* Abstract decls do not need an assembler name. */ - if (DECL_ABSTRACT (decl)) + if (DECL_ABSTRACT_P (decl)) return false; /* For VAR_DECLs, only static, public and external symbols need an assembler name. */ - if (TREE_CODE (decl) == VAR_DECL + if (VAR_P (decl) && !TREE_STATIC (decl) && !TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl)) @@ -4497,7 +5059,7 @@ return false; /* Functions represented in the callgraph need an assembler name. */ - if (cgraph_get_node (decl) != NULL) + if (cgraph_node::get (decl) != NULL) return true; /* Unused and not public functions don't need an assembler name. */ @@ -4528,23 +5090,32 @@ TREE_LANG_FLAG_5 (decl) = 0; TREE_LANG_FLAG_6 (decl) = 0; - /* Identifiers need not have a type. */ - if (DECL_NAME (decl)) - TREE_TYPE (DECL_NAME (decl)) = NULL_TREE; - free_lang_data_in_one_sizepos (&DECL_SIZE (decl)); free_lang_data_in_one_sizepos (&DECL_SIZE_UNIT (decl)); if (TREE_CODE (decl) == FIELD_DECL) - free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl)); - - /* DECL_FCONTEXT is only used for debug info generation. */ - if (TREE_CODE (decl) == FIELD_DECL - && debug_info_level < DINFO_LEVEL_TERSE) - DECL_FCONTEXT (decl) = NULL_TREE; + { + free_lang_data_in_one_sizepos (&DECL_FIELD_OFFSET (decl)); + if (TREE_CODE (DECL_CONTEXT (decl)) == QUAL_UNION_TYPE) + DECL_QUALIFIER (decl) = NULL_TREE; + } if (TREE_CODE (decl) == FUNCTION_DECL) { - if (gimple_has_body_p (decl)) + struct cgraph_node *node; + if (!(node = cgraph_node::get (decl)) + || (!node->definition && !node->clones)) + { + if (node) + node->release_body (); + else + { + release_function_body (decl); + DECL_ARGUMENTS (decl) = NULL; + DECL_RESULT (decl) = NULL; + DECL_INITIAL (decl) = error_mark_node; + } + } + if (gimple_has_body_p (decl) || (node && node->thunk.thunk_p)) { tree t; @@ -4559,22 +5130,36 @@ the PARM_DECL will be used in the function's body). */ for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t)) DECL_CONTEXT (t) = decl; + if (!DECL_FUNCTION_SPECIFIC_TARGET (decl)) + DECL_FUNCTION_SPECIFIC_TARGET (decl) + = target_option_default_node; + if (!DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl)) + DECL_FUNCTION_SPECIFIC_OPTIMIZATION (decl) + = optimization_default_node; } /* DECL_SAVED_TREE holds the GENERIC representation for DECL. At this point, it is not needed anymore. */ DECL_SAVED_TREE (decl) = NULL_TREE; - /* Clear the abstract origin if it refers to a method. Otherwise - dwarf2out.c will ICE as we clear TYPE_METHODS and thus the - origin will not be output correctly. */ + /* Clear the abstract origin if it refers to a method. + Otherwise dwarf2out.c will ICE as we splice functions out of + TYPE_FIELDS and thus the origin will not be output + correctly. */ if (DECL_ABSTRACT_ORIGIN (decl) && DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl)) && RECORD_OR_UNION_TYPE_P (DECL_CONTEXT (DECL_ABSTRACT_ORIGIN (decl)))) DECL_ABSTRACT_ORIGIN (decl) = NULL_TREE; - } - else if (TREE_CODE (decl) == VAR_DECL) + + /* Sometimes the C++ frontend doesn't manage to transform a temporary + DECL_VINDEX referring to itself into a vtable slot number as it + should. Happens with functions that are copied and then forgotten + about. Just clear it, it won't matter anymore. */ + if (DECL_VINDEX (decl) && !tree_fits_shwi_p (DECL_VINDEX (decl))) + DECL_VINDEX (decl) = NULL_TREE; + } + else if (VAR_P (decl)) { if ((DECL_EXTERNAL (decl) && (!TREE_STATIC (decl) || !TREE_READONLY (decl))) @@ -4582,15 +5167,20 @@ DECL_INITIAL (decl) = NULL_TREE; } else if (TREE_CODE (decl) == TYPE_DECL) + { + DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT; + DECL_VISIBILITY_SPECIFIED (decl) = 0; + DECL_INITIAL (decl) = NULL_TREE; + } + else if (TREE_CODE (decl) == FIELD_DECL) DECL_INITIAL (decl) = NULL_TREE; else if (TREE_CODE (decl) == TRANSLATION_UNIT_DECL && DECL_INITIAL (decl) && TREE_CODE (DECL_INITIAL (decl)) == BLOCK) { - /* Strip builtins from the translation-unit BLOCK. We still have - targets without builtin_decl support and also builtins are - shared nodes and thus we can't use TREE_CHAIN in multiple - lists. */ + /* Strip builtins from the translation-unit BLOCK. We still have targets + without builtin_decl_explicit support and also builtins are shared + nodes and thus we can't use TREE_CHAIN in multiple lists. */ tree *nextp = &BLOCK_VARS (DECL_INITIAL (decl)); while (*nextp) { @@ -4609,17 +5199,19 @@ struct free_lang_data_d { + free_lang_data_d () : decls (100), types (100) {} + /* Worklist to avoid excessive recursion. */ - VEC(tree,heap) *worklist; + auto_vec<tree> worklist; /* Set of traversed objects. Used to avoid duplicate visits. */ - struct pointer_set_t *pset; + hash_set<tree> pset; /* Array of symbols to process with free_lang_data_in_decl. */ - VEC(tree,heap) *decls; + auto_vec<tree> decls; /* Array of types to process with free_lang_data_in_type. */ - VEC(tree,heap) *types; + auto_vec<tree> types; }; @@ -4659,13 +5251,13 @@ { if (DECL_P (t)) { - VEC_safe_push (tree, heap, fld->decls, t); + fld->decls.safe_push (t); if (debug_info_level > DINFO_LEVEL_TERSE) save_debug_info_for_decl (t); } else if (TYPE_P (t)) { - VEC_safe_push (tree, heap, fld->types, t); + fld->types.safe_push (t); if (debug_info_level > DINFO_LEVEL_TERSE) save_debug_info_for_type (t); } @@ -4678,8 +5270,8 @@ static inline void fld_worklist_push (tree t, struct free_lang_data_d *fld) { - if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t)) - VEC_safe_push (tree, heap, fld->worklist, (t)); + if (t && !is_lang_specific (t) && !fld->pset.contains (t)) + fld->worklist.safe_push ((t)); } @@ -4729,24 +5321,17 @@ } else if (TREE_CODE (t) == TYPE_DECL) { - fld_worklist_push (DECL_ARGUMENT_FLD (t), fld); - fld_worklist_push (DECL_VINDEX (t), fld); + fld_worklist_push (DECL_ORIGINAL_TYPE (t), fld); } else if (TREE_CODE (t) == FIELD_DECL) { fld_worklist_push (DECL_FIELD_OFFSET (t), fld); fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld); - fld_worklist_push (DECL_QUALIFIER (t), fld); fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld); fld_worklist_push (DECL_FCONTEXT (t), fld); } - else if (TREE_CODE (t) == VAR_DECL) - { - fld_worklist_push (DECL_SECTION_NAME (t), fld); - fld_worklist_push (DECL_COMDAT_GROUP (t), fld); - } - - if ((TREE_CODE (t) == VAR_DECL || TREE_CODE (t) == PARM_DECL) + + if ((VAR_P (t) || TREE_CODE (t) == PARM_DECL) && DECL_HAS_VALUE_EXPR_P (t)) fld_worklist_push (DECL_VALUE_EXPR (t), fld); @@ -4773,13 +5358,22 @@ them and thus do not and want not to reach unused pointer types this way. */ if (!POINTER_TYPE_P (t)) - fld_worklist_push (TYPE_MINVAL (t), fld); + fld_worklist_push (TYPE_MIN_VALUE_RAW (t), fld); + /* TYPE_MAX_VALUE_RAW is TYPE_BINFO for record types. */ if (!RECORD_OR_UNION_TYPE_P (t)) - fld_worklist_push (TYPE_MAXVAL (t), fld); + fld_worklist_push (TYPE_MAX_VALUE_RAW (t), fld); fld_worklist_push (TYPE_MAIN_VARIANT (t), fld); /* Do not walk TYPE_NEXT_VARIANT. We do not stream it and thus do not and want not to reach unused variants this way. */ - fld_worklist_push (TYPE_CONTEXT (t), fld); + if (TYPE_CONTEXT (t)) + { + tree ctx = TYPE_CONTEXT (t); + /* We adjust BLOCK TYPE_CONTEXTs to the innermost non-BLOCK one. + So push that instead. */ + while (ctx && TREE_CODE (ctx) == BLOCK) + ctx = BLOCK_SUPERCONTEXT (ctx); + fld_worklist_push (ctx, fld); + } /* Do not walk TYPE_CANONICAL. We do not stream it and thus do not and want not to reach unused types this way. */ @@ -4787,19 +5381,9 @@ { unsigned i; tree tem; - for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)), - i, tem); ++i) + FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (TYPE_BINFO (t)), i, tem) fld_worklist_push (TREE_TYPE (tem), fld); - tem = BINFO_VIRTUALS (TYPE_BINFO (t)); - if (tem - /* The Java FE overloads BINFO_VIRTUALS for its own purpose. */ - && TREE_CODE (tem) == TREE_LIST) - do - { - fld_worklist_push (TREE_VALUE (tem), fld); - tem = TREE_CHAIN (tem); - } - while (tem); + fld_worklist_push (BINFO_VIRTUALS (TYPE_BINFO (t)), fld); } if (RECORD_OR_UNION_TYPE_P (t)) { @@ -4809,13 +5393,17 @@ tem = TYPE_FIELDS (t); while (tem) { - if (TREE_CODE (tem) == FIELD_DECL) + if (TREE_CODE (tem) == FIELD_DECL + || (TREE_CODE (tem) == TYPE_DECL + && !DECL_IGNORED_P (tem) + && debug_info_level > DINFO_LEVEL_TERSE + && !is_redundant_typedef (tem))) fld_worklist_push (tem, fld); tem = TREE_CHAIN (tem); } } - fld_worklist_push (TREE_CHAIN (t), fld); + fld_worklist_push (TYPE_STUB_DECL (t), fld); *ws = 0; } else if (TREE_CODE (t) == BLOCK) @@ -4828,7 +5416,8 @@ fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld); } - if (TREE_CODE (t) != IDENTIFIER_NODE) + if (TREE_CODE (t) != IDENTIFIER_NODE + && CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPED)) fld_worklist_push (TREE_TYPE (t), fld); return NULL_TREE; @@ -4842,11 +5431,11 @@ { while (1) { - if (!pointer_set_contains (fld->pset, t)) - walk_tree (&t, find_decls_types_r, fld, fld->pset); - if (VEC_empty (tree, fld->worklist)) + if (!fld->pset.contains (t)) + walk_tree (&t, find_decls_types_r, fld, &fld->pset); + if (fld->worklist.is_empty ()) break; - t = VEC_pop (tree, fld->worklist); + t = fld->worklist.pop (); } } @@ -4897,7 +5486,7 @@ for (c = r->u.eh_try.first_catch; c ; c = c->next_catch) { c->type_list = get_eh_types_for_runtime (c->type_list); - walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset); + walk_tree (&c->type_list, find_decls_types_r, fld, &fld->pset); } } break; @@ -4905,12 +5494,12 @@ case ERT_ALLOWED_EXCEPTIONS: r->u.allowed.type_list = get_eh_types_for_runtime (r->u.allowed.type_list); - walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset); + walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, &fld->pset); break; case ERT_MUST_NOT_THROW: walk_tree (&r->u.must_not_throw.failure_decl, - find_decls_types_r, fld, fld->pset); + find_decls_types_r, fld, &fld->pset); break; } } @@ -4953,12 +5542,13 @@ /* Traverse every statement in FN. */ FOR_EACH_BB_FN (bb, fn) { + gphi_iterator psi; gimple_stmt_iterator si; unsigned i; - for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) - { - gimple phi = gsi_stmt (si); + for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi)) + { + gphi *phi = psi.phi (); for (i = 0; i < gimple_phi_num_args (phi); i++) { @@ -4969,7 +5559,10 @@ for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { - gimple stmt = gsi_stmt (si); + gimple *stmt = gsi_stmt (si); + + if (is_gimple_call (stmt)) + find_decls_types (gimple_call_fntype (stmt), fld); for (i = 0; i < gimple_num_ops (stmt); i++) { @@ -4988,7 +5581,7 @@ NAMESPACE_DECLs, etc). */ static void -find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld) +find_decls_types_in_var (varpool_node *v, struct free_lang_data_d *fld) { find_decls_types (v->decl, fld); } @@ -4996,7 +5589,7 @@ /* If T needs an assembler name, have one created for it. */ void -assign_assembler_name_if_neeeded (tree t) +assign_assembler_name_if_needed (tree t) { if (need_assembler_name_p (t)) { @@ -5042,47 +5635,41 @@ free_lang_data_in_cgraph (void) { struct cgraph_node *n; - struct varpool_node *v; + varpool_node *v; struct free_lang_data_d fld; tree t; unsigned i; alias_pair *p; - /* Initialize sets and arrays to store referenced decls and types. */ - fld.pset = pointer_set_create (); - fld.worklist = NULL; - fld.decls = VEC_alloc (tree, heap, 100); - fld.types = VEC_alloc (tree, heap, 100); - /* Find decls and types in the body of every function in the callgraph. */ - for (n = cgraph_nodes; n; n = n->next) + FOR_EACH_FUNCTION (n) find_decls_types_in_node (n, &fld); - FOR_EACH_VEC_ELT (alias_pair, alias_pairs, i, p) + FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p) find_decls_types (p->decl, &fld); /* Find decls and types in every varpool symbol. */ - for (v = varpool_nodes; v; v = v->next) + FOR_EACH_VARIABLE (v) find_decls_types_in_var (v, &fld); /* Set the assembler name on every decl found. We need to do this now because free_lang_data_in_decl will invalidate data needed for mangling. This breaks mangling on interdependent decls. */ - FOR_EACH_VEC_ELT (tree, fld.decls, i, t) - assign_assembler_name_if_neeeded (t); + FOR_EACH_VEC_ELT (fld.decls, i, t) + assign_assembler_name_if_needed (t); /* Traverse every decl found freeing its language data. */ - FOR_EACH_VEC_ELT (tree, fld.decls, i, t) + FOR_EACH_VEC_ELT (fld.decls, i, t) free_lang_data_in_decl (t); /* Traverse every type found freeing its language data. */ - FOR_EACH_VEC_ELT (tree, fld.types, i, t) + FOR_EACH_VEC_ELT (fld.types, i, t) free_lang_data_in_type (t); - - pointer_set_destroy (fld.pset); - VEC_free (tree, heap, fld.worklist); - VEC_free (tree, heap, fld.decls); - VEC_free (tree, heap, fld.types); + if (flag_checking) + { + FOR_EACH_VEC_ELT (fld.types, i, t) + verify_type (t); + } } @@ -5095,9 +5682,13 @@ /* If we are the LTO frontend we have freed lang-specific data already. */ if (in_lto_p - || !flag_generate_lto) + || (!flag_generate_lto && !flag_generate_offload)) return 0; + /* Provide a dummy TRANSLATION_UNIT_DECL if the FE failed to provide one. */ + if (vec_safe_is_empty (all_translation_units)) + build_translation_unit_decl (NULL_TREE); + /* Allocate and assign alias sets to the standard integer types while the slots are still in the way the frontends generated them. */ for (i = 0; i < itk_none; ++i) @@ -5109,467 +5700,65 @@ free_lang_data_in_cgraph (); /* Create gimple variants for common types. */ - ptrdiff_type_node = integer_type_node; - fileptr_type_node = ptr_type_node; - if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE - || (TYPE_MODE (boolean_type_node) - != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0)) - || TYPE_PRECISION (boolean_type_node) != 1 - || !TYPE_UNSIGNED (boolean_type_node)) - { - boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE); - TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE); - TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1); - TYPE_PRECISION (boolean_type_node) = 1; - boolean_false_node = TYPE_MIN_VALUE (boolean_type_node); - boolean_true_node = TYPE_MAX_VALUE (boolean_type_node); - } - - /* Unify char_type_node with its properly signed variant. */ - if (TYPE_UNSIGNED (char_type_node)) - unsigned_char_type_node = char_type_node; - else - signed_char_type_node = char_type_node; + for (unsigned i = 0; + i < sizeof (builtin_structptr_types) / sizeof (builtin_structptr_type); + ++i) + builtin_structptr_types[i].node = builtin_structptr_types[i].base; /* Reset some langhooks. Do not reset types_compatible_p, it may still be used indirectly via the get_alias_set langhook. */ - lang_hooks.callgraph.analyze_expr = NULL; lang_hooks.dwarf_name = lhd_dwarf_name; lang_hooks.decl_printable_name = gimple_decl_printable_name; - lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name; + lang_hooks.gimplify_expr = lhd_gimplify_expr; + + /* We do not want the default decl_assembler_name implementation, + rather if we have fixed everything we want a wrapper around it + asserting that all non-local symbols already got their assembler + name and only produce assembler names for local symbols. Or rather + make sure we never call decl_assembler_name on local symbols and + devise a separate, middle-end private scheme for it. */ /* Reset diagnostic machinery. */ - diagnostic_starter (global_dc) = default_tree_diagnostic_starter; - diagnostic_finalizer (global_dc) = default_diagnostic_finalizer; - diagnostic_format_decoder (global_dc) = default_tree_printer; - - return 0; -} - - -struct simple_ipa_opt_pass pass_ipa_free_lang_data = -{ - { - SIMPLE_IPA_PASS, - "*free_lang_data", /* name */ - NULL, /* gate */ - free_lang_data, /* execute */ - NULL, /* sub */ - NULL, /* next */ - 0, /* static_pass_number */ - TV_IPA_FREE_LANG_DATA, /* tv_id */ - 0, /* properties_required */ - 0, /* properties_provided */ - 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - TODO_ggc_collect /* todo_flags_finish */ - } -}; - -/* Return nonzero if IDENT is a valid name for attribute ATTR, - or zero if not. - - We try both `text' and `__text__', ATTR may be either one. */ -/* ??? It might be a reasonable simplification to require ATTR to be only - `text'. One might then also require attribute lists to be stored in - their canonicalized form. */ - -static int -is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident) -{ - int ident_len; - const char *p; - - if (TREE_CODE (ident) != IDENTIFIER_NODE) - return 0; - - p = IDENTIFIER_POINTER (ident); - ident_len = IDENTIFIER_LENGTH (ident); - - if (ident_len == attr_len - && strcmp (attr, p) == 0) - return 1; - - /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */ - if (attr[0] == '_') - { - gcc_assert (attr[1] == '_'); - gcc_assert (attr[attr_len - 2] == '_'); - gcc_assert (attr[attr_len - 1] == '_'); - if (ident_len == attr_len - 4 - && strncmp (attr + 2, p, attr_len - 4) == 0) - return 1; - } - else - { - if (ident_len == attr_len + 4 - && p[0] == '_' && p[1] == '_' - && p[ident_len - 2] == '_' && p[ident_len - 1] == '_' - && strncmp (attr, p + 2, attr_len) == 0) - return 1; - } + tree_diagnostics_defaults (global_dc); return 0; } -/* Return nonzero if IDENT is a valid name for attribute ATTR, - or zero if not. - - We try both `text' and `__text__', ATTR may be either one. */ - -int -is_attribute_p (const char *attr, const_tree 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 - 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 - returns the first occurrence; the TREE_CHAIN of the return value should - be passed back in if further occurrences are wanted. */ - -tree -lookup_attribute (const char *attr_name, tree list) -{ - tree l; - size_t attr_len = strlen (attr_name); - - for (l = list; l; l = TREE_CHAIN (l)) - { - gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE); - if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l))) - return l; - } - return NULL_TREE; -} - -/* Remove any instances of attribute ATTR_NAME in LIST and return the - modified list. */ - -tree -remove_attribute (const char *attr_name, tree list) -{ - tree *p; - size_t attr_len = strlen (attr_name); - - for (p = &list; *p; ) - { - tree l = *p; - gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE); - if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l))) - *p = TREE_CHAIN (l); - else - p = &TREE_CHAIN (l); - } - - return list; -} - -/* Return an attribute list that is the union of a1 and a2. */ - -tree -merge_attributes (tree a1, tree a2) -{ - tree attributes; - - /* Either one unset? Take the set one. */ - - if ((attributes = a1) == 0) - attributes = a2; - - /* One that completely contains the other? Take it. */ - - else if (a2 != 0 && ! attribute_list_contained (a1, a2)) - { - if (attribute_list_contained (a2, a1)) - attributes = a2; - else - { - /* Pick the longest list, and hang on the other list. */ - - if (list_length (a1) < list_length (a2)) - attributes = a2, a2 = a1; - - for (; a2 != 0; a2 = TREE_CHAIN (a2)) - { - tree a; - for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), - attributes); - a != NULL_TREE; - a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), - TREE_CHAIN (a))) - { - if (TREE_VALUE (a) != NULL - && TREE_CODE (TREE_VALUE (a)) == TREE_LIST - && TREE_VALUE (a2) != NULL - && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST) - { - if (simple_cst_list_equal (TREE_VALUE (a), - TREE_VALUE (a2)) == 1) - break; - } - else if (simple_cst_equal (TREE_VALUE (a), - TREE_VALUE (a2)) == 1) - break; - } - if (a == NULL_TREE) - { - a1 = copy_node (a2); - TREE_CHAIN (a1) = attributes; - attributes = a1; - } - } - } - } - return attributes; -} - -/* Given types T1 and T2, merge their attributes and return - the result. */ - -tree -merge_type_attributes (tree t1, tree t2) -{ - return merge_attributes (TYPE_ATTRIBUTES (t1), - TYPE_ATTRIBUTES (t2)); -} - -/* Given decls OLDDECL and NEWDECL, merge their attributes and return - the result. */ - -tree -merge_decl_attributes (tree olddecl, tree newdecl) -{ - return merge_attributes (DECL_ATTRIBUTES (olddecl), - DECL_ATTRIBUTES (newdecl)); -} - -#if TARGET_DLLIMPORT_DECL_ATTRIBUTES - -/* Specialization of merge_decl_attributes for various Windows targets. - - This handles the following situation: - - __declspec (dllimport) int foo; - int foo; - - The second instance of `foo' nullifies the dllimport. */ - -tree -merge_dllimport_decl_attributes (tree old, tree new_tree) -{ - tree a; - int delete_dllimport_p = 1; - - /* 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 - marked dllimport and a definition appears later, then the object - is not dllimport'd. We also remove a `new' dllimport if the old list - contains dllexport: dllexport always overrides dllimport, regardless - of the order of declaration. */ - if (!VAR_OR_FUNCTION_DECL_P (new_tree)) - delete_dllimport_p = 0; - else if (DECL_DLLIMPORT_P (new_tree) - && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old))) - { - DECL_DLLIMPORT_P (new_tree) = 0; - warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: " - "dllimport ignored", new_tree); - } - else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree)) - { - /* Warn about overriding a symbol that has already been used, e.g.: - extern int __attribute__ ((dllimport)) foo; - int* bar () {return &foo;} - int foo; - */ - if (TREE_USED (old)) - { - warning (0, "%q+D redeclared without dllimport attribute " - "after being referenced with dll linkage", new_tree); - /* If we have used a variable's address with dllimport linkage, - keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the - decl may already have had TREE_CONSTANT computed. - We still remove the attribute so that assembler code refers - to '&foo rather than '_imp__foo'. */ - if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old)) - DECL_DLLIMPORT_P (new_tree) = 1; - } - - /* Let an inline definition silently override the external reference, - but otherwise warn about attribute inconsistency. */ - else if (TREE_CODE (new_tree) == VAR_DECL - || !DECL_DECLARED_INLINE_P (new_tree)) - warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: " - "previous dllimport ignored", new_tree); - } - else - delete_dllimport_p = 0; - - a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree)); - - if (delete_dllimport_p) - { - tree prev, t; - const size_t attr_len = strlen ("dllimport"); - - /* Scan the list for dllimport and delete it. */ - for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t)) - { - if (is_attribute_with_length_p ("dllimport", attr_len, - TREE_PURPOSE (t))) - { - if (prev == NULL_TREE) - a = TREE_CHAIN (a); - else - TREE_CHAIN (prev) = TREE_CHAIN (t); - break; - } - } - } - - return a; -} - -/* Handle a "dllimport" or "dllexport" attribute; arguments as in - struct attribute_spec.handler. */ - -tree -handle_dll_attribute (tree * pnode, tree name, tree args, int flags, - bool *no_add_attrs) -{ - tree node = *pnode; - bool is_dllimport; - - /* These attributes may apply to structure and union types being created, - but otherwise should pass to the declaration involved. */ - if (!DECL_P (node)) - { - if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT - | (int) ATTR_FLAG_ARRAY_NEXT)) - { - *no_add_attrs = true; - return tree_cons (name, args, NULL_TREE); - } - if (TREE_CODE (node) == RECORD_TYPE - || TREE_CODE (node) == UNION_TYPE) - { - node = TYPE_NAME (node); - if (!node) - return NULL_TREE; - } - else - { - warning (OPT_Wattributes, "%qE attribute ignored", - name); - *no_add_attrs = true; - return NULL_TREE; - } - } - - if (TREE_CODE (node) != FUNCTION_DECL - && TREE_CODE (node) != VAR_DECL - && TREE_CODE (node) != TYPE_DECL) - { - *no_add_attrs = true; - warning (OPT_Wattributes, "%qE attribute ignored", - name); - return NULL_TREE; - } - - if (TREE_CODE (node) == TYPE_DECL - && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE - && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE) - { - *no_add_attrs = true; - warning (OPT_Wattributes, "%qE attribute ignored", - name); - return NULL_TREE; - } - - is_dllimport = is_attribute_p ("dllimport", name); - - /* Report error on dllimport ambiguities seen now before they cause - any damage. */ - if (is_dllimport) - { - /* Honor any target-specific overrides. */ - if (!targetm.valid_dllimport_attribute_p (node)) - *no_add_attrs = true; - - else if (TREE_CODE (node) == FUNCTION_DECL - && DECL_DECLARED_INLINE_P (node)) - { - warning (OPT_Wattributes, "inline function %q+D declared as " - " dllimport: attribute ignored", node); - *no_add_attrs = true; - } - /* Like MS, treat definition of dllimported variables and - non-inlined functions on declaration as syntax errors. */ - else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node)) - { - error ("function %q+D definition is marked dllimport", node); - *no_add_attrs = true; - } - - else if (TREE_CODE (node) == VAR_DECL) - { - if (DECL_INITIAL (node)) - { - error ("variable %q+D definition is marked dllimport", - node); - *no_add_attrs = true; - } - - /* `extern' needn't be specified with dllimport. - Specify `extern' now and hope for the best. Sigh. */ - DECL_EXTERNAL (node) = 1; - /* Also, implicitly give dllimport'd variables declared within - a function global scope, unless declared static. */ - if (current_function_decl != NULL_TREE && !TREE_STATIC (node)) - TREE_PUBLIC (node) = 1; - } - - if (*no_add_attrs == false) - DECL_DLLIMPORT_P (node) = 1; - } - else if (TREE_CODE (node) == FUNCTION_DECL - && DECL_DECLARED_INLINE_P (node) - && flag_keep_inline_dllexport) - /* An exported function, even if inline, must be emitted. */ - DECL_EXTERNAL (node) = 0; - - /* Report error if symbol is not accessible at global scope. */ - if (!TREE_PUBLIC (node) - && (TREE_CODE (node) == VAR_DECL - || TREE_CODE (node) == FUNCTION_DECL)) - { - error ("external linkage required for symbol %q+D because of " - "%qE attribute", node, name); - *no_add_attrs = true; - } - - /* A dllexport'd entity must have default visibility so that other - program units (shared libraries or the main executable) can see - it. A dllimport'd entity must have default visibility so that - the linker knows that undefined references within this program - unit can be resolved by the dynamic linker. */ - if (!*no_add_attrs) - { - if (DECL_VISIBILITY_SPECIFIED (node) - && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT) - error ("%qE implies default visibility, but %qD has already " - "been declared with a different visibility", - name, node); - DECL_VISIBILITY (node) = VISIBILITY_DEFAULT; - DECL_VISIBILITY_SPECIFIED (node) = 1; - } - - return NULL_TREE; -} - -#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */ + +namespace { + +const pass_data pass_data_ipa_free_lang_data = +{ + SIMPLE_IPA_PASS, /* type */ + "*free_lang_data", /* name */ + OPTGROUP_NONE, /* optinfo_flags */ + TV_IPA_FREE_LANG_DATA, /* tv_id */ + 0, /* properties_required */ + 0, /* properties_provided */ + 0, /* properties_destroyed */ + 0, /* todo_flags_start */ + 0, /* todo_flags_finish */ +}; + +class pass_ipa_free_lang_data : public simple_ipa_opt_pass +{ +public: + pass_ipa_free_lang_data (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt) + {} + + /* opt_pass methods: */ + virtual unsigned int execute (function *) { return free_lang_data (); } + +}; // class pass_ipa_free_lang_data + +} // anon namespace + +simple_ipa_opt_pass * +make_pass_ipa_free_lang_data (gcc::context *ctxt) +{ + return new pass_ipa_free_lang_data (ctxt); +} /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask of the various TYPE_QUAL values. */ @@ -5580,22 +5769,47 @@ TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0; TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0; TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0; + TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0; TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals); } +/* Returns true iff CAND and BASE have equivalent language-specific + qualifiers. */ + +bool +check_lang_type (const_tree cand, const_tree base) +{ + if (lang_hooks.types.type_hash_eq == NULL) + return true; + /* type_hash_eq currently only applies to these types. */ + if (TREE_CODE (cand) != FUNCTION_TYPE + && TREE_CODE (cand) != METHOD_TYPE) + return true; + return lang_hooks.types.type_hash_eq (cand, base); +} + +/* Returns true iff unqualified CAND and BASE are equivalent. */ + +bool +check_base_type (const_tree cand, const_tree base) +{ + return (TYPE_NAME (cand) == TYPE_NAME (base) + /* Apparently this is needed for Objective-C. */ + && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base) + /* Check alignment. */ + && TYPE_ALIGN (cand) == TYPE_ALIGN (base) + && attribute_list_equal (TYPE_ATTRIBUTES (cand), + TYPE_ATTRIBUTES (base))); +} + /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS. */ bool check_qualified_type (const_tree cand, const_tree base, int type_quals) { return (TYPE_QUALS (cand) == type_quals - && TYPE_NAME (cand) == TYPE_NAME (base) - /* Apparently this is needed for Objective-C. */ - && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base) - /* Check alignment. */ - && TYPE_ALIGN (cand) == TYPE_ALIGN (base) - && attribute_list_equal (TYPE_ATTRIBUTES (cand), - TYPE_ATTRIBUTES (base))); + && check_base_type (cand, base) + && check_lang_type (cand, base)); } /* Returns true iff CAND is equivalent to BASE with ALIGN. */ @@ -5610,7 +5824,49 @@ /* Check alignment. */ && TYPE_ALIGN (cand) == align && attribute_list_equal (TYPE_ATTRIBUTES (cand), - TYPE_ATTRIBUTES (base))); + TYPE_ATTRIBUTES (base)) + && check_lang_type (cand, base)); +} + +/* This function checks to see if TYPE matches the size one of the built-in + atomic types, and returns that core atomic type. */ + +static tree +find_atomic_core_type (tree type) +{ + tree base_atomic_type; + + /* Only handle complete types. */ + if (!tree_fits_uhwi_p (TYPE_SIZE (type))) + return NULL_TREE; + + switch (tree_to_uhwi (TYPE_SIZE (type))) + { + case 8: + base_atomic_type = atomicQI_type_node; + break; + + case 16: + base_atomic_type = atomicHI_type_node; + break; + + case 32: + base_atomic_type = atomicSI_type_node; + break; + + case 64: + base_atomic_type = atomicDI_type_node; + break; + + case 128: + base_atomic_type = atomicTI_type_node; + break; + + default: + base_atomic_type = NULL_TREE; + } + + return base_atomic_type; } /* Return a version of the TYPE, qualified as indicated by the @@ -5639,7 +5895,7 @@ exist. This function never returns NULL_TREE. */ tree -build_qualified_type (tree type, int type_quals) +build_qualified_type (tree type, int type_quals MEM_STAT_DECL) { tree t; @@ -5649,17 +5905,32 @@ /* If not, build it. */ if (!t) { - t = build_variant_type_copy (type); + t = build_variant_type_copy (type PASS_MEM_STAT); set_type_quals (t, type_quals); + if (((type_quals & TYPE_QUAL_ATOMIC) == TYPE_QUAL_ATOMIC)) + { + /* See if this object can map to a basic atomic type. */ + tree atomic_type = find_atomic_core_type (type); + if (atomic_type) + { + /* Ensure the alignment of this type is compatible with + the required alignment of the atomic type. */ + if (TYPE_ALIGN (atomic_type) > TYPE_ALIGN (t)) + SET_TYPE_ALIGN (t, TYPE_ALIGN (atomic_type)); + } + } + if (TYPE_STRUCTURAL_EQUALITY_P (type)) /* Propagate structural equality. */ SET_TYPE_STRUCTURAL_EQUALITY (t); else if (TYPE_CANONICAL (type) != type) /* Build the underlying canonical type, since it is different from TYPE. */ - TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type), - type_quals); + { + tree c = build_qualified_type (TYPE_CANONICAL (type), type_quals); + TYPE_CANONICAL (t) = TYPE_CANONICAL (c); + } else /* T is its own canonical type. */ TYPE_CANONICAL (t) = t; @@ -5685,7 +5956,8 @@ return t; t = build_variant_type_copy (type); - TYPE_ALIGN (t) = align; + SET_TYPE_ALIGN (t, align); + TYPE_USER_ALIGN (t) = 1; return t; } @@ -5696,9 +5968,9 @@ TYPE_CANONICAL points to itself. */ tree -build_distinct_type_copy (tree type) -{ - tree t = copy_node (type); +build_distinct_type_copy (tree type MEM_STAT_DECL) +{ + tree t = copy_node (type PASS_MEM_STAT); TYPE_POINTER_TO (t) = 0; TYPE_REFERENCE_TO (t) = 0; @@ -5728,15 +6000,17 @@ require structural equality checks). */ tree -build_variant_type_copy (tree type) +build_variant_type_copy (tree type MEM_STAT_DECL) { tree t, m = TYPE_MAIN_VARIANT (type); - t = build_distinct_type_copy (type); + t = build_distinct_type_copy (type PASS_MEM_STAT); /* Since we're building a variant, assume that it is a non-semantic variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */ TYPE_CANONICAL (t) = TYPE_CANONICAL (type); + /* Type variants have no alias set defined. */ + TYPE_ALIAS_SET (t) = -1; /* Add the new type to the chain of variants of TYPE. */ TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m); @@ -5795,13 +6069,12 @@ priority_type decl_init_priority_lookup (tree decl) { - struct tree_priority_map *h; - struct tree_map_base in; - - gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); - in.from = decl; - h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in); - return h ? h->init : DEFAULT_INIT_PRIORITY; + symtab_node *snode = symtab_node::get (decl); + + if (!snode) + return DEFAULT_INIT_PRIORITY; + return + snode->get_init_priority (); } /* Return the finalization priority for DECL. */ @@ -5809,39 +6082,12 @@ priority_type decl_fini_priority_lookup (tree decl) { - struct tree_priority_map *h; - struct tree_map_base in; - - gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); - in.from = decl; - h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in); - return h ? h->fini : DEFAULT_INIT_PRIORITY; -} - -/* Return the initialization and finalization priority information for - DECL. If there is no previous priority information, a freshly - allocated structure is returned. */ - -static struct tree_priority_map * -decl_priority_info (tree decl) -{ - struct tree_priority_map in; - struct tree_priority_map *h; - void **loc; - - in.base.from = decl; - loc = htab_find_slot (init_priority_for_decl, &in, INSERT); - h = (struct tree_priority_map *) *loc; - if (!h) - { - h = ggc_alloc_cleared_tree_priority_map (); - *loc = h; - h->base.from = decl; - h->init = DEFAULT_INIT_PRIORITY; - h->fini = DEFAULT_INIT_PRIORITY; - } - - return h; + cgraph_node *node = cgraph_node::get (decl); + + if (!node) + return DEFAULT_INIT_PRIORITY; + return + node->get_fini_priority (); } /* Set the initialization priority for DECL to PRIORITY. */ @@ -5849,11 +6095,19 @@ void decl_init_priority_insert (tree decl, priority_type priority) { - struct tree_priority_map *h; - - gcc_assert (VAR_OR_FUNCTION_DECL_P (decl)); - h = decl_priority_info (decl); - h->init = priority; + struct symtab_node *snode; + + if (priority == DEFAULT_INIT_PRIORITY) + { + snode = symtab_node::get (decl); + if (!snode) + return; + } + else if (VAR_P (decl)) + snode = varpool_node::get_create (decl); + else + snode = cgraph_node::get_create (decl); + snode->set_init_priority (priority); } /* Set the finalization priority for DECL to PRIORITY. */ @@ -5861,11 +6115,17 @@ void decl_fini_priority_insert (tree decl, priority_type priority) { - struct tree_priority_map *h; - - gcc_assert (TREE_CODE (decl) == FUNCTION_DECL); - h = decl_priority_info (decl); - h->fini = priority; + struct cgraph_node *node; + + if (priority == DEFAULT_INIT_PRIORITY) + { + node = cgraph_node::get (decl); + if (!node) + return; + } + else + node = cgraph_node::get_create (decl); + node->set_fini_priority (priority); } /* Print out the statistics for the DECL_DEBUG_EXPR hash table. */ @@ -5874,9 +6134,9 @@ print_debug_expr_statistics (void) { fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n", - (long) htab_size (debug_expr_for_decl), - (long) htab_elements (debug_expr_for_decl), - htab_collisions (debug_expr_for_decl)); + (long) debug_expr_for_decl->size (), + (long) debug_expr_for_decl->elements (), + debug_expr_for_decl->collisions ()); } /* Print out the statistics for the DECL_VALUE_EXPR hash table. */ @@ -5885,9 +6145,9 @@ print_value_expr_statistics (void) { fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n", - (long) htab_size (value_expr_for_decl), - (long) htab_elements (value_expr_for_decl), - htab_collisions (value_expr_for_decl)); + (long) value_expr_for_decl->size (), + (long) value_expr_for_decl->elements (), + value_expr_for_decl->collisions ()); } /* Lookup a debug expression for FROM, and return it if we find one. */ @@ -5898,8 +6158,7 @@ struct tree_decl_map *h, in; in.base.from = from; - h = (struct tree_decl_map *) - htab_find_with_hash (debug_expr_for_decl, &in, DECL_UID (from)); + h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from)); if (h) return h->to; return NULL_TREE; @@ -5911,14 +6170,11 @@ decl_debug_expr_insert (tree from, tree to) { struct tree_decl_map *h; - void **loc; - - h = ggc_alloc_tree_decl_map (); + + h = ggc_alloc<tree_decl_map> (); h->base.from = from; h->to = to; - loc = htab_find_slot_with_hash (debug_expr_for_decl, h, DECL_UID (from), - INSERT); - *(struct tree_decl_map **) loc = h; + *debug_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h; } /* Lookup a value expression for FROM, and return it if we find one. */ @@ -5929,8 +6185,7 @@ struct tree_decl_map *h, in; in.base.from = from; - h = (struct tree_decl_map *) - htab_find_with_hash (value_expr_for_decl, &in, DECL_UID (from)); + h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from)); if (h) return h->to; return NULL_TREE; @@ -5942,46 +6197,139 @@ decl_value_expr_insert (tree from, tree to) { struct tree_decl_map *h; - void **loc; - - h = ggc_alloc_tree_decl_map (); + + h = ggc_alloc<tree_decl_map> (); h->base.from = from; h->to = to; - loc = htab_find_slot_with_hash (value_expr_for_decl, h, DECL_UID (from), - INSERT); - *(struct tree_decl_map **) loc = h; + *value_expr_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT) = h; +} + +/* Lookup a vector of debug arguments for FROM, and return it if we + find one. */ + +vec<tree, va_gc> ** +decl_debug_args_lookup (tree from) +{ + struct tree_vec_map *h, in; + + if (!DECL_HAS_DEBUG_ARGS_P (from)) + return NULL; + gcc_checking_assert (debug_args_for_decl != NULL); + in.base.from = from; + h = debug_args_for_decl->find_with_hash (&in, DECL_UID (from)); + if (h) + return &h->to; + return NULL; +} + +/* Insert a mapping FROM->empty vector of debug arguments in the value + expression hashtable. */ + +vec<tree, va_gc> ** +decl_debug_args_insert (tree from) +{ + struct tree_vec_map *h; + tree_vec_map **loc; + + if (DECL_HAS_DEBUG_ARGS_P (from)) + return decl_debug_args_lookup (from); + if (debug_args_for_decl == NULL) + debug_args_for_decl = hash_table<tree_vec_map_cache_hasher>::create_ggc (64); + h = ggc_alloc<tree_vec_map> (); + h->base.from = from; + h->to = NULL; + loc = debug_args_for_decl->find_slot_with_hash (h, DECL_UID (from), INSERT); + *loc = h; + DECL_HAS_DEBUG_ARGS_P (from) = 1; + return &h->to; } /* Hashing of types so that we don't make duplicates. The entry point is `type_hash_canon'. */ -/* 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 - of the individual types. */ - -static unsigned int -type_hash_list (const_tree list, hashval_t hashcode) -{ - const_tree tail; - - for (tail = list; tail; tail = TREE_CHAIN (tail)) - if (TREE_VALUE (tail) != error_mark_node) - hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)), - hashcode); - - return hashcode; +/* Generate the default hash code for TYPE. This is designed for + speed, rather than maximum entropy. */ + +hashval_t +type_hash_canon_hash (tree type) +{ + inchash::hash hstate; + + hstate.add_int (TREE_CODE (type)); + + if (TREE_TYPE (type)) + hstate.add_object (TYPE_HASH (TREE_TYPE (type))); + + for (tree t = TYPE_ATTRIBUTES (type); t; t = TREE_CHAIN (t)) + /* Just the identifier is adequate to distinguish. */ + hstate.add_object (IDENTIFIER_HASH_VALUE (get_attribute_name (t))); + + switch (TREE_CODE (type)) + { + case METHOD_TYPE: + hstate.add_object (TYPE_HASH (TYPE_METHOD_BASETYPE (type))); + /* FALLTHROUGH. */ + case FUNCTION_TYPE: + for (tree t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t)) + if (TREE_VALUE (t) != error_mark_node) + hstate.add_object (TYPE_HASH (TREE_VALUE (t))); + break; + + case OFFSET_TYPE: + hstate.add_object (TYPE_HASH (TYPE_OFFSET_BASETYPE (type))); + break; + + case ARRAY_TYPE: + { + if (TYPE_DOMAIN (type)) + hstate.add_object (TYPE_HASH (TYPE_DOMAIN (type))); + if (!AGGREGATE_TYPE_P (TREE_TYPE (type))) + { + unsigned typeless = TYPE_TYPELESS_STORAGE (type); + hstate.add_object (typeless); + } + } + break; + + case INTEGER_TYPE: + { + tree t = TYPE_MAX_VALUE (type); + if (!t) + t = TYPE_MIN_VALUE (type); + for (int i = 0; i < TREE_INT_CST_NUNITS (t); i++) + hstate.add_object (TREE_INT_CST_ELT (t, i)); + break; + } + + case REAL_TYPE: + case FIXED_POINT_TYPE: + { + unsigned prec = TYPE_PRECISION (type); + hstate.add_object (prec); + break; + } + + case VECTOR_TYPE: + { + unsigned nunits = TYPE_VECTOR_SUBPARTS (type); + hstate.add_object (nunits); + break; + } + + default: + break; + } + + return hstate.end (); } /* These are the Hashtable callback functions. */ /* Returns true iff the types are equivalent. */ -static int -type_hash_eq (const void *va, const void *vb) -{ - const struct type_hash *const a = (const struct type_hash *) va, - *const b = (const struct type_hash *) vb; - +bool +type_cache_hasher::equal (type_hash *a, type_hash *b) +{ /* First test the things that are the same for all types. */ if (a->hash != b->hash || TREE_CODE (a->type) != TREE_CODE (b->type) @@ -6006,6 +6354,7 @@ case COMPLEX_TYPE: case POINTER_TYPE: case REFERENCE_TYPE: + case NULLPTR_TYPE: return 1; case VECTOR_TYPE: @@ -6021,11 +6370,13 @@ TYPE_VALUES (b->type)))) return 0; - /* ... fall through ... */ + /* fall through */ case INTEGER_TYPE: case REAL_TYPE: case BOOLEAN_TYPE: + if (TYPE_PRECISION (a->type) != TYPE_PRECISION (b->type)) + return false; return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type) || tree_int_cst_equal (TYPE_MAX_VALUE (a->type), TYPE_MAX_VALUE (b->type))) @@ -6051,7 +6402,16 @@ break; return 0; case ARRAY_TYPE: - return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type); + /* Don't compare TYPE_TYPELESS_STORAGE flag on aggregates, + where the flag should be inherited from the element type + and can change after ARRAY_TYPEs are created; on non-aggregates + compare it and hash it, scalars will never have that flag set + and we need to differentiate between arrays created by different + front-ends or middle-end created arrays. */ + return (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type) + && (AGGREGATE_TYPE_P (TREE_TYPE (a->type)) + || (TYPE_TYPELESS_STORAGE (a->type) + == TYPE_TYPELESS_STORAGE (b->type)))); case RECORD_TYPE: case UNION_TYPE: @@ -6085,52 +6445,6 @@ return 1; } -/* Return the cached hash value. */ - -static hashval_t -type_hash_hash (const void *item) -{ - return ((const struct type_hash *) item)->hash; -} - -/* Look in the type hash table for a type isomorphic to TYPE. - If one is found, return it. Otherwise return 0. */ - -tree -type_hash_lookup (hashval_t hashcode, tree type) -{ - struct type_hash *h, in; - - /* The TYPE_ALIGN field of a type is set by layout_type(), so we - must call that routine before comparing TYPE_ALIGNs. */ - layout_type (type); - - in.hash = hashcode; - in.type = type; - - h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in, - hashcode); - if (h) - return h->type; - return NULL_TREE; -} - -/* Add an entry to the type-hash-table - for a type TYPE whose hash code is HASHCODE. */ - -void -type_hash_add (hashval_t hashcode, tree type) -{ - struct type_hash *h; - void **loc; - - h = ggc_alloc_type_hash (); - h->hash = hashcode; - h->type = type; - loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT); - *loc = (void *)h; -} - /* Given TYPE, and HASHCODE its hash code, return the canonical object for an identical type if one already exists. Otherwise, return TYPE, and record it as the canonical object. @@ -6143,135 +6457,64 @@ tree type_hash_canon (unsigned int hashcode, tree type) { - tree t1; + type_hash in; + type_hash **loc; /* The hash table only contains main variants, so ensure that's what we're being passed. */ gcc_assert (TYPE_MAIN_VARIANT (type) == type); - /* See if the type is in the hash table already. If so, return it. - Otherwise, add the type. */ - t1 = type_hash_lookup (hashcode, type); - if (t1 != 0) - { -#ifdef GATHER_STATISTICS - tree_node_counts[(int) t_kind]--; - tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type); -#endif + /* The TYPE_ALIGN field of a type is set by layout_type(), so we + must call that routine before comparing TYPE_ALIGNs. */ + layout_type (type); + + in.hash = hashcode; + in.type = type; + + loc = type_hash_table->find_slot_with_hash (&in, hashcode, INSERT); + if (*loc) + { + tree t1 = ((type_hash *) *loc)->type; + gcc_assert (TYPE_MAIN_VARIANT (t1) == t1); + if (TYPE_UID (type) + 1 == next_type_uid) + --next_type_uid; + /* Free also min/max values and the cache for integer + types. This can't be done in free_node, as LTO frees + those on its own. */ + if (TREE_CODE (type) == INTEGER_TYPE) + { + if (TYPE_MIN_VALUE (type) + && TREE_TYPE (TYPE_MIN_VALUE (type)) == type) + ggc_free (TYPE_MIN_VALUE (type)); + if (TYPE_MAX_VALUE (type) + && TREE_TYPE (TYPE_MAX_VALUE (type)) == type) + ggc_free (TYPE_MAX_VALUE (type)); + if (TYPE_CACHED_VALUES_P (type)) + ggc_free (TYPE_CACHED_VALUES (type)); + } + free_node (type); return t1; } else { - type_hash_add (hashcode, type); + struct type_hash *h; + + h = ggc_alloc<type_hash> (); + h->hash = hashcode; + h->type = type; + *loc = h; + return type; } } -/* 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 - table entry has been made for the type. */ - -static int -type_hash_marked_p (const void *p) -{ - const_tree const type = ((const struct type_hash *) p)->type; - - return ggc_marked_p (type); -} - static void print_type_hash_statistics (void) { fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n", - (long) htab_size (type_hash_table), - (long) htab_elements (type_hash_table), - htab_collisions (type_hash_table)); -} - -/* 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), - by adding the hash codes of the individual attributes. */ - -static unsigned int -attribute_hash_list (const_tree list, hashval_t hashcode) -{ - const_tree tail; - - for (tail = list; tail; tail = TREE_CHAIN (tail)) - /* ??? Do we want to add in TREE_VALUE too? */ - hashcode = iterative_hash_object - (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode); - return hashcode; -} - -/* Given two lists of attributes, return true if list l2 is - equivalent to l1. */ - -int -attribute_list_equal (const_tree l1, const_tree l2) -{ - return attribute_list_contained (l1, l2) - && attribute_list_contained (l2, l1); -} - -/* Given two lists of attributes, return true if list L2 is - completely contained within L1. */ -/* ??? 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 - must be used to show these elements are equivalent (which they are). */ -/* ??? It's not clear that attributes with arguments will always be handled - correctly. */ - -int -attribute_list_contained (const_tree l1, const_tree l2) -{ - const_tree t1, t2; - - /* First check the obvious, maybe the lists are identical. */ - if (l1 == l2) - return 1; - - /* Maybe the lists are similar. */ - for (t1 = l1, t2 = l2; - t1 != 0 && t2 != 0 - && TREE_PURPOSE (t1) == TREE_PURPOSE (t2) - && TREE_VALUE (t1) == TREE_VALUE (t2); - t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)); - - /* Maybe the lists are equal. */ - if (t1 == 0 && t2 == 0) - return 1; - - for (; t2 != 0; t2 = TREE_CHAIN (t2)) - { - const_tree attr; - /* This CONST_CAST is okay because lookup_attribute does not - modify its argument and the return value is assigned to a - const_tree. */ - for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), - CONST_CAST_TREE(l1)); - attr != NULL_TREE; - attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), - TREE_CHAIN (attr))) - { - if (TREE_VALUE (t2) != NULL - && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST - && TREE_VALUE (attr) != NULL - && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST) - { - if (simple_cst_list_equal (TREE_VALUE (t2), - TREE_VALUE (attr)) == 1) - break; - } - else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1) - break; - } - - if (attr == 0) - return 0; - } - - return 1; + (long) type_hash_table->size (), + (long) type_hash_table->elements (), + type_hash_table->collisions ()); } /* Given two lists of types @@ -6330,102 +6573,64 @@ if (TREE_CODE (t1) == INTEGER_CST && TREE_CODE (t2) == INTEGER_CST - && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) - && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)) + && wi::to_widest (t1) == wi::to_widest (t2)) return 1; return 0; } -/* Nonzero if integer constants T1 and T2 represent values that satisfy <. - The precise way of comparison depends on their data type. */ - -int -tree_int_cst_lt (const_tree t1, const_tree t2) -{ - if (t1 == t2) - return 0; - - if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2))) - { - int t1_sgn = tree_int_cst_sgn (t1); - int t2_sgn = tree_int_cst_sgn (t2); - - if (t1_sgn < t2_sgn) - return 1; - else if (t1_sgn > t2_sgn) - return 0; - /* Otherwise, both are non-negative, so we compare them as - unsigned just in case one of them would overflow a signed - type. */ - } - else if (!TYPE_UNSIGNED (TREE_TYPE (t1))) - return INT_CST_LT (t1, t2); - - return INT_CST_LT_UNSIGNED (t1, t2); -} - -/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */ +/* Return true if T is an INTEGER_CST whose numerical value (extended + according to TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. */ + +bool +tree_fits_shwi_p (const_tree t) +{ + return (t != NULL_TREE + && TREE_CODE (t) == INTEGER_CST + && wi::fits_shwi_p (wi::to_widest (t))); +} + +/* Return true if T is an INTEGER_CST whose numerical value (extended + according to TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. */ + +bool +tree_fits_uhwi_p (const_tree t) +{ + return (t != NULL_TREE + && TREE_CODE (t) == INTEGER_CST + && wi::fits_uhwi_p (wi::to_widest (t))); +} + +/* T is an INTEGER_CST whose numerical value (extended according to + TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that + HOST_WIDE_INT. */ + +HOST_WIDE_INT +tree_to_shwi (const_tree t) +{ + gcc_assert (tree_fits_shwi_p (t)); + return TREE_INT_CST_LOW (t); +} + +/* T is an INTEGER_CST whose numerical value (extended according to + TYPE_UNSIGNED) fits in an unsigned HOST_WIDE_INT. Return that + HOST_WIDE_INT. */ + +unsigned HOST_WIDE_INT +tree_to_uhwi (const_tree t) +{ + gcc_assert (tree_fits_uhwi_p (t)); + return TREE_INT_CST_LOW (t); +} + +/* Return the most significant (sign) bit of T. */ int -tree_int_cst_compare (const_tree t1, const_tree t2) -{ - if (tree_int_cst_lt (t1, t2)) - return -1; - else if (tree_int_cst_lt (t2, t1)) - return 1; - else - return 0; -} - -/* 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 - HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can - be represented in a single unsigned HOST_WIDE_INT. */ - -int -host_integerp (const_tree t, int pos) -{ - if (t == NULL_TREE) - return 0; - - return (TREE_CODE (t) == INTEGER_CST - && ((TREE_INT_CST_HIGH (t) == 0 - && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0) - || (! pos && TREE_INT_CST_HIGH (t) == -1 - && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0 - && (!TYPE_UNSIGNED (TREE_TYPE (t)) - || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (TREE_TYPE (t))))) - || (pos && TREE_INT_CST_HIGH (t) == 0))); -} - -/* 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 - be non-negative. We must be able to satisfy the above conditions. */ - -HOST_WIDE_INT -tree_low_cst (const_tree t, int pos) -{ - gcc_assert (host_integerp (t, pos)); - return TREE_INT_CST_LOW (t); -} - -/* Return the most significant bit of the integer constant T. */ - -int -tree_int_cst_msb (const_tree t) -{ - int prec; - HOST_WIDE_INT h; - unsigned HOST_WIDE_INT l; - - /* Note that using TYPE_PRECISION here is wrong. We care about the - actual bits, not the (arbitrary) range of the type. */ - prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1; - rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec, - 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0); - return (l & 1) == 1; +tree_int_cst_sign_bit (const_tree t) +{ + unsigned bitno = TYPE_PRECISION (TREE_TYPE (t)) - 1; + + return wi::extract_uhwi (wi::to_wide (t), bitno, 1); } /* Return an indication of the sign of the integer constant T. @@ -6435,11 +6640,11 @@ int tree_int_cst_sgn (const_tree t) { - if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0) + if (wi::to_wide (t) == 0) return 0; else if (TYPE_UNSIGNED (TREE_TYPE (t))) return 1; - else if (TREE_INT_CST_HIGH (t) < 0) + else if (wi::neg_p (wi::to_wide (t))) return -1; else return 1; @@ -6449,10 +6654,8 @@ signed or unsigned type, UNSIGNEDP says which. */ unsigned int -tree_int_cst_min_precision (tree value, bool unsignedp) -{ - int log; - +tree_int_cst_min_precision (tree value, signop sgn) +{ /* If the value is negative, compute its negative minus 1. The latter adjustment is because the absolute value of the largest negative value is one larger than the largest positive value. This is equivalent to @@ -6462,32 +6665,14 @@ value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value); /* Return the number of bits needed, taking into account the fact - that we need one more bit for a signed than unsigned type. */ + that we need one more bit for a signed than unsigned type. + If value is 0 or -1, the minimum precision is 1 no matter + whether unsignedp is true or false. */ if (integer_zerop (value)) - log = 0; + return 1; else - log = tree_floor_log2 (value); - - return log + 1 + !unsignedp; -} - -/* Compare two constructor-element-type constants. Return 1 if the lists - are known to be equal; otherwise return 0. */ - -int -simple_cst_list_equal (const_tree l1, const_tree l2) -{ - while (l1 != NULL_TREE && l2 != NULL_TREE) - { - if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1) - return 0; - - l1 = TREE_CHAIN (l1); - l2 = TREE_CHAIN (l2); - } - - return l1 == l2; + return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ; } /* Return truthvalue of whether T1 is the same tree structure as T2. @@ -6530,11 +6715,10 @@ switch (code1) { case INTEGER_CST: - return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) - && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)); + return wi::to_widest (t1) == wi::to_widest (t2); case REAL_CST: - return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); + return real_identical (&TREE_REAL_CST (t1), &TREE_REAL_CST (t2)); case FIXED_CST: return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2)); @@ -6547,16 +6731,15 @@ case CONSTRUCTOR: { unsigned HOST_WIDE_INT idx; - VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1); - VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2); - - if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2)) + vec<constructor_elt, va_gc> *v1 = CONSTRUCTOR_ELTS (t1); + vec<constructor_elt, va_gc> *v2 = CONSTRUCTOR_ELTS (t2); + + if (vec_safe_length (v1) != vec_safe_length (v2)) return false; - for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) + for (idx = 0; idx < vec_safe_length (v1); ++idx) /* ??? Should we handle also fields here? */ - if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value, - VEC_index (constructor_elt, v2, idx)->value)) + if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value)) return false; return true; } @@ -6668,7 +6851,7 @@ { if (tree_int_cst_sgn (t) < 0) return -1; - else if (TREE_INT_CST_HIGH (t) != 0) + else if (!tree_fits_uhwi_p (t)) return 1; else if (TREE_INT_CST_LOW (t) == u) return 0; @@ -6678,6 +6861,35 @@ return 1; } +/* Return true if SIZE represents a constant size that is in bounds of + what the middle-end and the backend accepts (covering not more than + half of the address-space). */ + +bool +valid_constant_size_p (const_tree size) +{ + if (! tree_fits_uhwi_p (size) + || TREE_OVERFLOW (size) + || tree_int_cst_sign_bit (size) != 0) + return false; + return true; +} + +/* Return the precision of the type, or for a complex or vector type the + precision of the type of its elements. */ + +unsigned int +element_precision (const_tree type) +{ + if (!TYPE_P (type)) + type = TREE_TYPE (type); + enum tree_code code = TREE_CODE (type); + if (code == COMPLEX_TYPE || code == VECTOR_TYPE) + type = TREE_TYPE (type); + + return TYPE_PRECISION (type); +} + /* Return true if CODE represents an associative tree code. Otherwise return false. */ bool @@ -6709,6 +6921,7 @@ { case PLUS_EXPR: case MULT_EXPR: + case MULT_HIGHPART_EXPR: case MIN_EXPR: case MAX_EXPR: case BIT_IOR_EXPR: @@ -6723,6 +6936,11 @@ case TRUTH_AND_EXPR: case TRUTH_XOR_EXPR: case TRUTH_OR_EXPR: + case WIDEN_MULT_EXPR: + case VEC_WIDEN_MULT_HI_EXPR: + case VEC_WIDEN_MULT_LO_EXPR: + case VEC_WIDEN_MULT_EVEN_EXPR: + case VEC_WIDEN_MULT_ODD_EXPR: return true; default: @@ -6740,6 +6958,8 @@ { case WIDEN_MULT_PLUS_EXPR: case WIDEN_MULT_MINUS_EXPR: + case DOT_PROD_EXPR: + case FMA_EXPR: return true; default: @@ -6748,21 +6968,98 @@ return false; } +/* Returns true if CODE can overflow. */ + +bool +operation_can_overflow (enum tree_code code) +{ + switch (code) + { + case PLUS_EXPR: + case MINUS_EXPR: + case MULT_EXPR: + case LSHIFT_EXPR: + /* Can overflow in various ways. */ + return true; + case TRUNC_DIV_EXPR: + case EXACT_DIV_EXPR: + case FLOOR_DIV_EXPR: + case CEIL_DIV_EXPR: + /* For INT_MIN / -1. */ + return true; + case NEGATE_EXPR: + case ABS_EXPR: + /* For -INT_MIN. */ + return true; + default: + /* These operators cannot overflow. */ + return false; + } +} + +/* Returns true if CODE operating on operands of type TYPE doesn't overflow, or + ftrapv doesn't generate trapping insns for CODE. */ + +bool +operation_no_trapping_overflow (tree type, enum tree_code code) +{ + gcc_checking_assert (ANY_INTEGRAL_TYPE_P (type)); + + /* We don't generate instructions that trap on overflow for complex or vector + types. */ + if (!INTEGRAL_TYPE_P (type)) + return true; + + if (!TYPE_OVERFLOW_TRAPS (type)) + return true; + + switch (code) + { + case PLUS_EXPR: + case MINUS_EXPR: + case MULT_EXPR: + case NEGATE_EXPR: + case ABS_EXPR: + /* These operators can overflow, and -ftrapv generates trapping code for + these. */ + return false; + case TRUNC_DIV_EXPR: + case EXACT_DIV_EXPR: + case FLOOR_DIV_EXPR: + case CEIL_DIV_EXPR: + case LSHIFT_EXPR: + /* These operators can overflow, but -ftrapv does not generate trapping + code for these. */ + return true; + default: + /* These operators cannot overflow. */ + return true; + } +} + +namespace inchash +{ + /* 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 HSTATE argument. This function is intended to produce the same hash for expressions which would compare equal using operand_equal_p. */ - -hashval_t -iterative_hash_expr (const_tree t, hashval_t val) +void +add_expr (const_tree t, inchash::hash &hstate, unsigned int flags) { int i; enum tree_code code; - char tclass; - - if (t == NULL_TREE) - return iterative_hash_hashval_t (0, val); + enum tree_code_class tclass; + + if (t == NULL_TREE || t == error_mark_node) + { + hstate.merge_hash (0); + return; + } + + if (!(flags & OEP_ADDRESS_OF)) + STRIP_NOPS (t); code = TREE_CODE (t); @@ -6770,67 +7067,86 @@ { /* Alas, constants aren't shared, so we can't rely on pointer identity. */ + case VOID_CST: + hstate.merge_hash (0); + return; case INTEGER_CST: - val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val); - return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val); + gcc_checking_assert (!(flags & OEP_ADDRESS_OF)); + for (i = 0; i < TREE_INT_CST_EXT_NUNITS (t); i++) + hstate.add_hwi (TREE_INT_CST_ELT (t, i)); + return; case REAL_CST: { - unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t)); - - return iterative_hash_hashval_t (val2, val); + unsigned int val2; + if (!HONOR_SIGNED_ZEROS (t) && real_zerop (t)) + val2 = rvc_zero; + else + val2 = real_hash (TREE_REAL_CST_PTR (t)); + hstate.merge_hash (val2); + return; } case FIXED_CST: { unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t)); - - return iterative_hash_hashval_t (val2, val); + hstate.merge_hash (val2); + return; } case STRING_CST: - return iterative_hash (TREE_STRING_POINTER (t), - TREE_STRING_LENGTH (t), val); + hstate.add ((const void *) TREE_STRING_POINTER (t), + TREE_STRING_LENGTH (t)); + return; case COMPLEX_CST: - val = iterative_hash_expr (TREE_REALPART (t), val); - return iterative_hash_expr (TREE_IMAGPART (t), val); + inchash::add_expr (TREE_REALPART (t), hstate, flags); + inchash::add_expr (TREE_IMAGPART (t), hstate, flags); + return; case VECTOR_CST: - return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val); + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (t); ++i) + inchash::add_expr (VECTOR_CST_ELT (t, i), hstate, flags); + return; + } case SSA_NAME: /* We can just compare by pointer. */ - return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val); + hstate.add_hwi (SSA_NAME_VERSION (t)); + return; case PLACEHOLDER_EXPR: /* The node itself doesn't matter. */ - return val; + return; + case BLOCK: + case OMP_CLAUSE: + /* Ignore. */ + return; case TREE_LIST: /* A list of expressions, for a CALL_EXPR or as the elements of a VECTOR_CST. */ for (; t; t = TREE_CHAIN (t)) - val = iterative_hash_expr (TREE_VALUE (t), val); - return val; + inchash::add_expr (TREE_VALUE (t), hstate, flags); + return; case CONSTRUCTOR: { unsigned HOST_WIDE_INT idx; tree field, value; + flags &= ~OEP_ADDRESS_OF; FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value) { - val = iterative_hash_expr (field, val); - val = iterative_hash_expr (value, val); + inchash::add_expr (field, hstate, flags); + inchash::add_expr (value, hstate, flags); } - return val; + return; } - case MEM_REF: + case STATEMENT_LIST: { - /* The type of the second operand is relevant, except for - its top-level qualifiers. */ - tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (t, 1))); - - val = iterative_hash_object (TYPE_HASH (type), val); - - /* We could use the standard hash computation from this point - on. */ - val = iterative_hash_object (code, val); - val = iterative_hash_expr (TREE_OPERAND (t, 1), val); - val = iterative_hash_expr (TREE_OPERAND (t, 0), val); - return val; + tree_stmt_iterator i; + for (i = tsi_start (CONST_CAST_TREE (t)); + !tsi_end_p (i); tsi_next (&i)) + inchash::add_expr (tsi_stmt (i), hstate, flags); + return; } + case TREE_VEC: + for (i = 0; i < TREE_VEC_LENGTH (t); ++i) + inchash::add_expr (TREE_VEC_ELT (t, i), hstate, flags); + return; case FUNCTION_DECL: /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form. Otherwise nodes that compare equal according to operand_equal_p might @@ -6838,9 +7154,9 @@ or front end builtins, since the function code is overloaded in those cases. */ if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL - && built_in_decls[DECL_FUNCTION_CODE (t)]) - { - t = built_in_decls[DECL_FUNCTION_CODE (t)]; + && builtin_decl_explicit_p (DECL_FUNCTION_CODE (t))) + { + t = builtin_decl_explicit (DECL_FUNCTION_CODE (t)); code = TREE_CODE (t); } /* FALL THROUGH */ @@ -6850,23 +7166,114 @@ if (tclass == tcc_declaration) { /* DECL's have a unique ID */ - val = iterative_hash_host_wide_int (DECL_UID (t), val); - } + hstate.add_hwi (DECL_UID (t)); + } + else if (tclass == tcc_comparison && !commutative_tree_code (code)) + { + /* For comparisons that can be swapped, use the lower + tree code. */ + enum tree_code ccode = swap_tree_comparison (code); + if (code < ccode) + ccode = code; + hstate.add_object (ccode); + inchash::add_expr (TREE_OPERAND (t, ccode != code), hstate, flags); + inchash::add_expr (TREE_OPERAND (t, ccode == code), hstate, flags); + } + else if (CONVERT_EXPR_CODE_P (code)) + { + /* NOP_EXPR and CONVERT_EXPR are considered equal by + operand_equal_p. */ + enum tree_code ccode = NOP_EXPR; + hstate.add_object (ccode); + + /* Don't hash the type, that can lead to having nodes which + compare equal according to operand_equal_p, but which + have different hash codes. Make sure to include signedness + in the hash computation. */ + hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t))); + inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags); + } + /* For OEP_ADDRESS_OF, hash MEM_EXPR[&decl, 0] the same as decl. */ + else if (code == MEM_REF + && (flags & OEP_ADDRESS_OF) != 0 + && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR + && DECL_P (TREE_OPERAND (TREE_OPERAND (t, 0), 0)) + && integer_zerop (TREE_OPERAND (t, 1))) + inchash::add_expr (TREE_OPERAND (TREE_OPERAND (t, 0), 0), + hstate, flags); + /* Don't ICE on FE specific trees, or their arguments etc. + during operand_equal_p hash verification. */ + else if (!IS_EXPR_CODE_CLASS (tclass)) + gcc_assert (flags & OEP_HASH_CHECK); else { - gcc_assert (IS_EXPR_CODE_CLASS (tclass)); - - val = iterative_hash_object (code, val); + unsigned int sflags = flags; + + hstate.add_object (code); + + switch (code) + { + case ADDR_EXPR: + gcc_checking_assert (!(flags & OEP_ADDRESS_OF)); + flags |= OEP_ADDRESS_OF; + sflags = flags; + break; + + case INDIRECT_REF: + case MEM_REF: + case TARGET_MEM_REF: + flags &= ~OEP_ADDRESS_OF; + sflags = flags; + break; + + case ARRAY_REF: + case ARRAY_RANGE_REF: + case COMPONENT_REF: + case BIT_FIELD_REF: + sflags &= ~OEP_ADDRESS_OF; + break; + + case COND_EXPR: + flags &= ~OEP_ADDRESS_OF; + break; + + case FMA_EXPR: + case WIDEN_MULT_PLUS_EXPR: + case WIDEN_MULT_MINUS_EXPR: + { + /* The multiplication operands are commutative. */ + inchash::hash one, two; + inchash::add_expr (TREE_OPERAND (t, 0), one, flags); + inchash::add_expr (TREE_OPERAND (t, 1), two, flags); + hstate.add_commutative (one, two); + inchash::add_expr (TREE_OPERAND (t, 2), two, flags); + return; + } + + case CALL_EXPR: + if (CALL_EXPR_FN (t) == NULL_TREE) + hstate.add_int (CALL_EXPR_IFN (t)); + break; + + case TARGET_EXPR: + /* For TARGET_EXPR, just hash on the TARGET_EXPR_SLOT. + Usually different TARGET_EXPRs just should use + different temporaries in their slots. */ + inchash::add_expr (TARGET_EXPR_SLOT (t), hstate, flags); + return; + + default: + break; + } /* Don't hash the type, that can lead to having nodes which compare equal according to operand_equal_p, but which have different hash codes. */ - if (CONVERT_EXPR_CODE_P (code) - || code == NON_LVALUE_EXPR) + if (code == NON_LVALUE_EXPR) { /* Make sure to include signness in the hash computation. */ - val += TYPE_UNSIGNED (TREE_TYPE (t)); - val = iterative_hash_expr (TREE_OPERAND (t, 0), val); + hstate.add_int (TYPE_UNSIGNED (TREE_TYPE (t))); + inchash::add_expr (TREE_OPERAND (t, 0), hstate, flags); } else if (commutative_tree_code (code)) @@ -6875,48 +7282,22 @@ however it appears. We do this by first hashing both operands and then rehashing based on the order of their independent hashes. */ - hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0); - hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0); - hashval_t t; - - if (one > two) - t = one, one = two, two = t; - - val = iterative_hash_hashval_t (one, val); - val = iterative_hash_hashval_t (two, val); + inchash::hash one, two; + inchash::add_expr (TREE_OPERAND (t, 0), one, flags); + inchash::add_expr (TREE_OPERAND (t, 1), two, flags); + hstate.add_commutative (one, two); } else for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i) - val = iterative_hash_expr (TREE_OPERAND (t, i), val); - } - return val; - break; - } -} - -/* Generate a hash value for a pair of expressions. This can be used - iteratively by passing a previous result as the VAL argument. - - The same hash value is always returned for a given pair of expressions, - regardless of the order in which they are presented. This is useful in - hashing the operands of commutative functions. */ - -hashval_t -iterative_hash_exprs_commutative (const_tree t1, - const_tree t2, hashval_t val) -{ - hashval_t one = iterative_hash_expr (t1, 0); - hashval_t two = iterative_hash_expr (t2, 0); - hashval_t t; - - if (one > two) - t = one, one = two, two = t; - val = iterative_hash_hashval_t (one, val); - val = iterative_hash_hashval_t (two, val); - - return val; -} - + inchash::add_expr (TREE_OPERAND (t, i), hstate, + i == 0 ? flags : sflags); + } + return; + } +} + +} + /* Constructors for pointer, array and function types. (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are constructed by language-dependent code, not here.) */ @@ -6927,10 +7308,11 @@ constructed, reuse it. */ tree -build_pointer_type_for_mode (tree to_type, enum machine_mode mode, +build_pointer_type_for_mode (tree to_type, machine_mode mode, bool can_alias_all) { tree t; + bool could_alias = can_alias_all; if (to_type == error_mark_node) return error_mark_node; @@ -6966,12 +7348,13 @@ TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type); TYPE_POINTER_TO (to_type) = t; - if (TYPE_STRUCTURAL_EQUALITY_P (to_type)) + /* During LTO we do not set TYPE_CANONICAL of pointers and references. */ + if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p) SET_TYPE_STRUCTURAL_EQUALITY (t); - else if (TYPE_CANONICAL (to_type) != to_type) + else if (TYPE_CANONICAL (to_type) != to_type || could_alias) TYPE_CANONICAL (t) = build_pointer_type_for_mode (TYPE_CANONICAL (to_type), - mode, can_alias_all); + mode, false); /* Lay out the type. This function has many callers that are concerned with expression-construction, and this simplifies them all. */ @@ -6987,17 +7370,18 @@ { addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC : TYPE_ADDR_SPACE (to_type); - enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); + machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); return build_pointer_type_for_mode (to_type, pointer_mode, false); } /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */ tree -build_reference_type_for_mode (tree to_type, enum machine_mode mode, +build_reference_type_for_mode (tree to_type, machine_mode mode, bool can_alias_all) { tree t; + bool could_alias = can_alias_all; if (to_type == error_mark_node) return error_mark_node; @@ -7033,12 +7417,13 @@ TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type); TYPE_REFERENCE_TO (to_type) = t; - if (TYPE_STRUCTURAL_EQUALITY_P (to_type)) + /* During LTO we do not set TYPE_CANONICAL of pointers and references. */ + if (TYPE_STRUCTURAL_EQUALITY_P (to_type) || in_lto_p) SET_TYPE_STRUCTURAL_EQUALITY (t); - else if (TYPE_CANONICAL (to_type) != to_type) + else if (TYPE_CANONICAL (to_type) != to_type || could_alias) TYPE_CANONICAL (t) = build_reference_type_for_mode (TYPE_CANONICAL (to_type), - mode, can_alias_all); + mode, false); layout_type (t); @@ -7054,34 +7439,10 @@ { addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC : TYPE_ADDR_SPACE (to_type); - enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); + machine_mode pointer_mode = targetm.addr_space.pointer_mode (as); return build_reference_type_for_mode (to_type, pointer_mode, false); } -/* Build a type that is compatible with t but has no cv quals anywhere - in its type, thus - - const char *const *const * -> char ***. */ - -tree -build_type_no_quals (tree t) -{ - switch (TREE_CODE (t)) - { - case POINTER_TYPE: - return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)), - TYPE_MODE (t), - TYPE_REF_CAN_ALIAS_ALL (t)); - case REFERENCE_TYPE: - return - build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)), - TYPE_MODE (t), - TYPE_REF_CAN_ALIAS_ALL (t)); - default: - return TYPE_MAIN_VARIANT (t); - } -} - #define MAX_INT_CACHED_PREC \ (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64) static GTY(()) tree nonstandard_integer_type_cache[2 * MAX_INT_CACHED_PREC + 2]; @@ -7114,14 +7475,42 @@ fixup_signed_type (itype); ret = itype; - if (host_integerp (TYPE_MAX_VALUE (itype), 1)) - ret = type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype); + if (tree_fits_uhwi_p (TYPE_MAX_VALUE (itype))) + ret = type_hash_canon (tree_to_uhwi (TYPE_MAX_VALUE (itype)), itype); if (precision <= MAX_INT_CACHED_PREC) nonstandard_integer_type_cache[precision + unsignedp] = ret; return ret; } +#define MAX_BOOL_CACHED_PREC \ + (HOST_BITS_PER_WIDE_INT > 64 ? HOST_BITS_PER_WIDE_INT : 64) +static GTY(()) tree nonstandard_boolean_type_cache[MAX_BOOL_CACHED_PREC + 1]; + +/* Builds a boolean type of precision PRECISION. + Used for boolean vectors to choose proper vector element size. */ +tree +build_nonstandard_boolean_type (unsigned HOST_WIDE_INT precision) +{ + tree type; + + if (precision <= MAX_BOOL_CACHED_PREC) + { + type = nonstandard_boolean_type_cache[precision]; + if (type) + return type; + } + + type = make_node (BOOLEAN_TYPE); + TYPE_PRECISION (type) = precision; + fixup_signed_type (type); + + if (precision <= MAX_INT_CACHED_PREC) + nonstandard_boolean_type_cache[precision] = type; + + return type; +} + /* Create a range of some discrete type TYPE (an INTEGER_TYPE, ENUMERAL_TYPE or BOOLEAN_TYPE) with low bound LOWVAL and high bound HIGHVAL. If SHARED is true, reuse such a type that has already been constructed. */ @@ -7130,7 +7519,6 @@ build_range_type_1 (tree type, tree lowval, tree highval, bool shared) { tree itype = make_node (INTEGER_TYPE); - hashval_t hashcode = 0; TREE_TYPE (itype) = type; @@ -7141,8 +7529,9 @@ SET_TYPE_MODE (itype, TYPE_MODE (type)); TYPE_SIZE (itype) = TYPE_SIZE (type); TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type); - TYPE_ALIGN (itype) = TYPE_ALIGN (type); + SET_TYPE_ALIGN (itype, TYPE_ALIGN (type)); TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type); + SET_TYPE_WARN_IF_NOT_ALIGN (itype, TYPE_WARN_IF_NOT_ALIGN (type)); if (!shared) return itype; @@ -7158,10 +7547,8 @@ return itype; } - hashcode = iterative_hash_expr (TYPE_MIN_VALUE (itype), hashcode); - hashcode = iterative_hash_expr (TYPE_MAX_VALUE (itype), hashcode); - hashcode = iterative_hash_hashval_t (TYPE_HASH (type), hashcode); - itype = type_hash_canon (hashcode, itype); + hashval_t hash = type_hash_canon_hash (itype); + itype = type_hash_canon (hash, itype); return itype; } @@ -7226,20 +7613,9 @@ || TREE_CODE (base_type) == BOOLEAN_TYPE) && int_size_in_bytes (type) == int_size_in_bytes (base_type) && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type)) - && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type))) - { - tree type_name = TYPE_NAME (type); - tree base_type_name = TYPE_NAME (base_type); - - if (type_name && TREE_CODE (type_name) == TYPE_DECL) - type_name = DECL_NAME (type_name); - - if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL) - base_type_name = DECL_NAME (base_type_name); - - if (type_name == base_type_name) - return false; - } + && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)) + && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type)) + return false; if (lowval) *lowval = low; @@ -7250,10 +7626,12 @@ /* 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. + If TYPELESS_STORAGE is true, TYPE_TYPELESS_STORAGE flag is set on the type. If SHARED is true, reuse such a type that has already been constructed. */ static tree -build_array_type_1 (tree elt_type, tree index_type, bool shared) +build_array_type_1 (tree elt_type, tree index_type, bool typeless_storage, + bool shared) { tree t; @@ -7267,6 +7645,7 @@ TREE_TYPE (t) = elt_type; TYPE_DOMAIN (t) = index_type; TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type); + TYPE_TYPELESS_STORAGE (t) = typeless_storage; layout_type (t); /* If the element type is incomplete at this point we get marked for @@ -7277,16 +7656,15 @@ if (shared) { - hashval_t hashcode = iterative_hash_object (TYPE_HASH (elt_type), 0); - if (index_type) - hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode); - t = type_hash_canon (hashcode, t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); } if (TYPE_CANONICAL (t) == t) { if (TYPE_STRUCTURAL_EQUALITY_P (elt_type) - || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type))) + || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)) + || in_lto_p) SET_TYPE_STRUCTURAL_EQUALITY (t); else if (TYPE_CANONICAL (elt_type) != elt_type || (index_type && TYPE_CANONICAL (index_type) != index_type)) @@ -7294,7 +7672,7 @@ = build_array_type_1 (TYPE_CANONICAL (elt_type), index_type ? TYPE_CANONICAL (index_type) : NULL_TREE, - shared); + typeless_storage, shared); } return t; @@ -7303,9 +7681,9 @@ /* Wrapper around build_array_type_1 with SHARED set to true. */ tree -build_array_type (tree elt_type, tree index_type) -{ - return build_array_type_1 (elt_type, index_type, true); +build_array_type (tree elt_type, tree index_type, bool typeless_storage) +{ + return build_array_type_1 (elt_type, index_type, typeless_storage, true); } /* Wrapper around build_array_type_1 with SHARED set to false. */ @@ -7313,7 +7691,16 @@ tree build_nonshared_array_type (tree elt_type, tree index_type) { - return build_array_type_1 (elt_type, index_type, false); + return build_array_type_1 (elt_type, index_type, false, false); +} + +/* Return a representation of ELT_TYPE[NELTS], using indices of type + sizetype. */ + +tree +build_array_type_nelts (tree elt_type, unsigned HOST_WIDE_INT nelts) +{ + return build_array_type (elt_type, build_index_type (size_int (nelts - 1))); } /* Recursively examines the array elements of TYPE, until a non-array @@ -7344,9 +7731,9 @@ true) or would not differ from ARGTYPES. */ static tree -maybe_canonicalize_argtypes(tree argtypes, - bool *any_structural_p, - bool *any_noncanonical_p) +maybe_canonicalize_argtypes (tree argtypes, + bool *any_structural_p, + bool *any_noncanonical_p) { tree arg; bool any_noncanonical_argtypes_p = false; @@ -7411,7 +7798,7 @@ build_function_type (tree value_type, tree arg_types) { tree t; - hashval_t hashcode = 0; + inchash::hash hstate; bool any_structural_p, any_noncanonical_p; tree canon_argtypes; @@ -7427,9 +7814,8 @@ TYPE_ARG_TYPES (t) = arg_types; /* If we already have such a type, use the old one. */ - hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode); - hashcode = type_hash_list (arg_types, hashcode); - t = type_hash_canon (hashcode, t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); /* Set up the canonical type. */ any_structural_p = TYPE_STRUCTURAL_EQUALITY_P (value_type); @@ -7448,100 +7834,9 @@ return t; } -/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP. */ - -tree -build_function_type_skip_args (tree orig_type, bitmap args_to_skip) -{ - tree new_type = NULL; - tree args, new_args = NULL, t; - tree new_reversed; - int i = 0; - - for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node; - args = TREE_CHAIN (args), i++) - if (!bitmap_bit_p (args_to_skip, i)) - new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args); - - new_reversed = nreverse (new_args); - if (args) - { - if (new_reversed) - TREE_CHAIN (new_args) = void_list_node; - else - new_reversed = void_list_node; - } - - /* Use copy_node to preserve as much as possible from original type - (debug info, attribute lists etc.) - Exception is METHOD_TYPEs must have THIS argument. - When we are asked to remove it, we need to build new FUNCTION_TYPE - instead. */ - if (TREE_CODE (orig_type) != METHOD_TYPE - || !bitmap_bit_p (args_to_skip, 0)) - { - new_type = build_distinct_type_copy (orig_type); - TYPE_ARG_TYPES (new_type) = new_reversed; - } - else - { - new_type - = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type), - new_reversed)); - TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type); - } - - /* This is a new type, not a copy of an old type. Need to reassociate - variants. We can handle everything except the main variant lazily. */ - t = TYPE_MAIN_VARIANT (orig_type); - if (orig_type != t) - { - TYPE_MAIN_VARIANT (new_type) = t; - TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t); - TYPE_NEXT_VARIANT (t) = new_type; - } - else - { - TYPE_MAIN_VARIANT (new_type) = new_type; - TYPE_NEXT_VARIANT (new_type) = NULL; - } - return new_type; -} - -/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP. - - Arguments from DECL_ARGUMENTS list can't be removed now, since they are - linked by TREE_CHAIN directly. The caller is responsible for eliminating - them when they are being duplicated (i.e. copy_arguments_for_versioning). */ - -tree -build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip) -{ - tree new_decl = copy_node (orig_decl); - tree new_type; - - new_type = TREE_TYPE (orig_decl); - if (prototype_p (new_type)) - new_type = build_function_type_skip_args (new_type, args_to_skip); - TREE_TYPE (new_decl) = new_type; - - /* For declarations setting DECL_VINDEX (i.e. methods) - we expect first argument to be THIS pointer. */ - if (bitmap_bit_p (args_to_skip, 0)) - DECL_VINDEX (new_decl) = NULL_TREE; - - /* When signature changes, we need to clear builtin info. */ - if (DECL_BUILT_IN (new_decl) && !bitmap_empty_p (args_to_skip)) - { - DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN; - DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0; - } - return new_decl; -} - /* Build a function type. The RETURN_TYPE is the type returned by the function. If VAARGS is set, no void_type_node is appended to the - the list. ARGP must be always be terminated be a NULL_TREE. */ + list. ARGP must be always be terminated be a NULL_TREE. */ static tree build_function_type_list_1 (bool vaargs, tree return_type, va_list argp) @@ -7607,6 +7902,44 @@ return args; } +/* Build a function type. RETURN_TYPE is the type returned by the + function; VAARGS indicates whether the function takes varargs. The + function takes N named arguments, the types of which are provided in + ARG_TYPES. */ + +static tree +build_function_type_array_1 (bool vaargs, tree return_type, int n, + tree *arg_types) +{ + int i; + tree t = vaargs ? NULL_TREE : void_list_node; + + for (i = n - 1; i >= 0; i--) + t = tree_cons (NULL_TREE, arg_types[i], t); + + return build_function_type (return_type, t); +} + +/* Build a function type. RETURN_TYPE is the type returned by the + function. The function takes N named arguments, the types of which + are provided in ARG_TYPES. */ + +tree +build_function_type_array (tree return_type, int n, tree *arg_types) +{ + return build_function_type_array_1 (false, return_type, n, arg_types); +} + +/* Build a variable argument function type. RETURN_TYPE is the type + returned by the function. The function takes N named arguments, the + types of which are provided in ARG_TYPES. */ + +tree +build_varargs_function_type_array (tree return_type, int n, tree *arg_types) +{ + return build_function_type_array_1 (true, return_type, n, arg_types); +} + /* 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 for the method. An implicit additional parameter (of type @@ -7619,7 +7952,6 @@ { tree t; tree ptype; - int hashcode = 0; bool any_structural_p, any_noncanonical_p; tree canon_argtypes; @@ -7636,10 +7968,8 @@ TYPE_ARG_TYPES (t) = argtypes; /* 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 (rettype), hashcode); - hashcode = type_hash_list (argtypes, hashcode); - t = type_hash_canon (hashcode, t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); /* Set up the canonical type. */ any_structural_p @@ -7687,7 +8017,6 @@ build_offset_type (tree basetype, tree type) { tree t; - hashval_t hashcode = 0; /* Make a node of the sort we want. */ t = make_node (OFFSET_TYPE); @@ -7696,9 +8025,8 @@ TREE_TYPE (t) = type; /* 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 (type), hashcode); - t = type_hash_canon (hashcode, t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); if (!COMPLETE_TYPE_P (t)) layout_type (t); @@ -7718,13 +8046,17 @@ return t; } -/* Create a complex type whose components are COMPONENT_TYPE. */ - -tree -build_complex_type (tree component_type) +/* Create a complex type whose components are COMPONENT_TYPE. + + If NAMED is true, the type is given a TYPE_NAME. We do not always + do so because this creates a DECL node and thus make the DECL_UIDs + dependent on the type canonicalization hashtable, which is GC-ed, + so the DECL_UIDs would not be stable wrt garbage collection. */ + +tree +build_complex_type (tree component_type, bool named) { tree t; - hashval_t hashcode; gcc_assert (INTEGRAL_TYPE_P (component_type) || SCALAR_FLOAT_TYPE_P (component_type) @@ -7736,8 +8068,8 @@ TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type); /* If we already have such a type, use the old one. */ - hashcode = iterative_hash_object (TYPE_HASH (component_type), 0); - t = type_hash_canon (hashcode, t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); if (!COMPLETE_TYPE_P (t)) layout_type (t); @@ -7748,11 +8080,11 @@ SET_TYPE_STRUCTURAL_EQUALITY (t); else if (TYPE_CANONICAL (component_type) != component_type) TYPE_CANONICAL (t) - = build_complex_type (TYPE_CANONICAL (component_type)); + = build_complex_type (TYPE_CANONICAL (component_type), named); } /* We need to create a name, since complex is a fundamental type. */ - if (! TYPE_NAME (t)) + if (!TYPE_NAME (t) && named) { const char *name; if (component_type == char_type_node) @@ -7796,50 +8128,99 @@ tree excess_precision_type (tree type) { - if (flag_excess_precision != EXCESS_PRECISION_FAST) - { - int flt_eval_method = TARGET_FLT_EVAL_METHOD; - switch (TREE_CODE (type)) - { - case REAL_TYPE: - switch (flt_eval_method) - { - case 1: - if (TYPE_MODE (type) == TYPE_MODE (float_type_node)) - return double_type_node; - break; - case 2: - if (TYPE_MODE (type) == TYPE_MODE (float_type_node) - || TYPE_MODE (type) == TYPE_MODE (double_type_node)) - return long_double_type_node; - break; - default: - gcc_unreachable (); - } - break; - case COMPLEX_TYPE: - if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE) - return NULL_TREE; - switch (flt_eval_method) - { - case 1: - if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)) - return complex_double_type_node; - break; - case 2: - if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node) - || (TYPE_MODE (TREE_TYPE (type)) - == TYPE_MODE (double_type_node))) - return complex_long_double_type_node; - break; - default: - gcc_unreachable (); - } - break; - default: - break; - } - } + /* The target can give two different responses to the question of + which excess precision mode it would like depending on whether we + are in -fexcess-precision=standard or -fexcess-precision=fast. */ + + enum excess_precision_type requested_type + = (flag_excess_precision == EXCESS_PRECISION_FAST + ? EXCESS_PRECISION_TYPE_FAST + : EXCESS_PRECISION_TYPE_STANDARD); + + enum flt_eval_method target_flt_eval_method + = targetm.c.excess_precision (requested_type); + + /* The target should not ask for unpredictable float evaluation (though + it might advertise that implicitly the evaluation is unpredictable, + but we don't care about that here, it will have been reported + elsewhere). If it does ask for unpredictable evaluation, we have + nothing to do here. */ + gcc_assert (target_flt_eval_method != FLT_EVAL_METHOD_UNPREDICTABLE); + + /* Nothing to do. The target has asked for all types we know about + to be computed with their native precision and range. */ + if (target_flt_eval_method == FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16) + return NULL_TREE; + + /* The target will promote this type in a target-dependent way, so excess + precision ought to leave it alone. */ + if (targetm.promoted_type (type) != NULL_TREE) + return NULL_TREE; + + machine_mode float16_type_mode = (float16_type_node + ? TYPE_MODE (float16_type_node) + : VOIDmode); + machine_mode float_type_mode = TYPE_MODE (float_type_node); + machine_mode double_type_mode = TYPE_MODE (double_type_node); + + switch (TREE_CODE (type)) + { + case REAL_TYPE: + { + machine_mode type_mode = TYPE_MODE (type); + switch (target_flt_eval_method) + { + case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT: + if (type_mode == float16_type_mode) + return float_type_node; + break; + case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE: + if (type_mode == float16_type_mode + || type_mode == float_type_mode) + return double_type_node; + break; + case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE: + if (type_mode == float16_type_mode + || type_mode == float_type_mode + || type_mode == double_type_mode) + return long_double_type_node; + break; + default: + gcc_unreachable (); + } + break; + } + case COMPLEX_TYPE: + { + if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE) + return NULL_TREE; + machine_mode type_mode = TYPE_MODE (TREE_TYPE (type)); + switch (target_flt_eval_method) + { + case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT: + if (type_mode == float16_type_mode) + return complex_float_type_node; + break; + case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE: + if (type_mode == float16_type_mode + || type_mode == float_type_mode) + return complex_double_type_node; + break; + case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE: + if (type_mode == float16_type_mode + || type_mode == float_type_mode + || type_mode == double_type_mode) + return complex_long_double_type_node; + break; + default: + gcc_unreachable (); + } + break; + } + default: + break; + } + return NULL_TREE; } @@ -7921,13 +8302,21 @@ } } - /* If we finally reach a constant see if it fits in for_type and + /* If we finally reach a constant see if it fits in sth smaller and in that case convert it. */ - if (for_type - && TREE_CODE (win) == INTEGER_CST - && TREE_TYPE (win) != for_type - && int_fits_type_p (win, for_type)) - win = fold_convert (for_type, win); + if (TREE_CODE (win) == INTEGER_CST) + { + tree wtype = TREE_TYPE (win); + unsigned prec = wi::min_precision (wi::to_wide (win), TYPE_SIGN (wtype)); + if (for_type) + prec = MAX (prec, final_prec); + if (prec < TYPE_PRECISION (wtype)) + { + tree t = lang_hooks.types.type_for_size (prec, TYPE_UNSIGNED (wtype)); + if (t && TYPE_PRECISION (t) < TYPE_PRECISION (wtype)) + win = fold_convert (t, win); + } + } return win; } @@ -7995,10 +8384,10 @@ && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE /* Ensure field is laid out already. */ && DECL_SIZE (TREE_OPERAND (op, 1)) != 0 - && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1)) + && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1)))) { unsigned HOST_WIDE_INT innerprec - = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); + = tree_to_uhwi (DECL_SIZE (TREE_OPERAND (op, 1))); int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1)) || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); tree type = lang_hooks.types.type_for_size (innerprec, unsignedp); @@ -8026,30 +8415,20 @@ return win; } -/* Returns true if integer constant C has a value that is permissible - for type TYPE (an INTEGER_TYPE). */ +/* Return true if integer constant C has a value that is permissible + for TYPE, an integral type. */ bool int_fits_type_p (const_tree c, const_tree type) { tree type_low_bound, type_high_bound; - bool ok_for_low_bound, ok_for_high_bound, unsc; - double_int dc, dd; - - dc = tree_to_double_int (c); - unsc = TYPE_UNSIGNED (TREE_TYPE (c)); - - if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (TREE_TYPE (c)) - && unsc) - /* So c is an unsigned integer whose type is sizetype and type is not. - sizetype'd integers are sign extended even though they are - unsigned. If the integer value fits in the lower end word of c, - and if the higher end word has all its bits set to 1, that - means the higher end bits are set to 1 only for sign extension. - So let's convert c into an equivalent zero extended unsigned - integer. */ - dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c))); + bool ok_for_low_bound, ok_for_high_bound; + signop sgn_c = TYPE_SIGN (TREE_TYPE (c)); + + /* Non-standard boolean types can have arbitrary precision but various + transformations assume that they can only take values 0 and +/-1. */ + if (TREE_CODE (type) == BOOLEAN_TYPE) + return wi::fits_to_boolean_p (wi::to_wide (c), type); retry: type_low_bound = TYPE_MIN_VALUE (type); @@ -8058,7 +8437,7 @@ /* 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 this type is a subtype, try checking against that. Otherwise, use - double_int_fits_to_tree_p, which checks against the precision. + fits_to_tree_p, which checks against the precision. 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 @@ -8068,22 +8447,7 @@ /* Check if c >= type_low_bound. */ if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST) { - dd = tree_to_double_int (type_low_bound); - if (TREE_CODE (type) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (type) - && TYPE_UNSIGNED (type)) - dd = double_int_zext (dd, TYPE_PRECISION (type)); - if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound))) - { - int c_neg = (!unsc && double_int_negative_p (dc)); - int t_neg = (unsc && double_int_negative_p (dd)); - - if (c_neg && !t_neg) - return false; - if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0) - return false; - } - else if (double_int_cmp (dc, dd, unsc) < 0) + if (tree_int_cst_lt (c, type_low_bound)) return false; ok_for_low_bound = true; } @@ -8093,22 +8457,7 @@ /* Check if c <= type_high_bound. */ if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST) { - dd = tree_to_double_int (type_high_bound); - if (TREE_CODE (type) == INTEGER_TYPE - && TYPE_IS_SIZETYPE (type) - && TYPE_UNSIGNED (type)) - dd = double_int_zext (dd, TYPE_PRECISION (type)); - if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound))) - { - int c_neg = (!unsc && double_int_negative_p (dc)); - int t_neg = (unsc && double_int_negative_p (dd)); - - if (t_neg && !c_neg) - return false; - if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0) - return false; - } - else if (double_int_cmp (dc, dd, unsc) > 0) + if (tree_int_cst_lt (type_high_bound, c)) return false; ok_for_high_bound = true; } @@ -8122,7 +8471,7 @@ /* Perform some generic filtering which may allow making a decision even if the bounds are not constant. First, negative integers never fit in unsigned types, */ - if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc)) + if (TYPE_UNSIGNED (type) && sgn_c == SIGNED && wi::neg_p (wi::to_wide (c))) return false; /* Second, narrower types always fit in wider ones. */ @@ -8130,16 +8479,21 @@ return true; /* Third, unsigned integers with top bit set never fit signed types. */ - if (! TYPE_UNSIGNED (type) && unsc) - { - int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1; - if (prec < HOST_BITS_PER_WIDE_INT) - { - if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0) + if (!TYPE_UNSIGNED (type) && sgn_c == UNSIGNED) + { + int prec = GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (c))) - 1; + if (prec < TYPE_PRECISION (TREE_TYPE (c))) + { + /* When a tree_cst is converted to a wide-int, the precision + is taken from the type. However, if the precision of the + mode underneath the type is smaller than that, it is + possible that the value will not fit. The test below + fails if any bit is set between the sign bit of the + underlying mode and the top bit of the type. */ + if (wi::zext (wi::to_wide (c), prec - 1) != wi::to_wide (c)) return false; - } - else if (((((unsigned HOST_WIDE_INT) 1) - << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0) + } + else if (wi::neg_p (wi::to_wide (c))) return false; } @@ -8154,8 +8508,8 @@ goto retry; } - /* Or to double_int_fits_to_tree_p, if nothing else. */ - return double_int_fits_to_tree_p (type, dc); + /* Or to fits_to_tree_p, if nothing else. */ + return wi::fits_to_tree_p (wi::to_wide (c), type); } /* Stores bounds of an integer TYPE in MIN and MAX. If TYPE has non-constant @@ -8168,34 +8522,25 @@ { if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type) && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST) - mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)), - TYPE_UNSIGNED (type)); + wi::to_mpz (wi::to_wide (TYPE_MIN_VALUE (type)), min, TYPE_SIGN (type)); else { if (TYPE_UNSIGNED (type)) mpz_set_ui (min, 0); else { - double_int mn; - mn = double_int_mask (TYPE_PRECISION (type) - 1); - mn = double_int_sext (double_int_add (mn, double_int_one), - TYPE_PRECISION (type)); - mpz_set_double_int (min, mn, false); + wide_int mn = wi::min_value (TYPE_PRECISION (type), SIGNED); + wi::to_mpz (mn, min, SIGNED); } } if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type) && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST) - mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)), - TYPE_UNSIGNED (type)); + wi::to_mpz (wi::to_wide (TYPE_MAX_VALUE (type)), max, TYPE_SIGN (type)); else { - if (TYPE_UNSIGNED (type)) - mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)), - true); - else - mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1), - true); + wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type)); + wi::to_mpz (mn, max, TYPE_SIGN (type)); } } @@ -8205,7 +8550,7 @@ auto_var_in_fn_p (const_tree var, const_tree fn) { return (DECL_P (var) && DECL_CONTEXT (var) == fn - && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var)) + && ((((VAR_P (var) && ! DECL_EXTERNAL (var)) || TREE_CODE (var) == PARM_DECL) && ! TREE_STATIC (var)) || TREE_CODE (var) == LABEL_DECL @@ -8252,11 +8597,19 @@ tree t; /* Test if T is either variable (if FN is zero) or an expression containing - a variable in FN. */ + a variable in FN. If TYPE isn't gimplified, return true also if + gimplify_one_sizepos would gimplify the expression into a local + variable. */ #define RETURN_TRUE_IF_VAR(T) \ do { tree _t = (T); \ - if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \ - && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \ + if (_t != NULL_TREE \ + && _t != error_mark_node \ + && TREE_CODE (_t) != INTEGER_CST \ + && TREE_CODE (_t) != PLACEHOLDER_EXPR \ + && (!fn \ + || (!TYPE_SIZES_GIMPLIFIED (type) \ + && !is_gimple_sizepos (_t)) \ + || walk_tree (&_t, find_var_from_fn, fn, NULL))) \ return true; } while (0) if (type == error_mark_node) @@ -8271,8 +8624,16 @@ case POINTER_TYPE: case REFERENCE_TYPE: case VECTOR_TYPE: + /* Ada can have pointer types refering to themselves indirectly. */ + if (TREE_VISITED (type)) + return false; + TREE_VISITED (type) = true; if (variably_modified_type_p (TREE_TYPE (type), fn)) - return true; + { + TREE_VISITED (type) = false; + return true; + } + TREE_VISITED (type) = false; break; case FUNCTION_TYPE: @@ -8311,7 +8672,7 @@ if (TREE_CODE (type) == QUAL_UNION_TYPE) RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t)); } - break; + break; case ARRAY_TYPE: /* Do not call ourselves to avoid infinite recursion. This is @@ -8432,6 +8793,10 @@ called. */ addr = CALL_EXPR_FN (call); + /* If there is no function, return early. */ + if (addr == NULL_TREE) + return NULL_TREE; + STRIP_NOPS (addr); /* If this is a readonly function pointer, extract its initial value. */ @@ -8450,37 +8815,65 @@ return NULL_TREE; } +/* If CALL_EXPR CALL calls a normal built-in function or an internal function, + return the associated function code, otherwise return CFN_LAST. */ + +combined_fn +get_call_combined_fn (const_tree call) +{ + /* It's invalid to call this function with anything but a CALL_EXPR. */ + gcc_assert (TREE_CODE (call) == CALL_EXPR); + + if (!CALL_EXPR_FN (call)) + return as_combined_fn (CALL_EXPR_IFN (call)); + + tree fndecl = get_callee_fndecl (call); + if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL) + return as_combined_fn (DECL_FUNCTION_CODE (fndecl)); + + return CFN_LAST; +} + +#define TREE_MEM_USAGE_SPACES 40 + /* Print debugging information about tree nodes generated during the compile, and any language-specific information. */ void dump_tree_statistics (void) { -#ifdef GATHER_STATISTICS - int i; - int total_nodes, total_bytes; -#endif - - fprintf (stderr, "\n??? tree nodes created\n\n"); -#ifdef GATHER_STATISTICS - fprintf (stderr, "Kind Nodes Bytes\n"); - fprintf (stderr, "---------------------------------------\n"); - total_nodes = total_bytes = 0; - for (i = 0; i < (int) all_kinds; i++) - { - fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i], - tree_node_counts[i], tree_node_sizes[i]); - total_nodes += tree_node_counts[i]; - total_bytes += tree_node_sizes[i]; - } - fprintf (stderr, "---------------------------------------\n"); - fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes); - fprintf (stderr, "---------------------------------------\n"); - ssanames_print_statistics (); - phinodes_print_statistics (); -#else - fprintf (stderr, "(No per-node statistics)\n"); -#endif + if (GATHER_STATISTICS) + { + int i; + int total_nodes, total_bytes; + fprintf (stderr, "\nKind Nodes Bytes\n"); + mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES); + total_nodes = total_bytes = 0; + for (i = 0; i < (int) all_kinds; i++) + { + fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i], + tree_node_counts[i], tree_node_sizes[i]); + total_nodes += tree_node_counts[i]; + total_bytes += tree_node_sizes[i]; + } + mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES); + fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes); + mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES); + fprintf (stderr, "Code Nodes\n"); + mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES); + for (i = 0; i < (int) MAX_TREE_CODES; i++) + fprintf (stderr, "%-32s %7d\n", get_tree_code_name ((enum tree_code) i), + tree_code_counts[i]); + mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES); + fprintf (stderr, "\n"); + ssanames_print_statistics (); + fprintf (stderr, "\n"); + phinodes_print_statistics (); + fprintf (stderr, "\n"); + } + else + fprintf (stderr, "(No per-node statistics)\n"); + print_type_hash_statistics (); print_debug_expr_statistics (); print_value_expr_statistics (); @@ -8489,25 +8882,43 @@ #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" +/* Generate a crc32 of the low BYTES bytes of VALUE. */ + +unsigned +crc32_unsigned_n (unsigned chksum, unsigned value, unsigned bytes) +{ + /* This relies on the raw feedback's top 4 bits being zero. */ +#define FEEDBACK(X) ((X) * 0x04c11db7) +#define SYNDROME(X) (FEEDBACK ((X) & 1) ^ FEEDBACK ((X) & 2) \ + ^ FEEDBACK ((X) & 4) ^ FEEDBACK ((X) & 8)) + static const unsigned syndromes[16] = + { + SYNDROME(0x0), SYNDROME(0x1), SYNDROME(0x2), SYNDROME(0x3), + SYNDROME(0x4), SYNDROME(0x5), SYNDROME(0x6), SYNDROME(0x7), + SYNDROME(0x8), SYNDROME(0x9), SYNDROME(0xa), SYNDROME(0xb), + SYNDROME(0xc), SYNDROME(0xd), SYNDROME(0xe), SYNDROME(0xf), + }; +#undef FEEDBACK +#undef SYNDROME + + value <<= (32 - bytes * 8); + for (unsigned ix = bytes * 2; ix--; value <<= 4) + { + unsigned feedback = syndromes[((value ^ chksum) >> 28) & 0xf]; + + chksum = (chksum << 4) ^ feedback; + } + + return chksum; +} + /* Generate a crc32 of a string. */ unsigned crc32_string (unsigned chksum, const char *string) { do - { - unsigned value = *string << 24; - unsigned ix; - - for (ix = 8; ix--; value <<= 1) - { - unsigned feedback; - - feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0; - chksum <<= 1; - chksum ^= feedback; - } - } + chksum = crc32_byte (chksum, *string); while (*string++); return chksum; } @@ -8530,8 +8941,46 @@ *p = '_'; } -/* Generate a name for a special-purpose function function. +/* For anonymous aggregate types, we need some sort of name to + hold on to. In practice, this should not appear, but it should + not be harmful if it does. */ +bool +anon_aggrname_p(const_tree id_node) +{ +#ifndef NO_DOT_IN_LABEL + return (IDENTIFIER_POINTER (id_node)[0] == '.' + && IDENTIFIER_POINTER (id_node)[1] == '_'); +#else /* NO_DOT_IN_LABEL */ +#ifndef NO_DOLLAR_IN_LABEL + return (IDENTIFIER_POINTER (id_node)[0] == '$' \ + && IDENTIFIER_POINTER (id_node)[1] == '_'); +#else /* NO_DOLLAR_IN_LABEL */ +#define ANON_AGGRNAME_PREFIX "__anon_" + return (!strncmp (IDENTIFIER_POINTER (id_node), ANON_AGGRNAME_PREFIX, + sizeof (ANON_AGGRNAME_PREFIX) - 1)); +#endif /* NO_DOLLAR_IN_LABEL */ +#endif /* NO_DOT_IN_LABEL */ +} + +/* Return a format for an anonymous aggregate name. */ +const char * +anon_aggrname_format() +{ +#ifndef NO_DOT_IN_LABEL + return "._%d"; +#else /* NO_DOT_IN_LABEL */ +#ifndef NO_DOLLAR_IN_LABEL + return "$_%d"; +#else /* NO_DOLLAR_IN_LABEL */ + return "__anon_%d"; +#endif /* NO_DOLLAR_IN_LABEL */ +#endif /* NO_DOT_IN_LABEL */ +} + +/* Generate a name for a special-purpose function. The generated name may need to be unique across the whole link. + Changes to this function may also require corresponding changes to + xstrdup_mask_random. TYPE is some string to identify the purpose of this function to the linker or collect2; it must start with an uppercase letter, one of: @@ -8561,15 +9010,10 @@ { const char *file = main_input_filename; if (! file) - file = input_filename; + file = LOCATION_FILE (input_location); /* Just use the file's basename, because the full pathname might be quite long. */ - p = strrchr (file, '/'); - if (p) - p++; - else - p = file; - p = q = ASTRDUP (p); + p = q = ASTRDUP (lbasename (file)); } else { @@ -8583,14 +9027,14 @@ if (! name) name = ""; if (! file) - file = input_filename; + file = LOCATION_FILE (input_location); len = strlen (file); - q = (char *) alloca (9 * 2 + len + 1); + q = (char *) alloca (9 + 19 + len + 1); memcpy (q, file, len + 1); - sprintf (q + len, "_%08X_%08X", crc32_string (0, name), - crc32_string (0, get_random_seed (false))); + snprintf (q + len, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX, + crc32_string (0, name), get_random_seed (false)); p = q; } @@ -8622,11 +9066,11 @@ va_list args; const char *buffer; unsigned length = 0; - int code; + enum tree_code code; va_start (args, function); - while ((code = va_arg (args, int))) - length += 4 + strlen (tree_code_name[code]); + while ((code = (enum tree_code) va_arg (args, int))) + length += 4 + strlen (get_tree_code_name (code)); va_end (args); if (length) { @@ -8635,14 +9079,14 @@ length += strlen ("expected "); buffer = tmp = (char *) alloca (length); length = 0; - while ((code = va_arg (args, int))) + while ((code = (enum tree_code) va_arg (args, int))) { const char *prefix = length ? " or " : "expected "; strcpy (tmp + length, prefix); length += strlen (prefix); - strcpy (tmp + length, tree_code_name[code]); - length += strlen (tree_code_name[code]); + strcpy (tmp + length, get_tree_code_name (code)); + length += strlen (get_tree_code_name (code)); } va_end (args); } @@ -8650,7 +9094,7 @@ buffer = "unexpected node"; internal_error ("tree check: %s, have %s in %s, at %s:%d", - buffer, tree_code_name[TREE_CODE (node)], + buffer, get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line); } @@ -8665,29 +9109,29 @@ va_list args; char *buffer; unsigned length = 0; - int code; + enum tree_code code; va_start (args, function); - while ((code = va_arg (args, int))) - length += 4 + strlen (tree_code_name[code]); + while ((code = (enum tree_code) va_arg (args, int))) + length += 4 + strlen (get_tree_code_name (code)); va_end (args); va_start (args, function); buffer = (char *) alloca (length); length = 0; - while ((code = va_arg (args, int))) + while ((code = (enum tree_code) va_arg (args, int))) { if (length) { strcpy (buffer + length, " or "); length += 4; } - strcpy (buffer + length, tree_code_name[code]); - length += strlen (tree_code_name[code]); + strcpy (buffer + length, get_tree_code_name (code)); + length += strlen (get_tree_code_name (code)); } va_end (args); internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d", - buffer, tree_code_name[TREE_CODE (node)], + buffer, get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line); } @@ -8702,7 +9146,7 @@ ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d", TREE_CODE_CLASS_STRING (cl), TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))), - tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); + get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line); } /* Similar to tree_check_failed, except that instead of specifying a @@ -8718,7 +9162,7 @@ unsigned int c; for (c = c1; c <= c2; ++c) - length += 4 + strlen (tree_code_name[c]); + length += 4 + strlen (get_tree_code_name ((enum tree_code) c)); length += strlen ("expected "); buffer = (char *) alloca (length); @@ -8730,12 +9174,12 @@ strcpy (buffer + length, prefix); length += strlen (prefix); - strcpy (buffer + length, tree_code_name[c]); - length += strlen (tree_code_name[c]); + strcpy (buffer + length, get_tree_code_name ((enum tree_code) c)); + length += strlen (get_tree_code_name ((enum tree_code) c)); } internal_error ("tree check: %s, have %s in %s, at %s:%d", - buffer, tree_code_name[TREE_CODE (node)], + buffer, get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line); } @@ -8751,7 +9195,7 @@ ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d", TREE_CODE_CLASS_STRING (cl), TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))), - tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); + get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line); } @@ -8762,7 +9206,7 @@ const char *function, enum omp_clause_code code) { 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], get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line); } @@ -8822,10 +9266,22 @@ { internal_error ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d", - TS_ENUM_NAME(en), - tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); -} - + TS_ENUM_NAME (en), + get_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 + (dynamically sized) vector. */ + +void +tree_int_cst_elt_check_failed (int idx, int len, const char *file, int line, + const char *function) +{ + internal_error + ("tree check: accessed elt %d of tree_int_cst with %d elts in %s, at %s:%d", + idx + 1, len, function, trim_filename (file), line); +} /* Similar to above, except that the check is for the bounds of a TREE_VEC's (dynamically sized) vector. */ @@ -8846,10 +9302,10 @@ tree_operand_check_failed (int idx, const_tree exp, const char *file, int line, const char *function) { - int code = TREE_CODE (exp); + enum tree_code code = TREE_CODE (exp); internal_error ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d", - idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp), + idx + 1, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp), function, trim_filename (file), line); } @@ -8873,30 +9329,28 @@ the information necessary for debugging output. */ static tree -make_vector_type (tree innertype, int nunits, enum machine_mode mode) +make_vector_type (tree innertype, int nunits, machine_mode mode) { tree t; - hashval_t hashcode = 0; + tree mv_innertype = TYPE_MAIN_VARIANT (innertype); t = make_node (VECTOR_TYPE); - TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype); + TREE_TYPE (t) = mv_innertype; SET_TYPE_VECTOR_SUBPARTS (t, nunits); SET_TYPE_MODE (t, mode); - if (TYPE_STRUCTURAL_EQUALITY_P (innertype)) + if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p) SET_TYPE_STRUCTURAL_EQUALITY (t); - else if (TYPE_CANONICAL (innertype) != innertype - || mode != VOIDmode) + else if ((TYPE_CANONICAL (mv_innertype) != innertype + || mode != VOIDmode) + && !VECTOR_BOOLEAN_TYPE_P (t)) TYPE_CANONICAL (t) - = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode); + = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode); layout_type (t); - hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode); - hashcode = iterative_hash_host_wide_int (nunits, hashcode); - hashcode = iterative_hash_host_wide_int (mode, hashcode); - hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode); - t = type_hash_canon (hashcode, t); + hashval_t hash = type_hash_canon_hash (t); + t = type_hash_canon (hash, t); /* We have built a main variant, based on the main variant of the inner type. Use it to build the variant we return. */ @@ -8912,6 +9366,8 @@ static tree make_or_reuse_type (unsigned size, int unsignedp) { + int i; + if (size == INT_TYPE_SIZE) return unsignedp ? unsigned_type_node : integer_type_node; if (size == CHAR_TYPE_SIZE) @@ -8923,9 +9379,12 @@ if (size == LONG_LONG_TYPE_SIZE) return (unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node); - if (size == 128 && int128_integer_type_node) - return (unsignedp ? int128_unsigned_type_node - : int128_integer_type_node); + + for (i = 0; i < NUM_INT_N_ENTS; i ++) + if (size == int_n_data[i].bitsize + && int_n_enabled_p[i]) + return (unsignedp ? int_n_trees[i].unsigned_type + : int_n_trees[i].signed_type); if (unsignedp) return make_unsigned_type (size); @@ -9007,13 +9466,54 @@ return make_accum_type (size, unsignedp, satp); } + +/* Create an atomic variant node for TYPE. This routine is called + during initialization of data types to create the 5 basic atomic + types. The generic build_variant_type function requires these to + already be set up in order to function properly, so cannot be + called from there. If ALIGN is non-zero, then ensure alignment is + overridden to this value. */ + +static tree +build_atomic_base (tree type, unsigned int align) +{ + tree t; + + /* Make sure its not already registered. */ + if ((t = get_qualified_type (type, TYPE_QUAL_ATOMIC))) + return t; + + t = build_variant_type_copy (type); + set_type_quals (t, TYPE_QUAL_ATOMIC); + + if (align) + SET_TYPE_ALIGN (t, align); + + return t; +} + +/* Information about the _FloatN and _FloatNx types. This must be in + the same order as the corresponding TI_* enum values. */ +const floatn_type_info floatn_nx_types[NUM_FLOATN_NX_TYPES] = + { + { 16, false }, + { 32, false }, + { 64, false }, + { 128, false }, + { 32, true }, + { 64, true }, + { 128, true }, + }; + + /* 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 - this function to select one of the types as sizetype. */ + of C datatypes. SIGNED_CHAR specifies whether char is signed. */ void build_common_tree_nodes (bool signed_char) { + int i; + error_mark_node = make_node (ERROR_MARK); TREE_TYPE (error_mark_node) = error_mark_node; @@ -9041,25 +9541,81 @@ long_unsigned_type_node = make_unsigned_type (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); -#if HOST_BITS_PER_WIDE_INT >= 64 - /* TODO: This isn't correct, but as logic depends at the moment on - host's instead of target's wide-integer. - If there is a target not supporting TImode, but has an 128-bit - integer-scalar register, this target check needs to be adjusted. */ - if (targetm.scalar_mode_supported_p (TImode)) - { - int128_integer_type_node = make_signed_type (128); - int128_unsigned_type_node = make_unsigned_type (128); - } -#endif + + for (i = 0; i < NUM_INT_N_ENTS; i ++) + { + int_n_trees[i].signed_type = make_signed_type (int_n_data[i].bitsize); + int_n_trees[i].unsigned_type = make_unsigned_type (int_n_data[i].bitsize); + TYPE_SIZE (int_n_trees[i].signed_type) = bitsize_int (int_n_data[i].bitsize); + TYPE_SIZE (int_n_trees[i].unsigned_type) = bitsize_int (int_n_data[i].bitsize); + + if (int_n_data[i].bitsize > LONG_LONG_TYPE_SIZE + && int_n_enabled_p[i]) + { + integer_types[itk_intN_0 + i * 2] = int_n_trees[i].signed_type; + integer_types[itk_unsigned_intN_0 + i * 2] = int_n_trees[i].unsigned_type; + } + } + /* Define a boolean type. This type only represents boolean values but - 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 - boolean_type_node before calling build_common_tree_nodes_2. */ + may be larger than char depending on the value of BOOL_TYPE_SIZE. */ boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE); TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE); + TYPE_PRECISION (boolean_type_node) = 1; TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1); - TYPE_PRECISION (boolean_type_node) = 1; + + /* Define what type to use for size_t. */ + if (strcmp (SIZE_TYPE, "unsigned int") == 0) + size_type_node = unsigned_type_node; + else if (strcmp (SIZE_TYPE, "long unsigned int") == 0) + size_type_node = long_unsigned_type_node; + else if (strcmp (SIZE_TYPE, "long long unsigned int") == 0) + size_type_node = long_long_unsigned_type_node; + else if (strcmp (SIZE_TYPE, "short unsigned int") == 0) + size_type_node = short_unsigned_type_node; + else + { + int i; + + size_type_node = NULL_TREE; + for (i = 0; i < NUM_INT_N_ENTS; i++) + if (int_n_enabled_p[i]) + { + char name[50]; + sprintf (name, "__int%d unsigned", int_n_data[i].bitsize); + + if (strcmp (name, SIZE_TYPE) == 0) + { + size_type_node = int_n_trees[i].unsigned_type; + } + } + if (size_type_node == NULL_TREE) + gcc_unreachable (); + } + + /* Define what type to use for ptrdiff_t. */ + if (strcmp (PTRDIFF_TYPE, "int") == 0) + ptrdiff_type_node = integer_type_node; + else if (strcmp (PTRDIFF_TYPE, "long int") == 0) + ptrdiff_type_node = long_integer_type_node; + else if (strcmp (PTRDIFF_TYPE, "long long int") == 0) + ptrdiff_type_node = long_long_integer_type_node; + else if (strcmp (PTRDIFF_TYPE, "short int") == 0) + ptrdiff_type_node = short_integer_type_node; + else + { + ptrdiff_type_node = NULL_TREE; + for (int i = 0; i < NUM_INT_N_ENTS; i++) + if (int_n_enabled_p[i]) + { + char name[50]; + sprintf (name, "__int%d", int_n_data[i].bitsize); + if (strcmp (name, PTRDIFF_TYPE) == 0) + ptrdiff_type_node = int_n_trees[i].signed_type; + } + if (ptrdiff_type_node == NULL_TREE) + gcc_unreachable (); + } /* Fill in the rest of the sized types. Reuse existing type nodes when possible. */ @@ -9075,17 +9631,27 @@ 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); + /* Don't call build_qualified type for atomics. That routine does + special processing for atomics, and until they are initialized + it's better not to make that call. + + Check to see if there is a target override for atomic types. */ + + atomicQI_type_node = build_atomic_base (unsigned_intQI_type_node, + targetm.atomic_align_for_mode (QImode)); + atomicHI_type_node = build_atomic_base (unsigned_intHI_type_node, + targetm.atomic_align_for_mode (HImode)); + atomicSI_type_node = build_atomic_base (unsigned_intSI_type_node, + targetm.atomic_align_for_mode (SImode)); + atomicDI_type_node = build_atomic_base (unsigned_intDI_type_node, + targetm.atomic_align_for_mode (DImode)); + atomicTI_type_node = build_atomic_base (unsigned_intTI_type_node, + targetm.atomic_align_for_mode (TImode)); + access_public_node = get_identifier ("public"); access_protected_node = get_identifier ("protected"); access_private_node = get_identifier ("private"); -} - -/* Call this function after calling build_common_tree_nodes and set_sizetype. - It will create several other common tree nodes. */ - -void -build_common_tree_nodes_2 (int short_double) -{ + /* Define these next since types below may used them. */ integer_zero_node = build_int_cst (integer_type_node, 0); integer_one_node = build_int_cst (integer_type_node, 1); @@ -9104,66 +9670,105 @@ void_type_node = make_node (VOID_TYPE); layout_type (void_type_node); + pointer_bounds_type_node = targetm.chkp_bound_type (); + /* 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. */ - TYPE_ALIGN (void_type_node) = BITS_PER_UNIT; + SET_TYPE_ALIGN (void_type_node, BITS_PER_UNIT); TYPE_USER_ALIGN (void_type_node) = 0; + void_node = make_node (VOID_CST); + TREE_TYPE (void_node) = void_type_node; + null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0); layout_type (TREE_TYPE (null_pointer_node)); ptr_type_node = build_pointer_type (void_type_node); const_ptr_type_node = build_pointer_type (build_type_variant (void_type_node, 1, 0)); - fileptr_type_node = ptr_type_node; + for (unsigned i = 0; + i < sizeof (builtin_structptr_types) / sizeof (builtin_structptr_type); + ++i) + builtin_structptr_types[i].node = builtin_structptr_types[i].base; + + pointer_sized_int_node = build_nonstandard_integer_type (POINTER_SIZE, 1); float_type_node = make_node (REAL_TYPE); TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE; layout_type (float_type_node); double_type_node = make_node (REAL_TYPE); - if (short_double) - TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE; - else - TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; + TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; layout_type (double_type_node); long_double_type_node = make_node (REAL_TYPE); TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; layout_type (long_double_type_node); + for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) + { + int n = floatn_nx_types[i].n; + bool extended = floatn_nx_types[i].extended; + scalar_float_mode mode; + if (!targetm.floatn_mode (n, extended).exists (&mode)) + continue; + int precision = GET_MODE_PRECISION (mode); + /* Work around the rs6000 KFmode having precision 113 not + 128. */ + const struct real_format *fmt = REAL_MODE_FORMAT (mode); + gcc_assert (fmt->b == 2 && fmt->emin + fmt->emax == 3); + int min_precision = fmt->p + ceil_log2 (fmt->emax - fmt->emin); + if (!extended) + gcc_assert (min_precision == n); + if (precision < min_precision) + precision = min_precision; + FLOATN_NX_TYPE_NODE (i) = make_node (REAL_TYPE); + TYPE_PRECISION (FLOATN_NX_TYPE_NODE (i)) = precision; + layout_type (FLOATN_NX_TYPE_NODE (i)); + SET_TYPE_MODE (FLOATN_NX_TYPE_NODE (i), mode); + } + float_ptr_type_node = build_pointer_type (float_type_node); double_ptr_type_node = build_pointer_type (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); /* Fixed size integer types. */ - uint32_type_node = build_nonstandard_integer_type (32, true); - uint64_type_node = build_nonstandard_integer_type (64, true); + uint16_type_node = make_or_reuse_type (16, 1); + uint32_type_node = make_or_reuse_type (32, 1); + uint64_type_node = make_or_reuse_type (64, 1); /* Decimal float types. */ dfloat32_type_node = make_node (REAL_TYPE); TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE; + SET_TYPE_MODE (dfloat32_type_node, SDmode); layout_type (dfloat32_type_node); - SET_TYPE_MODE (dfloat32_type_node, SDmode); dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node); dfloat64_type_node = make_node (REAL_TYPE); TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE; + SET_TYPE_MODE (dfloat64_type_node, DDmode); layout_type (dfloat64_type_node); - SET_TYPE_MODE (dfloat64_type_node, DDmode); dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node); dfloat128_type_node = make_node (REAL_TYPE); TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE; + SET_TYPE_MODE (dfloat128_type_node, TDmode); layout_type (dfloat128_type_node); - SET_TYPE_MODE (dfloat128_type_node, TDmode); dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node); - complex_integer_type_node = build_complex_type (integer_type_node); - complex_float_type_node = build_complex_type (float_type_node); - complex_double_type_node = build_complex_type (double_type_node); - complex_long_double_type_node = build_complex_type (long_double_type_node); + complex_integer_type_node = build_complex_type (integer_type_node, true); + complex_float_type_node = build_complex_type (float_type_node, true); + complex_double_type_node = build_complex_type (double_type_node, true); + complex_long_double_type_node = build_complex_type (long_double_type_node, + true); + + for (i = 0; i < NUM_FLOATN_NX_TYPES; i++) + { + if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE) + COMPLEX_FLOATN_NX_TYPE_NODE (i) + = build_complex_type (FLOATN_NX_TYPE_NODE (i)); + } /* Make fixed-point nodes based on sat/non-sat and signed/unsigned. */ #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \ @@ -9233,6 +9838,49 @@ } } +/* Modify DECL for given flags. + TM_PURE attribute is set only on types, so the function will modify + DECL's type when ECF_TM_PURE is used. */ + +void +set_call_expr_flags (tree decl, int flags) +{ + if (flags & ECF_NOTHROW) + TREE_NOTHROW (decl) = 1; + if (flags & ECF_CONST) + TREE_READONLY (decl) = 1; + if (flags & ECF_PURE) + DECL_PURE_P (decl) = 1; + if (flags & ECF_LOOPING_CONST_OR_PURE) + DECL_LOOPING_CONST_OR_PURE_P (decl) = 1; + if (flags & ECF_NOVOPS) + DECL_IS_NOVOPS (decl) = 1; + if (flags & ECF_NORETURN) + TREE_THIS_VOLATILE (decl) = 1; + if (flags & ECF_MALLOC) + DECL_IS_MALLOC (decl) = 1; + if (flags & ECF_RETURNS_TWICE) + DECL_IS_RETURNS_TWICE (decl) = 1; + if (flags & ECF_LEAF) + DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"), + NULL, DECL_ATTRIBUTES (decl)); + if (flags & ECF_COLD) + DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("cold"), + NULL, DECL_ATTRIBUTES (decl)); + if (flags & ECF_RET1) + DECL_ATTRIBUTES (decl) + = tree_cons (get_identifier ("fn spec"), + build_tree_list (NULL_TREE, build_string (1, "1")), + DECL_ATTRIBUTES (decl)); + if ((flags & ECF_TM_PURE) && flag_tm) + apply_tm_attr (decl, get_identifier ("transaction_pure")); + /* Looping const or pure is implied by noreturn. + There is currently no way to declare looping const or looping pure alone. */ + gcc_assert (!(flags & ECF_LOOPING_CONST_OR_PURE) + || ((flags & ECF_NORETURN) && (flags & (ECF_CONST | ECF_PURE)))); +} + + /* A subroutine of build_common_builtin_nodes. Define a builtin function. */ static void @@ -9243,51 +9891,54 @@ decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL, library_name, NULL_TREE); - if (ecf_flags & ECF_CONST) - TREE_READONLY (decl) = 1; - if (ecf_flags & ECF_PURE) - DECL_PURE_P (decl) = 1; - if (ecf_flags & ECF_LOOPING_CONST_OR_PURE) - DECL_LOOPING_CONST_OR_PURE_P (decl) = 1; - if (ecf_flags & ECF_NORETURN) - TREE_THIS_VOLATILE (decl) = 1; - if (ecf_flags & ECF_NOTHROW) - TREE_NOTHROW (decl) = 1; - if (ecf_flags & ECF_MALLOC) - DECL_IS_MALLOC (decl) = 1; - if (ecf_flags & ECF_LEAF) - DECL_ATTRIBUTES (decl) = tree_cons (get_identifier ("leaf"), - NULL, DECL_ATTRIBUTES (decl)); - - built_in_decls[code] = decl; - implicit_built_in_decls[code] = decl; + set_call_expr_flags (decl, ecf_flags); + + set_builtin_decl (code, decl, true); } /* Call this function after instantiating all builtins that the language - front end cares about. This will build the rest of the builtins that - are relied upon by the tree optimizers and the middle-end. */ + front end cares about. This will build the rest of the builtins + and internal functions that are relied upon by the tree optimizers and + the middle-end. */ void build_common_builtin_nodes (void) { tree tmp, ftype; - - if (built_in_decls[BUILT_IN_MEMCPY] == NULL - || built_in_decls[BUILT_IN_MEMMOVE] == NULL) + int ecf_flags; + + if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE) + || !builtin_decl_explicit_p (BUILT_IN_ABORT)) + { + ftype = build_function_type (void_type_node, void_list_node); + if (!builtin_decl_explicit_p (BUILT_IN_UNREACHABLE)) + local_define_builtin ("__builtin_unreachable", ftype, + BUILT_IN_UNREACHABLE, + "__builtin_unreachable", + ECF_NOTHROW | ECF_LEAF | ECF_NORETURN + | ECF_CONST | ECF_COLD); + if (!builtin_decl_explicit_p (BUILT_IN_ABORT)) + local_define_builtin ("__builtin_abort", ftype, BUILT_IN_ABORT, + "abort", + ECF_LEAF | ECF_NORETURN | ECF_CONST | ECF_COLD); + } + + if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY) + || !builtin_decl_explicit_p (BUILT_IN_MEMMOVE)) { ftype = build_function_type_list (ptr_type_node, ptr_type_node, const_ptr_type_node, size_type_node, NULL_TREE); - if (built_in_decls[BUILT_IN_MEMCPY] == NULL) + if (!builtin_decl_explicit_p (BUILT_IN_MEMCPY)) local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY, - "memcpy", ECF_NOTHROW | ECF_LEAF); - if (built_in_decls[BUILT_IN_MEMMOVE] == NULL) + "memcpy", ECF_NOTHROW | ECF_LEAF | ECF_RET1); + if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE)) local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE, - "memmove", ECF_NOTHROW | ECF_LEAF); - } - - if (built_in_decls[BUILT_IN_MEMCMP] == NULL) + "memmove", ECF_NOTHROW | ECF_LEAF | ECF_RET1); + } + + if (!builtin_decl_explicit_p (BUILT_IN_MEMCMP)) { ftype = build_function_type_list (integer_type_node, const_ptr_type_node, const_ptr_type_node, size_type_node, @@ -9296,26 +9947,40 @@ "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF); } - if (built_in_decls[BUILT_IN_MEMSET] == NULL) + if (!builtin_decl_explicit_p (BUILT_IN_MEMSET)) { ftype = build_function_type_list (ptr_type_node, ptr_type_node, integer_type_node, size_type_node, NULL_TREE); local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET, - "memset", ECF_NOTHROW | ECF_LEAF); - } - - if (built_in_decls[BUILT_IN_ALLOCA] == NULL) + "memset", ECF_NOTHROW | ECF_LEAF | ECF_RET1); + } + + /* If we're checking the stack, `alloca' can throw. */ + const int alloca_flags + = ECF_MALLOC | ECF_LEAF | (flag_stack_check ? 0 : ECF_NOTHROW); + + if (!builtin_decl_explicit_p (BUILT_IN_ALLOCA)) { ftype = build_function_type_list (ptr_type_node, size_type_node, NULL_TREE); local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA, - "alloca", ECF_MALLOC | ECF_NOTHROW | ECF_LEAF); - } - - /* If we're checking the stack, `alloca' can throw. */ - if (flag_stack_check) - TREE_NOTHROW (built_in_decls[BUILT_IN_ALLOCA]) = 0; + "alloca", alloca_flags); + } + + ftype = build_function_type_list (ptr_type_node, size_type_node, + size_type_node, NULL_TREE); + local_define_builtin ("__builtin_alloca_with_align", ftype, + BUILT_IN_ALLOCA_WITH_ALIGN, + "__builtin_alloca_with_align", + alloca_flags); + + ftype = build_function_type_list (ptr_type_node, size_type_node, + size_type_node, size_type_node, NULL_TREE); + local_define_builtin ("__builtin_alloca_with_align_and_max", ftype, + BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX, + "__builtin_alloca_with_align_and_max", + alloca_flags); ftype = build_function_type_list (void_type_node, ptr_type_node, ptr_type_node, @@ -9323,12 +9988,23 @@ local_define_builtin ("__builtin_init_trampoline", ftype, BUILT_IN_INIT_TRAMPOLINE, "__builtin_init_trampoline", ECF_NOTHROW | ECF_LEAF); + local_define_builtin ("__builtin_init_heap_trampoline", ftype, + BUILT_IN_INIT_HEAP_TRAMPOLINE, + "__builtin_init_heap_trampoline", + ECF_NOTHROW | ECF_LEAF); + local_define_builtin ("__builtin_init_descriptor", ftype, + BUILT_IN_INIT_DESCRIPTOR, + "__builtin_init_descriptor", ECF_NOTHROW | ECF_LEAF); ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE); local_define_builtin ("__builtin_adjust_trampoline", ftype, BUILT_IN_ADJUST_TRAMPOLINE, "__builtin_adjust_trampoline", ECF_CONST | ECF_NOTHROW); + local_define_builtin ("__builtin_adjust_descriptor", ftype, + BUILT_IN_ADJUST_DESCRIPTOR, + "__builtin_adjust_descriptor", + ECF_CONST | ECF_NOTHROW); ftype = build_function_type_list (void_type_node, ptr_type_node, ptr_type_node, NULL_TREE); @@ -9343,16 +10019,10 @@ BUILT_IN_SETJMP_SETUP, "__builtin_setjmp_setup", ECF_NOTHROW); - ftype = build_function_type_list (ptr_type_node, ptr_type_node, NULL_TREE); - local_define_builtin ("__builtin_setjmp_dispatcher", ftype, - BUILT_IN_SETJMP_DISPATCHER, - "__builtin_setjmp_dispatcher", - ECF_PURE | ECF_NOTHROW); - ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE); local_define_builtin ("__builtin_setjmp_receiver", ftype, BUILT_IN_SETJMP_RECEIVER, - "__builtin_setjmp_receiver", ECF_NOTHROW); + "__builtin_setjmp_receiver", ECF_NOTHROW | ECF_LEAF); ftype = build_function_type_list (ptr_type_node, NULL_TREE); local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE, @@ -9363,8 +10033,15 @@ BUILT_IN_STACK_RESTORE, "__builtin_stack_restore", ECF_NOTHROW | ECF_LEAF); + ftype = build_function_type_list (integer_type_node, const_ptr_type_node, + const_ptr_type_node, size_type_node, + NULL_TREE); + local_define_builtin ("__builtin_memcmp_eq", ftype, BUILT_IN_MEMCMP_EQ, + "__builtin_memcmp_eq", + ECF_PURE | ECF_NOTHROW | ECF_LEAF); + /* If there's a possibility that we might use the ARM EABI, build the - alternate __cxa_end_cleanup node used to resume from C++ and Java. */ + alternate __cxa_end_cleanup node used to resume from C++. */ if (targetm.arm_eabi_unwinder) { ftype = build_function_type_list (void_type_node, NULL_TREE); @@ -9376,11 +10053,36 @@ ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE); local_define_builtin ("__builtin_unwind_resume", ftype, BUILT_IN_UNWIND_RESUME, - ((targetm.except_unwind_info (&global_options) + ((targetm_common.except_unwind_info (&global_options) == UI_SJLJ) ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"), ECF_NORETURN); + if (builtin_decl_explicit (BUILT_IN_RETURN_ADDRESS) == NULL_TREE) + { + ftype = build_function_type_list (ptr_type_node, integer_type_node, + NULL_TREE); + local_define_builtin ("__builtin_return_address", ftype, + BUILT_IN_RETURN_ADDRESS, + "__builtin_return_address", + ECF_NOTHROW); + } + + if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER) + || !builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT)) + { + ftype = build_function_type_list (void_type_node, ptr_type_node, + ptr_type_node, NULL_TREE); + if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_ENTER)) + local_define_builtin ("__cyg_profile_func_enter", ftype, + BUILT_IN_PROFILE_FUNC_ENTER, + "__cyg_profile_func_enter", 0); + if (!builtin_decl_explicit_p (BUILT_IN_PROFILE_FUNC_EXIT)) + local_define_builtin ("__cyg_profile_func_exit", ftype, + BUILT_IN_PROFILE_FUNC_EXIT, + "__cyg_profile_func_exit", 0); + } + /* The exception object and filter values from the runtime. The argument must be zero before exception lowering, i.e. from the front end. After exception lowering, it will be the region number for the exception @@ -9389,8 +10091,12 @@ its value in the landing pad. */ ftype = build_function_type_list (ptr_type_node, integer_type_node, NULL_TREE); + ecf_flags = ECF_PURE | ECF_NOTHROW | ECF_LEAF; + /* Only use TM_PURE if we have TM language support. */ + if (builtin_decl_explicit_p (BUILT_IN_TM_LOAD_1)) + ecf_flags |= ECF_TM_PURE; local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER, - "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW | ECF_LEAF); + "__builtin_eh_pointer", ecf_flags); tmp = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0); ftype = build_function_type_list (tmp, integer_type_node, NULL_TREE); @@ -9417,8 +10123,12 @@ const char *p; enum built_in_function mcode, dcode; tree type, inner_type; - - type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0); + const char *prefix = "__"; + + if (targetm.libfunc_gnu_prefix) + prefix = "__gnu_"; + + type = lang_hooks.types.type_for_mode ((machine_mode) mode, 0); if (type == NULL) continue; inner_type = TREE_TYPE (type); @@ -9435,15 +10145,21 @@ *q = TOLOWER (*p); *q = '\0'; - built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL); + built_in_names[mcode] = concat (prefix, "mul", mode_name_buf, "3", + NULL); local_define_builtin (built_in_names[mcode], ftype, mcode, - built_in_names[mcode], ECF_CONST | ECF_NOTHROW | ECF_LEAF); - - built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL); + built_in_names[mcode], + ECF_CONST | ECF_NOTHROW | ECF_LEAF); + + built_in_names[dcode] = concat (prefix, "div", mode_name_buf, "3", + NULL); local_define_builtin (built_in_names[dcode], ftype, dcode, - built_in_names[dcode], ECF_CONST | ECF_NOTHROW | ECF_LEAF); + built_in_names[dcode], + ECF_CONST | ECF_NOTHROW | ECF_LEAF); } } + + init_internal_fns (); } /* HACK. GROSS. This is absolutely disgusting. I wish there was a @@ -9509,9 +10225,10 @@ /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and the inner type. */ tree -build_vector_type_for_mode (tree innertype, enum machine_mode mode) +build_vector_type_for_mode (tree innertype, machine_mode mode) { int nunits; + unsigned int bitsize; switch (GET_MODE_CLASS (mode)) { @@ -9526,11 +10243,9 @@ case MODE_INT: /* Check that there are no leftover bits. */ - gcc_assert (GET_MODE_BITSIZE (mode) - % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0); - - nunits = GET_MODE_BITSIZE (mode) - / TREE_INT_CST_LOW (TYPE_SIZE (innertype)); + bitsize = GET_MODE_BITSIZE (as_a <scalar_int_mode> (mode)); + gcc_assert (bitsize % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0); + nunits = bitsize / TREE_INT_CST_LOW (TYPE_SIZE (innertype)); break; default: @@ -9549,17 +10264,67 @@ return make_vector_type (innertype, nunits, VOIDmode); } -/* Similarly, but takes the inner type and number of units, which must be - a power of two. */ +/* Build truth vector with specified length and number of units. */ + +tree +build_truth_vector_type (unsigned nunits, unsigned vector_size) +{ + machine_mode mask_mode + = targetm.vectorize.get_mask_mode (nunits, vector_size).else_blk (); + + unsigned HOST_WIDE_INT vsize; + if (mask_mode == BLKmode) + vsize = vector_size * BITS_PER_UNIT; + else + vsize = GET_MODE_BITSIZE (mask_mode); + + unsigned HOST_WIDE_INT esize = vsize / nunits; + gcc_assert (esize * nunits == vsize); + + tree bool_type = build_nonstandard_boolean_type (esize); + + return make_vector_type (bool_type, nunits, mask_mode); +} + +/* Returns a vector type corresponding to a comparison of VECTYPE. */ + +tree +build_same_sized_truth_vector_type (tree vectype) +{ + if (VECTOR_BOOLEAN_TYPE_P (vectype)) + return vectype; + + unsigned HOST_WIDE_INT size = GET_MODE_SIZE (TYPE_MODE (vectype)); + + if (!size) + size = tree_to_uhwi (TYPE_SIZE_UNIT (vectype)); + + return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (vectype), size); +} + +/* Similarly, but builds a variant type with TYPE_VECTOR_OPAQUE set. */ tree build_opaque_vector_type (tree innertype, int nunits) { - tree t; - innertype = build_distinct_type_copy (innertype); - t = make_vector_type (innertype, nunits, VOIDmode); - TYPE_VECTOR_OPAQUE (t) = true; - return t; + tree t = make_vector_type (innertype, nunits, VOIDmode); + tree cand; + /* We always build the non-opaque variant before the opaque one, + so if it already exists, it is TYPE_NEXT_VARIANT of this one. */ + cand = TYPE_NEXT_VARIANT (t); + if (cand + && TYPE_VECTOR_OPAQUE (cand) + && check_qualified_type (cand, t, TYPE_QUALS (t))) + return cand; + /* Othewise build a variant type and make sure to queue it after + the non-opaque type. */ + cand = build_distinct_type_copy (t); + TYPE_VECTOR_OPAQUE (cand) = true; + TYPE_CANONICAL (cand) = TYPE_CANONICAL (t); + TYPE_NEXT_VARIANT (cand) = TYPE_NEXT_VARIANT (t); + TYPE_NEXT_VARIANT (t) = cand; + TYPE_MAIN_VARIANT (cand) = TYPE_MAIN_VARIANT (t); + return cand; } @@ -9594,15 +10359,20 @@ && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init)))); case VECTOR_CST: - for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt)) - if (!initializer_zerop (TREE_VALUE (elt))) - return false; - return true; + { + unsigned i; + for (i = 0; i < VECTOR_CST_NELTS (init); ++i) + if (!initializer_zerop (VECTOR_CST_ELT (init, i))) + return false; + return true; + } case CONSTRUCTOR: { unsigned HOST_WIDE_INT idx; + if (TREE_CLOBBER_P (init)) + return false; FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt) if (!initializer_zerop (elt)) return false; @@ -9627,6 +10397,54 @@ } } +/* Check if vector VEC consists of all the equal elements and + that the number of elements corresponds to the type of VEC. + The function returns first element of the vector + or NULL_TREE if the vector is not uniform. */ +tree +uniform_vector_p (const_tree vec) +{ + tree first, t; + unsigned i; + + if (vec == NULL_TREE) + return NULL_TREE; + + gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec))); + + if (TREE_CODE (vec) == VECTOR_CST) + { + first = VECTOR_CST_ELT (vec, 0); + for (i = 1; i < VECTOR_CST_NELTS (vec); ++i) + if (!operand_equal_p (first, VECTOR_CST_ELT (vec, i), 0)) + return NULL_TREE; + + return first; + } + + else if (TREE_CODE (vec) == CONSTRUCTOR) + { + first = error_mark_node; + + FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (vec), i, t) + { + if (i == 0) + { + first = t; + continue; + } + if (!operand_equal_p (first, t, 0)) + return NULL_TREE; + } + if (i != TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec))) + return NULL_TREE; + + return first; + } + + return NULL_TREE; +} + /* Build an empty statement at location LOC. */ tree @@ -9650,17 +10468,14 @@ length = omp_clause_num_ops[code]; size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree)); - t = ggc_alloc_tree_node (size); + record_node_allocation_statistics (OMP_CLAUSE, size); + + t = (tree) ggc_internal_alloc (size); memset (t, 0, size); TREE_SET_CODE (t, OMP_CLAUSE); OMP_CLAUSE_SET_CODE (t, code); OMP_CLAUSE_LOCATION (t) = loc; -#ifdef GATHER_STATISTICS - tree_node_counts[(int) omp_clause_kind]++; - tree_node_sizes[(int) omp_clause_kind] += size; -#endif - return t; } @@ -9670,7 +10485,7 @@ object is initialized to zeros. */ tree -build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL) +build_vl_exp (enum tree_code code, int len MEM_STAT_DECL) { tree t; int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp); @@ -9678,12 +10493,9 @@ gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp); gcc_assert (len >= 1); -#ifdef GATHER_STATISTICS - tree_node_counts[(int) e_kind]++; - tree_node_sizes[(int) e_kind] += length; -#endif - - t = ggc_alloc_zone_cleared_tree_node_stat (&tree_zone, length PASS_MEM_STAT); + record_node_allocation_statistics (code, length); + + t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT); TREE_SET_CODE (t, code); @@ -9694,6 +10506,23 @@ return t; } +/* Helper function for build_call_* functions; build a CALL_EXPR with + indicated RETURN_TYPE, FN, and NARGS, but do not initialize any of + the argument slots. */ + +static tree +build_call_1 (tree return_type, tree fn, int nargs) +{ + tree t; + + t = build_vl_exp (CALL_EXPR, nargs + 3); + TREE_TYPE (t) = return_type; + CALL_EXPR_FN (t) = fn; + CALL_EXPR_STATIC_CHAIN (t) = NULL; + + return t; +} + /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and FN and a null static chain slot. NARGS is the number of call arguments which are specified as "..." arguments. */ @@ -9719,10 +10548,7 @@ tree t; int i; - t = build_vl_exp (CALL_EXPR, nargs + 3); - TREE_TYPE (t) = return_type; - CALL_EXPR_FN (t) = fn; - CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE; + t = build_call_1 (return_type, fn, nargs); for (i = 0; i < nargs; i++) CALL_EXPR_ARG (t, i) = va_arg (args, tree); process_call_operands (t); @@ -9740,10 +10566,7 @@ tree t; int i; - t = build_vl_exp (CALL_EXPR, nargs + 3); - TREE_TYPE (t) = return_type; - CALL_EXPR_FN (t) = fn; - CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE; + t = build_call_1 (return_type, fn, nargs); for (i = 0; i < nargs; i++) CALL_EXPR_ARG (t, i) = args[i]; process_call_operands (t); @@ -9751,85 +10574,206 @@ return t; } -/* Like build_call_array, but takes a VEC. */ - -tree -build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args) +/* Like build_call_array, but takes a vec. */ + +tree +build_call_vec (tree return_type, tree fn, vec<tree, va_gc> *args) { tree ret, t; unsigned int ix; - ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3); - TREE_TYPE (ret) = return_type; - CALL_EXPR_FN (ret) = fn; - CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE; - FOR_EACH_VEC_ELT (tree, args, ix, t) + ret = build_call_1 (return_type, fn, vec_safe_length (args)); + FOR_EACH_VEC_SAFE_ELT (args, ix, t) CALL_EXPR_ARG (ret, ix) = t; process_call_operands (ret); return ret; } - -/* Returns true if it is possible to prove that the index of - an array access REF (an ARRAY_REF expression) falls into the - array bounds. */ - -bool -in_array_bounds_p (tree ref) -{ - tree idx = TREE_OPERAND (ref, 1); - tree min, max; - - if (TREE_CODE (idx) != INTEGER_CST) - return false; - - min = array_ref_low_bound (ref); - max = array_ref_up_bound (ref); - if (!min - || !max - || TREE_CODE (min) != INTEGER_CST - || TREE_CODE (max) != INTEGER_CST) - return false; - - if (tree_int_cst_lt (idx, min) - || tree_int_cst_lt (max, idx)) - return false; - - return true; -} - -/* Returns true if it is possible to prove that the range of - an array access REF (an ARRAY_RANGE_REF expression) falls - into the array bounds. */ - -bool -range_in_array_bounds_p (tree ref) -{ - tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref)); - tree range_min, range_max, min, max; - - range_min = TYPE_MIN_VALUE (domain_type); - range_max = TYPE_MAX_VALUE (domain_type); - if (!range_min - || !range_max - || TREE_CODE (range_min) != INTEGER_CST - || TREE_CODE (range_max) != INTEGER_CST) - return false; - - min = array_ref_low_bound (ref); - max = array_ref_up_bound (ref); - if (!min - || !max - || TREE_CODE (min) != INTEGER_CST - || TREE_CODE (max) != INTEGER_CST) - return false; - - if (tree_int_cst_lt (range_min, min) - || tree_int_cst_lt (max, range_max)) - return false; - - return true; -} +/* Conveniently construct a function call expression. FNDECL names the + function to be called and N arguments are passed in the array + ARGARRAY. */ + +tree +build_call_expr_loc_array (location_t loc, tree fndecl, int n, tree *argarray) +{ + tree fntype = TREE_TYPE (fndecl); + tree fn = build1 (ADDR_EXPR, build_pointer_type (fntype), fndecl); + + return fold_build_call_array_loc (loc, TREE_TYPE (fntype), fn, n, argarray); +} + +/* Conveniently construct a function call expression. FNDECL names the + function to be called and the arguments are passed in the vector + VEC. */ + +tree +build_call_expr_loc_vec (location_t loc, tree fndecl, vec<tree, va_gc> *vec) +{ + return build_call_expr_loc_array (loc, fndecl, vec_safe_length (vec), + vec_safe_address (vec)); +} + + +/* Conveniently construct a function call expression. FNDECL names the + function to be called, N is the number of arguments, and the "..." + parameters are the argument expressions. */ + +tree +build_call_expr_loc (location_t loc, tree fndecl, int n, ...) +{ + va_list ap; + tree *argarray = XALLOCAVEC (tree, n); + int i; + + va_start (ap, n); + for (i = 0; i < n; i++) + argarray[i] = va_arg (ap, tree); + va_end (ap); + return build_call_expr_loc_array (loc, fndecl, n, argarray); +} + +/* Like build_call_expr_loc (UNKNOWN_LOCATION, ...). Duplicated because + varargs macros aren't supported by all bootstrap compilers. */ + +tree +build_call_expr (tree fndecl, int n, ...) +{ + va_list ap; + tree *argarray = XALLOCAVEC (tree, n); + int i; + + va_start (ap, n); + for (i = 0; i < n; i++) + argarray[i] = va_arg (ap, tree); + va_end (ap); + return build_call_expr_loc_array (UNKNOWN_LOCATION, fndecl, n, argarray); +} + +/* Build an internal call to IFN, with arguments ARGS[0:N-1] and with return + type TYPE. This is just like CALL_EXPR, except its CALL_EXPR_FN is NULL. + It will get gimplified later into an ordinary internal function. */ + +tree +build_call_expr_internal_loc_array (location_t loc, internal_fn ifn, + tree type, int n, const tree *args) +{ + tree t = build_call_1 (type, NULL_TREE, n); + for (int i = 0; i < n; ++i) + CALL_EXPR_ARG (t, i) = args[i]; + SET_EXPR_LOCATION (t, loc); + CALL_EXPR_IFN (t) = ifn; + return t; +} + +/* Build internal call expression. This is just like CALL_EXPR, except + its CALL_EXPR_FN is NULL. It will get gimplified later into ordinary + internal function. */ + +tree +build_call_expr_internal_loc (location_t loc, enum internal_fn ifn, + tree type, int n, ...) +{ + va_list ap; + tree *argarray = XALLOCAVEC (tree, n); + int i; + + va_start (ap, n); + for (i = 0; i < n; i++) + argarray[i] = va_arg (ap, tree); + va_end (ap); + return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray); +} + +/* Return a function call to FN, if the target is guaranteed to support it, + or null otherwise. + + N is the number of arguments, passed in the "...", and TYPE is the + type of the return value. */ + +tree +maybe_build_call_expr_loc (location_t loc, combined_fn fn, tree type, + int n, ...) +{ + va_list ap; + tree *argarray = XALLOCAVEC (tree, n); + int i; + + va_start (ap, n); + for (i = 0; i < n; i++) + argarray[i] = va_arg (ap, tree); + va_end (ap); + if (internal_fn_p (fn)) + { + internal_fn ifn = as_internal_fn (fn); + if (direct_internal_fn_p (ifn)) + { + tree_pair types = direct_internal_fn_types (ifn, type, argarray); + if (!direct_internal_fn_supported_p (ifn, types, + OPTIMIZE_FOR_BOTH)) + return NULL_TREE; + } + return build_call_expr_internal_loc_array (loc, ifn, type, n, argarray); + } + else + { + tree fndecl = builtin_decl_implicit (as_builtin_fn (fn)); + if (!fndecl) + return NULL_TREE; + return build_call_expr_loc_array (loc, fndecl, n, argarray); + } +} + +/* Return a function call to the appropriate builtin alloca variant. + + SIZE is the size to be allocated. ALIGN, if non-zero, is the requested + alignment of the allocated area. MAX_SIZE, if non-negative, is an upper + bound for SIZE in case it is not a fixed value. */ + +tree +build_alloca_call_expr (tree size, unsigned int align, HOST_WIDE_INT max_size) +{ + if (max_size >= 0) + { + tree t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN_AND_MAX); + return + build_call_expr (t, 3, size, size_int (align), size_int (max_size)); + } + else if (align > 0) + { + tree t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN); + return build_call_expr (t, 2, size, size_int (align)); + } + else + { + tree t = builtin_decl_explicit (BUILT_IN_ALLOCA); + return build_call_expr (t, 1, size); + } +} + +/* Create a new constant string literal and return a char* pointer to it. + The STRING_CST value is the LEN characters at STR. */ +tree +build_string_literal (int len, const char *str) +{ + tree t, elem, index, type; + + t = build_string (len, str); + elem = build_type_variant (char_type_node, 1, 0); + index = build_index_type (size_int (len - 1)); + type = build_array_type (elem, index); + TREE_TYPE (t) = type; + TREE_CONSTANT (t) = 1; + TREE_READONLY (t) = 1; + TREE_STATIC (t) = 1; + + type = build_pointer_type (elem); + t = build1 (ADDR_EXPR, type, + build4 (ARRAY_REF, elem, + t, integer_zero_node, NULL_TREE, NULL_TREE)); + return t; +} + + /* Return true if T (assumed to be a DECL) must be assigned a memory location. */ @@ -9837,9 +10781,6 @@ bool needs_to_live_in_memory (const_tree t) { - if (TREE_CODE (t) == SSA_NAME) - t = SSA_NAME_VAR (t); - return (TREE_ADDRESSABLE (t) || is_global_var (t) || (TREE_CODE (t) == RESULT_DECL @@ -9847,50 +10788,6 @@ && aggregate_value_p (t, current_function_decl))); } -/* There are situations in which a language considers record types - compatible which have different field lists. Decide if two fields - are compatible. It is assumed that the parent records are compatible. */ - -bool -fields_compatible_p (const_tree f1, const_tree f2) -{ - if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1), - DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST)) - return false; - - if (!operand_equal_p (DECL_FIELD_OFFSET (f1), - DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST)) - return false; - - if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2))) - return false; - - return true; -} - -/* Locate within RECORD a field that is compatible with ORIG_FIELD. */ - -tree -find_compatible_field (tree record, tree orig_field) -{ - tree f; - - for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f)) - if (TREE_CODE (f) == FIELD_DECL - && fields_compatible_p (f, orig_field)) - return f; - - /* ??? Why isn't this on the main fields list? */ - f = TYPE_VFIELD (record); - if (f && TREE_CODE (f) == FIELD_DECL - && fields_compatible_p (f, orig_field)) - return f; - - /* ??? We should abort here, but Java appears to do Bad Things - with inherited fields. */ - return orig_field; -} - /* Return value of a constant X and sign-extend it. */ HOST_WIDE_INT @@ -9900,77 +10797,52 @@ unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x); /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */ - gcc_assert (TREE_INT_CST_HIGH (x) == 0 - || TREE_INT_CST_HIGH (x) == -1); + gcc_assert (cst_and_fits_in_hwi (x)); if (bits < HOST_BITS_PER_WIDE_INT) { bool negative = ((val >> (bits - 1)) & 1) != 0; if (negative) - val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1; + val |= HOST_WIDE_INT_M1U << (bits - 1) << 1; else - val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1); + val &= ~(HOST_WIDE_INT_M1U << (bits - 1) << 1); } return val; } -/* Return value of a constant X and sign-extend it. */ - -HOST_WIDEST_INT -widest_int_cst_value (const_tree x) -{ - unsigned bits = TYPE_PRECISION (TREE_TYPE (x)); - unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x); - -#if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT - gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT); - val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x)) - << HOST_BITS_PER_WIDE_INT); -#else - /* Make sure the sign-extended value will fit in a HOST_WIDE_INT. */ - gcc_assert (TREE_INT_CST_HIGH (x) == 0 - || TREE_INT_CST_HIGH (x) == -1); -#endif - - if (bits < HOST_BITS_PER_WIDEST_INT) - { - bool negative = ((val >> (bits - 1)) & 1) != 0; - if (negative) - val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1; - else - val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1); - } - - return val; -} - -/* If TYPE is an integral type, return an equivalent type which is - unsigned iff UNSIGNEDP is true. If TYPE is not an integral type, - return TYPE itself. */ +/* If TYPE is an integral or pointer type, return an integer type with + the same precision which is unsigned iff UNSIGNEDP is true, or itself + if TYPE is already an integer type of signedness UNSIGNEDP. */ tree signed_or_unsigned_type_for (int unsignedp, tree type) { - tree t = type; - if (POINTER_TYPE_P (type)) - { - /* If the pointer points to the normal address space, use the - size_type_node. Otherwise use an appropriate size for the pointer - based on the named address space it points to. */ - if (!TYPE_ADDR_SPACE (TREE_TYPE (t))) - t = size_type_node; - else - return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp); - } - - if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp) - return t; - - return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp); -} - -/* Returns unsigned variant of TYPE. */ + if (TREE_CODE (type) == INTEGER_TYPE && TYPE_UNSIGNED (type) == unsignedp) + return type; + + if (TREE_CODE (type) == VECTOR_TYPE) + { + tree inner = TREE_TYPE (type); + tree inner2 = signed_or_unsigned_type_for (unsignedp, inner); + if (!inner2) + return NULL_TREE; + if (inner == inner2) + return type; + return build_vector_type (inner2, TYPE_VECTOR_SUBPARTS (type)); + } + + if (!INTEGRAL_TYPE_P (type) + && !POINTER_TYPE_P (type) + && TREE_CODE (type) != OFFSET_TYPE) + return NULL_TREE; + + return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp); +} + +/* If TYPE is an integral or pointer type, return an integer type with + the same precision which is unsigned, or itself if TYPE is already an + unsigned integer type. */ tree unsigned_type_for (tree type) @@ -9978,7 +10850,9 @@ return signed_or_unsigned_type_for (1, type); } -/* Returns signed variant of TYPE. */ +/* If TYPE is an integral or pointer type, return an integer type with + the same precision which is signed, or itself if TYPE is already a + signed integer type. */ tree signed_type_for (tree type) @@ -9986,13 +10860,29 @@ return signed_or_unsigned_type_for (0, type); } +/* If TYPE is a vector type, return a signed integer vector type with the + same width and number of subparts. Otherwise return boolean_type_node. */ + +tree +truth_type_for (tree type) +{ + if (TREE_CODE (type) == VECTOR_TYPE) + { + if (VECTOR_BOOLEAN_TYPE_P (type)) + return type; + return build_truth_vector_type (TYPE_VECTOR_SUBPARTS (type), + GET_MODE_SIZE (TYPE_MODE (type))); + } + else + return boolean_type_node; +} + /* Returns the largest value obtainable by casting something in INNER type to OUTER type. */ tree upper_bound_in_type (tree outer, tree inner) { - unsigned HOST_WIDE_INT lo, hi; unsigned int det = 0; unsigned oprec = TYPE_PRECISION (outer); unsigned iprec = TYPE_PRECISION (inner); @@ -10036,21 +10926,8 @@ gcc_unreachable (); } - /* Compute 2^^prec - 1. */ - if (prec <= HOST_BITS_PER_WIDE_INT) - { - hi = 0; - lo = ((~(unsigned HOST_WIDE_INT) 0) - >> (HOST_BITS_PER_WIDE_INT - prec)); - } - else - { - hi = ((~(unsigned HOST_WIDE_INT) 0) - >> (2 * HOST_BITS_PER_WIDE_INT - prec)); - lo = ~(unsigned HOST_WIDE_INT) 0; - } - - return build_int_cst_wide (outer, lo, hi); + return wide_int_to_tree (outer, + wi::mask (prec, false, TYPE_PRECISION (outer))); } /* Returns the smallest value obtainable by casting something in INNER type to @@ -10059,7 +10936,6 @@ tree lower_bound_in_type (tree outer, tree inner) { - unsigned HOST_WIDE_INT lo, hi; unsigned oprec = TYPE_PRECISION (outer); unsigned iprec = TYPE_PRECISION (inner); @@ -10070,7 +10946,7 @@ contains all values of INNER type. In particular, both INNER and OUTER types have zero in common. */ || (oprec > iprec && TYPE_UNSIGNED (inner))) - lo = hi = 0; + return build_int_cst (outer, 0); else { /* If we are widening a signed type to another signed type, we @@ -10078,21 +10954,10 @@ precision or narrowing to a signed type, we want to obtain -2^(oprec-1). */ unsigned prec = oprec > iprec ? iprec : oprec; - - if (prec <= HOST_BITS_PER_WIDE_INT) - { - hi = ~(unsigned HOST_WIDE_INT) 0; - lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1); - } - else - { - hi = ((~(unsigned HOST_WIDE_INT) 0) - << (prec - HOST_BITS_PER_WIDE_INT - 1)); - lo = 0; - } - } - - return build_int_cst_wide (outer, lo, hi); + return wide_int_to_tree (outer, + wi::mask (prec - 1, true, + TYPE_PRECISION (outer))); + } } /* Return nonzero if two operands that are suitable for PHI nodes are @@ -10111,42 +10976,12 @@ return operand_equal_p (arg0, arg1, 0); } -/* Returns number of zeros at the end of binary representation of X. - - ??? Use ffs if available? */ +/* Returns number of zeros at the end of binary representation of X. */ tree num_ending_zeros (const_tree x) { - unsigned HOST_WIDE_INT fr, nfr; - unsigned num, abits; - tree type = TREE_TYPE (x); - - if (TREE_INT_CST_LOW (x) == 0) - { - num = HOST_BITS_PER_WIDE_INT; - fr = TREE_INT_CST_HIGH (x); - } - else - { - num = 0; - fr = TREE_INT_CST_LOW (x); - } - - for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2) - { - nfr = fr >> abits; - if (nfr << abits == fr) - { - num += abits; - fr = nfr; - } - } - - if (num > TYPE_PRECISION (type)) - num = TYPE_PRECISION (type); - - return build_int_cst_type (type, num); + return build_int_cst (TREE_TYPE (x), wi::ctz (wi::to_wide (x))); } @@ -10165,7 +11000,7 @@ static tree walk_type_fields (tree type, walk_tree_fn func, void *data, - struct pointer_set_t *pset, walk_tree_lh lh) + hash_set<tree> *pset, walk_tree_lh lh) { tree result = NULL_TREE; @@ -10173,6 +11008,7 @@ { case POINTER_TYPE: case REFERENCE_TYPE: + case VECTOR_TYPE: /* We have to worry about mutually recursive pointers. These can't be written in C. They can in Ada. It's pathological, but there's an ACATS test (c38102a) that checks it. Deal with this @@ -10193,7 +11029,7 @@ break; } - /* ... fall through ... */ + /* fall through */ case COMPLEX_TYPE: WALK_SUBTREE (TREE_TYPE (type)); @@ -10246,7 +11082,7 @@ tree walk_tree_1 (tree *tp, walk_tree_fn func, void *data, - struct pointer_set_t *pset, walk_tree_lh lh) + hash_set<tree> *pset, walk_tree_lh lh) { enum tree_code code; int walk_subtrees; @@ -10267,7 +11103,7 @@ /* Don't walk the same tree twice, if the user has requested that we avoid doing so. */ - if (pset && pointer_set_insert (pset, *tp)) + if (pset && pset->add (*tp)) return NULL_TREE; /* Call the function. */ @@ -10347,8 +11183,7 @@ unsigned HOST_WIDE_INT idx; constructor_elt *ce; - for (idx = 0; - VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce); + for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce); idx++) WALK_SUBTREE (ce->value); } @@ -10385,21 +11220,70 @@ case OMP_CLAUSE: switch (OMP_CLAUSE_CODE (*tp)) { + case OMP_CLAUSE_GANG: + case OMP_CLAUSE__GRIDDIM_: + WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1)); + /* FALLTHRU */ + + case OMP_CLAUSE_ASYNC: + case OMP_CLAUSE_WAIT: + case OMP_CLAUSE_WORKER: + case OMP_CLAUSE_VECTOR: + case OMP_CLAUSE_NUM_GANGS: + case OMP_CLAUSE_NUM_WORKERS: + case OMP_CLAUSE_VECTOR_LENGTH: case OMP_CLAUSE_PRIVATE: case OMP_CLAUSE_SHARED: case OMP_CLAUSE_FIRSTPRIVATE: case OMP_CLAUSE_COPYIN: case OMP_CLAUSE_COPYPRIVATE: + case OMP_CLAUSE_FINAL: case OMP_CLAUSE_IF: case OMP_CLAUSE_NUM_THREADS: case OMP_CLAUSE_SCHEDULE: + case OMP_CLAUSE_UNIFORM: + case OMP_CLAUSE_DEPEND: + case OMP_CLAUSE_NUM_TEAMS: + case OMP_CLAUSE_THREAD_LIMIT: + case OMP_CLAUSE_DEVICE: + case OMP_CLAUSE_DIST_SCHEDULE: + case OMP_CLAUSE_SAFELEN: + case OMP_CLAUSE_SIMDLEN: + case OMP_CLAUSE_ORDERED: + case OMP_CLAUSE_PRIORITY: + case OMP_CLAUSE_GRAINSIZE: + case OMP_CLAUSE_NUM_TASKS: + case OMP_CLAUSE_HINT: + case OMP_CLAUSE_TO_DECLARE: + case OMP_CLAUSE_LINK: + case OMP_CLAUSE_USE_DEVICE_PTR: + case OMP_CLAUSE_IS_DEVICE_PTR: + case OMP_CLAUSE__LOOPTEMP_: + case OMP_CLAUSE__SIMDUID_: + case OMP_CLAUSE__CILK_FOR_COUNT_: WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0)); /* FALLTHRU */ + case OMP_CLAUSE_INDEPENDENT: case OMP_CLAUSE_NOWAIT: - case OMP_CLAUSE_ORDERED: case OMP_CLAUSE_DEFAULT: case OMP_CLAUSE_UNTIED: + case OMP_CLAUSE_MERGEABLE: + case OMP_CLAUSE_PROC_BIND: + case OMP_CLAUSE_INBRANCH: + case OMP_CLAUSE_NOTINBRANCH: + case OMP_CLAUSE_FOR: + case OMP_CLAUSE_PARALLEL: + case OMP_CLAUSE_SECTIONS: + case OMP_CLAUSE_TASKGROUP: + case OMP_CLAUSE_NOGROUP: + case OMP_CLAUSE_THREADS: + case OMP_CLAUSE_SIMD: + case OMP_CLAUSE_DEFAULTMAP: + case OMP_CLAUSE_AUTO: + case OMP_CLAUSE_SEQ: + case OMP_CLAUSE_TILE: + case OMP_CLAUSE__SIMT_: WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); case OMP_CLAUSE_LASTPRIVATE: @@ -10415,10 +11299,25 @@ WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); } + case OMP_CLAUSE_LINEAR: + WALK_SUBTREE (OMP_CLAUSE_DECL (*tp)); + WALK_SUBTREE (OMP_CLAUSE_LINEAR_STEP (*tp)); + WALK_SUBTREE (OMP_CLAUSE_LINEAR_STMT (*tp)); + WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); + + case OMP_CLAUSE_ALIGNED: + case OMP_CLAUSE_FROM: + case OMP_CLAUSE_TO: + case OMP_CLAUSE_MAP: + case OMP_CLAUSE__CACHE_: + WALK_SUBTREE (OMP_CLAUSE_DECL (*tp)); + WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1)); + WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); + case OMP_CLAUSE_REDUCTION: { int i; - for (i = 0; i < 4; i++) + for (i = 0; i < 5; i++) WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i)); WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); } @@ -10465,9 +11364,14 @@ if (result || !walk_subtrees) return result; - result = walk_type_fields (*type_p, func, data, pset, lh); - if (result) - return result; + /* But do not walk a pointed-to type since it may itself need to + be walked in the declaration case if it isn't anonymous. */ + if (!POINTER_TYPE_P (*type_p)) + { + result = walk_type_fields (*type_p, func, data, pset, lh); + if (result) + return result; + } /* If this is a record type, also walk the fields. */ if (RECORD_OR_UNION_TYPE_P (*type_p)) @@ -10545,26 +11449,37 @@ walk_tree_lh lh) { tree result; - struct pointer_set_t *pset; - - pset = pointer_set_create (); - result = walk_tree_1 (tp, func, data, pset, lh); - pointer_set_destroy (pset); + + hash_set<tree> pset; + result = walk_tree_1 (tp, func, data, &pset, lh); return result; } -tree * +tree tree_block (tree t) { - char const c = TREE_CODE_CLASS (TREE_CODE (t)); + const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t)); if (IS_EXPR_CODE_CLASS (c)) - return &t->exp.block; + return LOCATION_BLOCK (t->exp.locus); gcc_unreachable (); return NULL; } +void +tree_set_block (tree t, tree b) +{ + const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t)); + + if (IS_EXPR_CODE_CLASS (c)) + { + t->exp.locus = set_block (t->exp.locus, b); + } + else + gcc_unreachable (); +} + /* Create a nameless artificial label and put it in the current function context. The label has a location of LOC. Returns the newly created label. */ @@ -10594,6 +11509,13 @@ STRIP_NOPS (stripped_decl); if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl)) return IDENTIFIER_POINTER (DECL_NAME (stripped_decl)); + else if (TREE_CODE (stripped_decl) == SSA_NAME) + { + tree name = SSA_NAME_IDENTIFIER (stripped_decl); + if (!name) + return NULL; + return IDENTIFIER_POINTER (name); + } else { switch (TREE_CODE (stripped_decl)) @@ -10617,7 +11539,7 @@ if (!fntype) return false; - FOREACH_FUNCTION_ARGS(fntype, t, args_iter) + FOREACH_FUNCTION_ARGS (fntype, t, args_iter) { n = t; } @@ -10628,7 +11550,7 @@ /* Return true if TYPE has a prototype. */ bool -prototype_p (tree fntype) +prototype_p (const_tree fntype) { tree t; @@ -10695,12 +11617,12 @@ /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq nodes. */ -/* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */ - -static hashval_t -cl_option_hash_hash (const void *x) -{ - const_tree const t = (const_tree) x; +/* Return the hash code X, an OPTIMIZATION_NODE or TARGET_OPTION code. */ + +hashval_t +cl_option_hasher::hash (tree x) +{ + const_tree const t = x; const char *p; size_t i; size_t len = 0; @@ -10713,10 +11635,7 @@ } else if (TREE_CODE (t) == TARGET_OPTION_NODE) - { - p = (const char *)TREE_TARGET_OPTION (t); - len = sizeof (struct cl_target_option); - } + return cl_target_option_hash (TREE_TARGET_OPTION (t)); else gcc_unreachable (); @@ -10734,11 +11653,11 @@ TARGET_OPTION tree node) is the same as that given by *Y, which is the same. */ -static int -cl_option_hash_eq (const void *x, const void *y) -{ - const_tree const xt = (const_tree) x; - const_tree const yt = (const_tree) y; +bool +cl_option_hasher::equal (tree x, tree y) +{ + const_tree const xt = x; + const_tree const yt = y; const char *xp; const char *yp; size_t len; @@ -10755,9 +11674,8 @@ else if (TREE_CODE (xt) == TARGET_OPTION_NODE) { - xp = (const char *)TREE_TARGET_OPTION (xt); - yp = (const char *)TREE_TARGET_OPTION (yt); - len = sizeof (struct cl_target_option); + return cl_target_option_eq (TREE_TARGET_OPTION (xt), + TREE_TARGET_OPTION (yt)); } else @@ -10766,21 +11684,20 @@ return (memcmp (xp, yp, len) == 0); } -/* Build an OPTIMIZATION_NODE based on the current options. */ - -tree -build_optimization_node (void) +/* Build an OPTIMIZATION_NODE based on the options in OPTS. */ + +tree +build_optimization_node (struct gcc_options *opts) { tree t; - void **slot; /* Use the cache of optimization nodes. */ cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node), - &global_options); - - slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT); - t = (tree) *slot; + opts); + + tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT); + t = *slot; if (!t) { /* Insert this one into the hash table. */ @@ -10794,21 +11711,20 @@ return t; } -/* Build a TARGET_OPTION_NODE based on the current options. */ - -tree -build_target_option_node (void) +/* Build a TARGET_OPTION_NODE based on the options in OPTS. */ + +tree +build_target_option_node (struct gcc_options *opts) { tree t; - void **slot; /* Use the cache of optimization nodes. */ cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node), - &global_options); - - slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT); - t = (tree) *slot; + opts); + + tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT); + t = *slot; if (!t) { /* Insert this one into the hash table. */ @@ -10822,6 +11738,18 @@ return t; } +/* Clear TREE_TARGET_GLOBALS of all TARGET_OPTION_NODE trees, + so that they aren't saved during PCH writing. */ + +void +prepare_target_option_nodes_for_pch (void) +{ + hash_table<cl_option_hasher>::iterator iter = cl_option_hash_table->begin (); + for (; iter != cl_option_hash_table->end (); ++iter) + if (TREE_CODE (*iter) == TARGET_OPTION_NODE) + TREE_TARGET_GLOBALS (*iter) = NULL; +} + /* Determine the "ultimate origin" of a block. The block may be an inlined instance of an inlined instance of a block which is local to an inline function, so we have to trace all of the way back through the origin chain @@ -10833,8 +11761,7 @@ { tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block); - /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the - nodes in the function to point to themselves; ignore that if + /* BLOCK_ABSTRACT_ORIGIN can point to itself; ignore that if we're trying to output the abstract instance of this function. */ if (BLOCK_ABSTRACT (block) && immediate_origin == block) return NULL_TREE; @@ -10867,15 +11794,42 @@ } } -/* Return true if T1 and T2 are equivalent lists. */ +/* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates + no instruction. */ bool -list_equal_p (const_tree t1, const_tree t2) -{ - for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2)) - if (TREE_VALUE (t1) != TREE_VALUE (t2)) +tree_nop_conversion_p (const_tree outer_type, const_tree inner_type) +{ + /* Do not strip casts into or out of differing address spaces. */ + if (POINTER_TYPE_P (outer_type) + && TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) != ADDR_SPACE_GENERIC) + { + if (!POINTER_TYPE_P (inner_type) + || (TYPE_ADDR_SPACE (TREE_TYPE (outer_type)) + != TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))) + return false; + } + else if (POINTER_TYPE_P (inner_type) + && TYPE_ADDR_SPACE (TREE_TYPE (inner_type)) != ADDR_SPACE_GENERIC) + { + /* We already know that outer_type is not a pointer with + a non-generic address space. */ return false; - return !t1 && !t2; + } + + /* Use precision rather then machine mode when we can, which gives + the correct answer even for submode (bit-field) types. */ + if ((INTEGRAL_TYPE_P (outer_type) + || POINTER_TYPE_P (outer_type) + || TREE_CODE (outer_type) == OFFSET_TYPE) + && (INTEGRAL_TYPE_P (inner_type) + || POINTER_TYPE_P (inner_type) + || TREE_CODE (inner_type) == OFFSET_TYPE)) + return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type); + + /* Otherwise fall back on comparing machine modes (e.g. for + aggregate types, floats). */ + return TYPE_MODE (outer_type) == TYPE_MODE (inner_type); } /* Return true iff conversion in EXP generates no instruction. Mark @@ -10899,19 +11853,7 @@ if (!inner_type) return false; - /* Use precision rather then machine mode when we can, which gives - the correct answer even for submode (bit-field) types. */ - if ((INTEGRAL_TYPE_P (outer_type) - || POINTER_TYPE_P (outer_type) - || TREE_CODE (outer_type) == OFFSET_TYPE) - && (INTEGRAL_TYPE_P (inner_type) - || POINTER_TYPE_P (inner_type) - || TREE_CODE (inner_type) == OFFSET_TYPE)) - return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type); - - /* Otherwise fall back on comparing machine modes (e.g. for - aggregate types, floats). */ - return TYPE_MODE (outer_type) == TYPE_MODE (inner_type); + return tree_nop_conversion_p (outer_type, inner_type); } /* Return true iff conversion in EXP generates no instruction. Don't @@ -10954,6 +11896,83 @@ return exp; } +/* Avoid any floating point extensions from EXP. */ +tree +strip_float_extensions (tree exp) +{ + tree sub, expt, subt; + + /* For floating point constant look up the narrowest type that can hold + it properly and handle it like (type)(narrowest_type)constant. + This way we can optimize for instance a=a*2.0 where "a" is float + but 2.0 is double constant. */ + if (TREE_CODE (exp) == REAL_CST && !DECIMAL_FLOAT_TYPE_P (TREE_TYPE (exp))) + { + REAL_VALUE_TYPE orig; + tree type = NULL; + + orig = TREE_REAL_CST (exp); + if (TYPE_PRECISION (TREE_TYPE (exp)) > TYPE_PRECISION (float_type_node) + && exact_real_truncate (TYPE_MODE (float_type_node), &orig)) + type = float_type_node; + else if (TYPE_PRECISION (TREE_TYPE (exp)) + > TYPE_PRECISION (double_type_node) + && exact_real_truncate (TYPE_MODE (double_type_node), &orig)) + type = double_type_node; + if (type) + return build_real_truncate (type, orig); + } + + if (!CONVERT_EXPR_P (exp)) + return exp; + + sub = TREE_OPERAND (exp, 0); + subt = TREE_TYPE (sub); + expt = TREE_TYPE (exp); + + if (!FLOAT_TYPE_P (subt)) + return exp; + + if (DECIMAL_FLOAT_TYPE_P (expt) != DECIMAL_FLOAT_TYPE_P (subt)) + return exp; + + if (TYPE_PRECISION (subt) > TYPE_PRECISION (expt)) + return exp; + + return strip_float_extensions (sub); +} + +/* Strip out all handled components that produce invariant + offsets. */ + +const_tree +strip_invariant_refs (const_tree op) +{ + while (handled_component_p (op)) + { + switch (TREE_CODE (op)) + { + case ARRAY_REF: + case ARRAY_RANGE_REF: + if (!is_gimple_constant (TREE_OPERAND (op, 1)) + || TREE_OPERAND (op, 2) != NULL_TREE + || TREE_OPERAND (op, 3) != NULL_TREE) + return NULL; + break; + + case COMPONENT_REF: + if (TREE_OPERAND (op, 2) != NULL_TREE) + return NULL; + break; + + default:; + } + op = TREE_OPERAND (op, 0); + } + + return op; +} + static GTY(()) tree gcc_eh_personality_decl; /* Return the GCC personality function decl. */ @@ -10966,6 +11985,68 @@ return gcc_eh_personality_decl; } +/* TARGET is a call target of GIMPLE call statement + (obtained by gimple_call_fn). Return true if it is + OBJ_TYPE_REF representing an virtual call of C++ method. + (As opposed to OBJ_TYPE_REF representing objc calls + through a cast where middle-end devirtualization machinery + can't apply.) */ + +bool +virtual_method_call_p (const_tree target) +{ + if (TREE_CODE (target) != OBJ_TYPE_REF) + return false; + tree t = TREE_TYPE (target); + gcc_checking_assert (TREE_CODE (t) == POINTER_TYPE); + t = TREE_TYPE (t); + if (TREE_CODE (t) == FUNCTION_TYPE) + return false; + gcc_checking_assert (TREE_CODE (t) == METHOD_TYPE); + /* If we do not have BINFO associated, it means that type was built + without devirtualization enabled. Do not consider this a virtual + call. */ + if (!TYPE_BINFO (obj_type_ref_class (target))) + return false; + return true; +} + +/* REF is OBJ_TYPE_REF, return the class the ref corresponds to. */ + +tree +obj_type_ref_class (const_tree ref) +{ + gcc_checking_assert (TREE_CODE (ref) == OBJ_TYPE_REF); + ref = TREE_TYPE (ref); + gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE); + ref = TREE_TYPE (ref); + /* We look for type THIS points to. ObjC also builds + OBJ_TYPE_REF with non-method calls, Their first parameter + ID however also corresponds to class type. */ + gcc_checking_assert (TREE_CODE (ref) == METHOD_TYPE + || TREE_CODE (ref) == FUNCTION_TYPE); + ref = TREE_VALUE (TYPE_ARG_TYPES (ref)); + gcc_checking_assert (TREE_CODE (ref) == POINTER_TYPE); + return TREE_TYPE (ref); +} + +/* Lookup sub-BINFO of BINFO of TYPE at offset POS. */ + +static tree +lookup_binfo_at_offset (tree binfo, tree type, HOST_WIDE_INT pos) +{ + unsigned int i; + tree base_binfo, b; + + for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) + if (pos == tree_to_shwi (BINFO_OFFSET (base_binfo)) + && types_same_for_odr (TREE_TYPE (base_binfo), type)) + return base_binfo; + else if ((b = lookup_binfo_at_offset (base_binfo, type, pos)) != NULL) + return b; + return NULL; +} + /* Try to find a base info of BINFO that would have its field decl at offset OFFSET within the BINFO type and which is of EXPECTED_TYPE. If it can be found, return, otherwise return NULL_TREE. */ @@ -10981,45 +12062,47 @@ tree fld; int i; - if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (expected_type)) + if (types_same_for_odr (type, expected_type)) return binfo; if (offset < 0) return NULL_TREE; for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld)) { - if (TREE_CODE (fld) != FIELD_DECL) + if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld)) continue; pos = int_bit_position (fld); - size = tree_low_cst (DECL_SIZE (fld), 1); + size = tree_to_uhwi (DECL_SIZE (fld)); if (pos <= offset && (pos + size) > offset) break; } if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE) return NULL_TREE; - if (!DECL_ARTIFICIAL (fld)) - { - binfo = TYPE_BINFO (TREE_TYPE (fld)); - if (!binfo) - return NULL_TREE; - } /* Offset 0 indicates the primary base, whose vtable contents are represented in the binfo for the derived class. */ else if (offset != 0) { - tree base_binfo, found_binfo = NULL_TREE; + tree found_binfo = NULL, base_binfo; + /* Offsets in BINFO are in bytes relative to the whole structure + while POS is in bits relative to the containing field. */ + int binfo_offset = (tree_to_shwi (BINFO_OFFSET (binfo)) + pos + / BITS_PER_UNIT); + for (i = 0; BINFO_BASE_ITERATE (binfo, i, base_binfo); i++) - if (TREE_TYPE (base_binfo) == TREE_TYPE (fld)) + if (tree_to_shwi (BINFO_OFFSET (base_binfo)) == binfo_offset + && types_same_for_odr (TREE_TYPE (base_binfo), TREE_TYPE (fld))) { found_binfo = base_binfo; break; } - if (!found_binfo) - return NULL_TREE; - binfo = found_binfo; - } + if (found_binfo) + binfo = found_binfo; + else + binfo = lookup_binfo_at_offset (binfo, TREE_TYPE (fld), + binfo_offset); + } type = TREE_TYPE (fld); offset -= pos; @@ -11029,7 +12112,7 @@ /* Returns true if X is a typedef decl. */ bool -is_typedef_decl (tree x) +is_typedef_decl (const_tree x) { return (x && TREE_CODE (x) == TYPE_DECL && DECL_ORIGINAL_TYPE (x) != NULL_TREE); @@ -11038,7 +12121,7 @@ /* Returns true iff TYPE is a type variant created for a typedef. */ bool -typedef_variant_p (tree type) +typedef_variant_p (const_tree type) { return is_typedef_decl (TYPE_NAME (type)); } @@ -11073,17 +12156,17 @@ else msg = NULL; + bool w; if (DECL_P (node)) { - expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node)); if (msg) - warning (OPT_Wdeprecated_declarations, - "%qD is deprecated (declared at %s:%d): %s", - node, xloc.file, xloc.line, msg); + w = warning (OPT_Wdeprecated_declarations, + "%qD is deprecated: %s", node, msg); else - warning (OPT_Wdeprecated_declarations, - "%qD is deprecated (declared at %s:%d)", - node, xloc.file, xloc.line); + w = warning (OPT_Wdeprecated_declarations, + "%qD is deprecated", node); + if (w) + inform (DECL_SOURCE_LOCATION (node), "declared here"); } else if (TYPE_P (node)) { @@ -11101,30 +12184,26 @@ if (decl) { - expanded_location xloc - = expand_location (DECL_SOURCE_LOCATION (decl)); if (what) { if (msg) - warning (OPT_Wdeprecated_declarations, - "%qE is deprecated (declared at %s:%d): %s", - what, xloc.file, xloc.line, msg); + w = warning (OPT_Wdeprecated_declarations, + "%qE is deprecated: %s", what, msg); else - warning (OPT_Wdeprecated_declarations, - "%qE is deprecated (declared at %s:%d)", what, - xloc.file, xloc.line); + w = warning (OPT_Wdeprecated_declarations, + "%qE is deprecated", what); } else { if (msg) - warning (OPT_Wdeprecated_declarations, - "type is deprecated (declared at %s:%d): %s", - xloc.file, xloc.line, msg); + w = warning (OPT_Wdeprecated_declarations, + "type is deprecated: %s", msg); else - warning (OPT_Wdeprecated_declarations, - "type is deprecated (declared at %s:%d)", - xloc.file, xloc.line); + w = warning (OPT_Wdeprecated_declarations, + "type is deprecated"); } + if (w) + inform (DECL_SOURCE_LOCATION (decl), "declared here"); } else { @@ -11148,4 +12227,1663 @@ } } +/* Return true if REF has a COMPONENT_REF with a bit-field field declaration + somewhere in it. */ + +bool +contains_bitfld_component_ref_p (const_tree ref) +{ + while (handled_component_p (ref)) + { + if (TREE_CODE (ref) == COMPONENT_REF + && DECL_BIT_FIELD (TREE_OPERAND (ref, 1))) + return true; + ref = TREE_OPERAND (ref, 0); + } + + return false; +} + +/* Try to determine whether a TRY_CATCH expression can fall through. + This is a subroutine of block_may_fallthru. */ + +static bool +try_catch_may_fallthru (const_tree stmt) +{ + tree_stmt_iterator i; + + /* If the TRY block can fall through, the whole TRY_CATCH can + fall through. */ + if (block_may_fallthru (TREE_OPERAND (stmt, 0))) + return true; + + i = tsi_start (TREE_OPERAND (stmt, 1)); + switch (TREE_CODE (tsi_stmt (i))) + { + case CATCH_EXPR: + /* We expect to see a sequence of CATCH_EXPR trees, each with a + catch expression and a body. The whole TRY_CATCH may fall + through iff any of the catch bodies falls through. */ + for (; !tsi_end_p (i); tsi_next (&i)) + { + if (block_may_fallthru (CATCH_BODY (tsi_stmt (i)))) + return true; + } + return false; + + case EH_FILTER_EXPR: + /* The exception filter expression only matters if there is an + exception. If the exception does not match EH_FILTER_TYPES, + we will execute EH_FILTER_FAILURE, and we will fall through + if that falls through. If the exception does match + EH_FILTER_TYPES, the stack unwinder will continue up the + stack, so we will not fall through. We don't know whether we + will throw an exception which matches EH_FILTER_TYPES or not, + so we just ignore EH_FILTER_TYPES and assume that we might + throw an exception which doesn't match. */ + return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i))); + + default: + /* This case represents statements to be executed when an + exception occurs. Those statements are implicitly followed + by a RESX statement to resume execution after the exception. + So in this case the TRY_CATCH never falls through. */ + return false; + } +} + +/* Try to determine if we can fall out of the bottom of BLOCK. This guess + need not be 100% accurate; simply be conservative and return true if we + don't know. This is used only to avoid stupidly generating extra code. + If we're wrong, we'll just delete the extra code later. */ + +bool +block_may_fallthru (const_tree block) +{ + /* This CONST_CAST is okay because expr_last returns its argument + unmodified and we assign it to a const_tree. */ + const_tree stmt = expr_last (CONST_CAST_TREE (block)); + + switch (stmt ? TREE_CODE (stmt) : ERROR_MARK) + { + case GOTO_EXPR: + case RETURN_EXPR: + /* Easy cases. If the last statement of the block implies + control transfer, then we can't fall through. */ + return false; + + case SWITCH_EXPR: + /* If SWITCH_LABELS is set, this is lowered, and represents a + branch to a selected label and hence can not fall through. + Otherwise SWITCH_BODY is set, and the switch can fall + through. */ + return SWITCH_LABELS (stmt) == NULL_TREE; + + case COND_EXPR: + if (block_may_fallthru (COND_EXPR_THEN (stmt))) + return true; + return block_may_fallthru (COND_EXPR_ELSE (stmt)); + + case BIND_EXPR: + return block_may_fallthru (BIND_EXPR_BODY (stmt)); + + case TRY_CATCH_EXPR: + return try_catch_may_fallthru (stmt); + + case TRY_FINALLY_EXPR: + /* The finally clause is always executed after the try clause, + so if it does not fall through, then the try-finally will not + fall through. Otherwise, if the try clause does not fall + through, then when the finally clause falls through it will + resume execution wherever the try clause was going. So the + whole try-finally will only fall through if both the try + clause and the finally clause fall through. */ + return (block_may_fallthru (TREE_OPERAND (stmt, 0)) + && block_may_fallthru (TREE_OPERAND (stmt, 1))); + + case MODIFY_EXPR: + if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR) + stmt = TREE_OPERAND (stmt, 1); + else + return true; + /* FALLTHRU */ + + case CALL_EXPR: + /* Functions that do not return do not fall through. */ + return (call_expr_flags (stmt) & ECF_NORETURN) == 0; + + case CLEANUP_POINT_EXPR: + return block_may_fallthru (TREE_OPERAND (stmt, 0)); + + case TARGET_EXPR: + return block_may_fallthru (TREE_OPERAND (stmt, 1)); + + case ERROR_MARK: + return true; + + default: + return lang_hooks.block_may_fallthru (stmt); + } +} + +/* True if we are using EH to handle cleanups. */ +static bool using_eh_for_cleanups_flag = false; + +/* This routine is called from front ends to indicate eh should be used for + cleanups. */ +void +using_eh_for_cleanups (void) +{ + using_eh_for_cleanups_flag = true; +} + +/* Query whether EH is used for cleanups. */ +bool +using_eh_for_cleanups_p (void) +{ + return using_eh_for_cleanups_flag; +} + +/* Wrapper for tree_code_name to ensure that tree code is valid */ +const char * +get_tree_code_name (enum tree_code code) +{ + const char *invalid = "<invalid tree code>"; + + if (code >= MAX_TREE_CODES) + return invalid; + + return tree_code_name[code]; +} + +/* Drops the TREE_OVERFLOW flag from T. */ + +tree +drop_tree_overflow (tree t) +{ + gcc_checking_assert (TREE_OVERFLOW (t)); + + /* For tree codes with a sharing machinery re-build the result. */ + if (TREE_CODE (t) == INTEGER_CST) + return wide_int_to_tree (TREE_TYPE (t), wi::to_wide (t)); + + /* Otherwise, as all tcc_constants are possibly shared, copy the node + and drop the flag. */ + t = copy_node (t); + TREE_OVERFLOW (t) = 0; + + /* For constants that contain nested constants, drop the flag + from those as well. */ + if (TREE_CODE (t) == COMPLEX_CST) + { + if (TREE_OVERFLOW (TREE_REALPART (t))) + TREE_REALPART (t) = drop_tree_overflow (TREE_REALPART (t)); + if (TREE_OVERFLOW (TREE_IMAGPART (t))) + TREE_IMAGPART (t) = drop_tree_overflow (TREE_IMAGPART (t)); + } + if (TREE_CODE (t) == VECTOR_CST) + { + for (unsigned i = 0; i < VECTOR_CST_NELTS (t); ++i) + { + tree& elt = VECTOR_CST_ELT (t, i); + if (TREE_OVERFLOW (elt)) + elt = drop_tree_overflow (elt); + } + } + return t; +} + +/* Given a memory reference expression T, return its base address. + The base address of a memory reference expression is the main + object being referenced. For instance, the base address for + 'array[i].fld[j]' is 'array'. You can think of this as stripping + away the offset part from a memory address. + + This function calls handled_component_p to strip away all the inner + parts of the memory reference until it reaches the base object. */ + +tree +get_base_address (tree t) +{ + while (handled_component_p (t)) + t = TREE_OPERAND (t, 0); + + if ((TREE_CODE (t) == MEM_REF + || TREE_CODE (t) == TARGET_MEM_REF) + && TREE_CODE (TREE_OPERAND (t, 0)) == ADDR_EXPR) + t = TREE_OPERAND (TREE_OPERAND (t, 0), 0); + + /* ??? Either the alias oracle or all callers need to properly deal + with WITH_SIZE_EXPRs before we can look through those. */ + if (TREE_CODE (t) == WITH_SIZE_EXPR) + return NULL_TREE; + + return t; +} + +/* Return a tree of sizetype representing the size, in bytes, of the element + of EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ + +tree +array_ref_element_size (tree exp) +{ + tree aligned_size = TREE_OPERAND (exp, 3); + tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))); + location_t loc = EXPR_LOCATION (exp); + + /* If a size was specified in the ARRAY_REF, it's the size measured + in alignment units of the element type. So multiply by that value. */ + if (aligned_size) + { + /* ??? tree_ssa_useless_type_conversion will eliminate casts to + sizetype from another type of the same width and signedness. */ + if (TREE_TYPE (aligned_size) != sizetype) + aligned_size = fold_convert_loc (loc, sizetype, aligned_size); + return size_binop_loc (loc, MULT_EXPR, aligned_size, + size_int (TYPE_ALIGN_UNIT (elmt_type))); + } + + /* Otherwise, take the size from that of the element type. Substitute + any PLACEHOLDER_EXPR that we have. */ + else + return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_SIZE_UNIT (elmt_type), exp); +} + +/* Return a tree representing the lower bound of the array mentioned in + EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ + +tree +array_ref_low_bound (tree exp) +{ + tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0))); + + /* If a lower bound is specified in EXP, use it. */ + if (TREE_OPERAND (exp, 2)) + return TREE_OPERAND (exp, 2); + + /* Otherwise, if there is a domain type and it has a lower bound, use it, + substituting for a PLACEHOLDER_EXPR as needed. */ + if (domain_type && TYPE_MIN_VALUE (domain_type)) + return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MIN_VALUE (domain_type), exp); + + /* Otherwise, return a zero of the appropriate type. */ + return build_int_cst (TREE_TYPE (TREE_OPERAND (exp, 1)), 0); +} + +/* Return a tree representing the upper bound of the array mentioned in + EXP, an ARRAY_REF or an ARRAY_RANGE_REF. */ + +tree +array_ref_up_bound (tree exp) +{ + tree domain_type = TYPE_DOMAIN (TREE_TYPE (TREE_OPERAND (exp, 0))); + + /* If there is a domain type and it has an upper bound, use it, substituting + for a PLACEHOLDER_EXPR as needed. */ + if (domain_type && TYPE_MAX_VALUE (domain_type)) + return SUBSTITUTE_PLACEHOLDER_IN_EXPR (TYPE_MAX_VALUE (domain_type), exp); + + /* Otherwise fail. */ + return NULL_TREE; +} + +/* Returns true if REF is an array reference or a component reference + to an array at the end of a structure. + If this is the case, the array may be allocated larger + than its upper bound implies. */ + +bool +array_at_struct_end_p (tree ref) +{ + tree atype; + + if (TREE_CODE (ref) == ARRAY_REF + || TREE_CODE (ref) == ARRAY_RANGE_REF) + { + atype = TREE_TYPE (TREE_OPERAND (ref, 0)); + ref = TREE_OPERAND (ref, 0); + } + else if (TREE_CODE (ref) == COMPONENT_REF + && TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 1))) == ARRAY_TYPE) + atype = TREE_TYPE (TREE_OPERAND (ref, 1)); + else + return false; + + if (TREE_CODE (ref) == STRING_CST) + return false; + + while (handled_component_p (ref)) + { + /* If the reference chain contains a component reference to a + non-union type and there follows another field the reference + is not at the end of a structure. */ + if (TREE_CODE (ref) == COMPONENT_REF) + { + if (TREE_CODE (TREE_TYPE (TREE_OPERAND (ref, 0))) == RECORD_TYPE) + { + tree nextf = DECL_CHAIN (TREE_OPERAND (ref, 1)); + while (nextf && TREE_CODE (nextf) != FIELD_DECL) + nextf = DECL_CHAIN (nextf); + if (nextf) + return false; + } + } + /* If we have a multi-dimensional array we do not consider + a non-innermost dimension as flex array if the whole + multi-dimensional array is at struct end. + Same for an array of aggregates with a trailing array + member. */ + else if (TREE_CODE (ref) == ARRAY_REF) + return false; + else if (TREE_CODE (ref) == ARRAY_RANGE_REF) + ; + /* If we view an underlying object as sth else then what we + gathered up to now is what we have to rely on. */ + else if (TREE_CODE (ref) == VIEW_CONVERT_EXPR) + break; + else + gcc_unreachable (); + + ref = TREE_OPERAND (ref, 0); + } + + /* The array now is at struct end. Treat flexible arrays as + always subject to extend, even into just padding constrained by + an underlying decl. */ + if (! TYPE_SIZE (atype)) + return true; + + tree size = NULL; + + if (TREE_CODE (ref) == MEM_REF + && TREE_CODE (TREE_OPERAND (ref, 0)) == ADDR_EXPR) + { + size = TYPE_SIZE (TREE_TYPE (ref)); + ref = TREE_OPERAND (TREE_OPERAND (ref, 0), 0); + } + + /* If the reference is based on a declared entity, the size of the array + is constrained by its given domain. (Do not trust commons PR/69368). */ + if (DECL_P (ref) + /* Be sure the size of MEM_REF target match. For example: + + char buf[10]; + struct foo *str = (struct foo *)&buf; + + str->trailin_array[2] = 1; + + is valid because BUF allocate enough space. */ + + && (!size || (DECL_SIZE (ref) != NULL + && operand_equal_p (DECL_SIZE (ref), size, 0))) + && !(flag_unconstrained_commons + && VAR_P (ref) && DECL_COMMON (ref))) + return false; + + return true; +} + +/* Return a tree representing the offset, in bytes, of the field referenced + by EXP. This does not include any offset in DECL_FIELD_BIT_OFFSET. */ + +tree +component_ref_field_offset (tree exp) +{ + tree aligned_offset = TREE_OPERAND (exp, 2); + tree field = TREE_OPERAND (exp, 1); + location_t loc = EXPR_LOCATION (exp); + + /* If an offset was specified in the COMPONENT_REF, it's the offset measured + in units of DECL_OFFSET_ALIGN / BITS_PER_UNIT. So multiply by that + value. */ + if (aligned_offset) + { + /* ??? tree_ssa_useless_type_conversion will eliminate casts to + sizetype from another type of the same width and signedness. */ + if (TREE_TYPE (aligned_offset) != sizetype) + aligned_offset = fold_convert_loc (loc, sizetype, aligned_offset); + return size_binop_loc (loc, MULT_EXPR, aligned_offset, + size_int (DECL_OFFSET_ALIGN (field) + / BITS_PER_UNIT)); + } + + /* Otherwise, take the offset from that of the field. Substitute + any PLACEHOLDER_EXPR that we have. */ + else + return SUBSTITUTE_PLACEHOLDER_IN_EXPR (DECL_FIELD_OFFSET (field), exp); +} + +/* Return the machine mode of T. For vectors, returns the mode of the + inner type. The main use case is to feed the result to HONOR_NANS, + avoiding the BLKmode that a direct TYPE_MODE (T) might return. */ + +machine_mode +element_mode (const_tree t) +{ + if (!TYPE_P (t)) + t = TREE_TYPE (t); + if (VECTOR_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE) + t = TREE_TYPE (t); + return TYPE_MODE (t); +} + +/* Vector types need to re-check the target flags each time we report + the machine mode. We need to do this because attribute target can + change the result of vector_mode_supported_p and have_regs_of_mode + on a per-function basis. Thus the TYPE_MODE of a VECTOR_TYPE can + change on a per-function basis. */ +/* ??? Possibly a better solution is to run through all the types + referenced by a function and re-compute the TYPE_MODE once, rather + than make the TYPE_MODE macro call a function. */ + +machine_mode +vector_type_mode (const_tree t) +{ + machine_mode mode; + + gcc_assert (TREE_CODE (t) == VECTOR_TYPE); + + mode = t->type_common.mode; + if (VECTOR_MODE_P (mode) + && (!targetm.vector_mode_supported_p (mode) + || !have_regs_of_mode[mode])) + { + scalar_int_mode innermode; + + /* For integers, try mapping it to a same-sized scalar mode. */ + if (is_int_mode (TREE_TYPE (t)->type_common.mode, &innermode)) + { + unsigned int size = (TYPE_VECTOR_SUBPARTS (t) + * GET_MODE_BITSIZE (innermode)); + scalar_int_mode mode; + if (int_mode_for_size (size, 0).exists (&mode) + && have_regs_of_mode[mode]) + return mode; + } + + return BLKmode; + } + + return mode; +} + +/* Verify that basic properties of T match TV and thus T can be a variant of + TV. TV should be the more specified variant (i.e. the main variant). */ + +static bool +verify_type_variant (const_tree t, tree tv) +{ + /* Type variant can differ by: + + - TYPE_QUALS: TYPE_READONLY, TYPE_VOLATILE, TYPE_ATOMIC, TYPE_RESTRICT, + ENCODE_QUAL_ADDR_SPACE. + - main variant may be TYPE_COMPLETE_P and variant types !TYPE_COMPLETE_P + in this case some values may not be set in the variant types + (see TYPE_COMPLETE_P checks). + - it is possible to have TYPE_ARTIFICIAL variant of non-artifical type + - by TYPE_NAME and attributes (i.e. when variant originate by typedef) + - TYPE_CANONICAL (TYPE_ALIAS_SET is the same among variants) + - by the alignment: TYPE_ALIGN and TYPE_USER_ALIGN + - during LTO by TYPE_CONTEXT if type is TYPE_FILE_SCOPE_P + this is necessary to make it possible to merge types form different TUs + - arrays, pointers and references may have TREE_TYPE that is a variant + of TREE_TYPE of their main variants. + - aggregates may have new TYPE_FIELDS list that list variants of + the main variant TYPE_FIELDS. + - vector types may differ by TYPE_VECTOR_OPAQUE + */ + + /* Convenience macro for matching individual fields. */ +#define verify_variant_match(flag) \ + do { \ + if (flag (tv) != flag (t)) \ + { \ + error ("type variant differs by " #flag "."); \ + debug_tree (tv); \ + return false; \ + } \ + } while (false) + + /* tree_base checks. */ + + verify_variant_match (TREE_CODE); + /* FIXME: Ada builds non-artificial variants of artificial types. */ + if (TYPE_ARTIFICIAL (tv) && 0) + verify_variant_match (TYPE_ARTIFICIAL); + if (POINTER_TYPE_P (tv)) + verify_variant_match (TYPE_REF_CAN_ALIAS_ALL); + /* FIXME: TYPE_SIZES_GIMPLIFIED may differs for Ada build. */ + verify_variant_match (TYPE_UNSIGNED); + verify_variant_match (TYPE_PACKED); + if (TREE_CODE (t) == REFERENCE_TYPE) + verify_variant_match (TYPE_REF_IS_RVALUE); + if (AGGREGATE_TYPE_P (t)) + verify_variant_match (TYPE_REVERSE_STORAGE_ORDER); + else + verify_variant_match (TYPE_SATURATING); + /* FIXME: This check trigger during libstdc++ build. */ + if (RECORD_OR_UNION_TYPE_P (t) && COMPLETE_TYPE_P (t) && 0) + verify_variant_match (TYPE_FINAL_P); + + /* tree_type_common checks. */ + + if (COMPLETE_TYPE_P (t)) + { + verify_variant_match (TYPE_MODE); + if (TREE_CODE (TYPE_SIZE (t)) != PLACEHOLDER_EXPR + && TREE_CODE (TYPE_SIZE (tv)) != PLACEHOLDER_EXPR) + verify_variant_match (TYPE_SIZE); + if (TREE_CODE (TYPE_SIZE_UNIT (t)) != PLACEHOLDER_EXPR + && TREE_CODE (TYPE_SIZE_UNIT (tv)) != PLACEHOLDER_EXPR + && TYPE_SIZE_UNIT (t) != TYPE_SIZE_UNIT (tv)) + { + gcc_assert (!operand_equal_p (TYPE_SIZE_UNIT (t), + TYPE_SIZE_UNIT (tv), 0)); + error ("type variant has different TYPE_SIZE_UNIT"); + debug_tree (tv); + error ("type variant's TYPE_SIZE_UNIT"); + debug_tree (TYPE_SIZE_UNIT (tv)); + error ("type's TYPE_SIZE_UNIT"); + debug_tree (TYPE_SIZE_UNIT (t)); + return false; + } + } + verify_variant_match (TYPE_PRECISION); + verify_variant_match (TYPE_NEEDS_CONSTRUCTING); + if (RECORD_OR_UNION_TYPE_P (t)) + verify_variant_match (TYPE_TRANSPARENT_AGGR); + else if (TREE_CODE (t) == ARRAY_TYPE) + verify_variant_match (TYPE_NONALIASED_COMPONENT); + /* During LTO we merge variant lists from diferent translation units + that may differ BY TYPE_CONTEXT that in turn may point + to TRANSLATION_UNIT_DECL. + Ada also builds variants of types with different TYPE_CONTEXT. */ + if ((!in_lto_p || !TYPE_FILE_SCOPE_P (t)) && 0) + verify_variant_match (TYPE_CONTEXT); + verify_variant_match (TYPE_STRING_FLAG); + if (TYPE_ALIAS_SET_KNOWN_P (t)) + { + error ("type variant with TYPE_ALIAS_SET_KNOWN_P"); + debug_tree (tv); + return false; + } + + /* tree_type_non_common checks. */ + + /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS + and dangle the pointer from time to time. */ + if (RECORD_OR_UNION_TYPE_P (t) && TYPE_VFIELD (t) != TYPE_VFIELD (tv) + && (in_lto_p || !TYPE_VFIELD (tv) + || TREE_CODE (TYPE_VFIELD (tv)) != TREE_LIST)) + { + error ("type variant has different TYPE_VFIELD"); + debug_tree (tv); + return false; + } + if ((TREE_CODE (t) == ENUMERAL_TYPE && COMPLETE_TYPE_P (t)) + || TREE_CODE (t) == INTEGER_TYPE + || TREE_CODE (t) == BOOLEAN_TYPE + || TREE_CODE (t) == REAL_TYPE + || TREE_CODE (t) == FIXED_POINT_TYPE) + { + verify_variant_match (TYPE_MAX_VALUE); + verify_variant_match (TYPE_MIN_VALUE); + } + if (TREE_CODE (t) == METHOD_TYPE) + verify_variant_match (TYPE_METHOD_BASETYPE); + if (TREE_CODE (t) == OFFSET_TYPE) + verify_variant_match (TYPE_OFFSET_BASETYPE); + if (TREE_CODE (t) == ARRAY_TYPE) + verify_variant_match (TYPE_ARRAY_MAX_SIZE); + /* FIXME: Be lax and allow TYPE_BINFO to be missing in variant types + or even type's main variant. This is needed to make bootstrap pass + and the bug seems new in GCC 5. + C++ FE should be updated to make this consistent and we should check + that TYPE_BINFO is always NULL for !COMPLETE_TYPE_P and otherwise there + is a match with main variant. + + Also disable the check for Java for now because of parser hack that builds + first an dummy BINFO and then sometimes replace it by real BINFO in some + of the copies. */ + if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t) && TYPE_BINFO (tv) + && TYPE_BINFO (t) != TYPE_BINFO (tv) + /* FIXME: Java sometimes keep dump TYPE_BINFOs on variant types. + Since there is no cheap way to tell C++/Java type w/o LTO, do checking + at LTO time only. */ + && (in_lto_p && odr_type_p (t))) + { + error ("type variant has different TYPE_BINFO"); + debug_tree (tv); + error ("type variant's TYPE_BINFO"); + debug_tree (TYPE_BINFO (tv)); + error ("type's TYPE_BINFO"); + debug_tree (TYPE_BINFO (t)); + return false; + } + + /* Check various uses of TYPE_VALUES_RAW. */ + if (TREE_CODE (t) == ENUMERAL_TYPE) + verify_variant_match (TYPE_VALUES); + else if (TREE_CODE (t) == ARRAY_TYPE) + verify_variant_match (TYPE_DOMAIN); + /* Permit incomplete variants of complete type. While FEs may complete + all variants, this does not happen for C++ templates in all cases. */ + else if (RECORD_OR_UNION_TYPE_P (t) + && COMPLETE_TYPE_P (t) + && TYPE_FIELDS (t) != TYPE_FIELDS (tv)) + { + tree f1, f2; + + /* Fortran builds qualified variants as new records with items of + qualified type. Verify that they looks same. */ + for (f1 = TYPE_FIELDS (t), f2 = TYPE_FIELDS (tv); + f1 && f2; + f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2)) + if (TREE_CODE (f1) != FIELD_DECL || TREE_CODE (f2) != FIELD_DECL + || (TYPE_MAIN_VARIANT (TREE_TYPE (f1)) + != TYPE_MAIN_VARIANT (TREE_TYPE (f2)) + /* FIXME: gfc_nonrestricted_type builds all types as variants + with exception of pointer types. It deeply copies the type + which means that we may end up with a variant type + referring non-variant pointer. We may change it to + produce types as variants, too, like + objc_get_protocol_qualified_type does. */ + && !POINTER_TYPE_P (TREE_TYPE (f1))) + || DECL_FIELD_OFFSET (f1) != DECL_FIELD_OFFSET (f2) + || DECL_FIELD_BIT_OFFSET (f1) != DECL_FIELD_BIT_OFFSET (f2)) + break; + if (f1 || f2) + { + error ("type variant has different TYPE_FIELDS"); + debug_tree (tv); + error ("first mismatch is field"); + debug_tree (f1); + error ("and field"); + debug_tree (f2); + return false; + } + } + else if ((TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE)) + verify_variant_match (TYPE_ARG_TYPES); + /* For C++ the qualified variant of array type is really an array type + of qualified TREE_TYPE. + objc builds variants of pointer where pointer to type is a variant, too + in objc_get_protocol_qualified_type. */ + if (TREE_TYPE (t) != TREE_TYPE (tv) + && ((TREE_CODE (t) != ARRAY_TYPE + && !POINTER_TYPE_P (t)) + || TYPE_MAIN_VARIANT (TREE_TYPE (t)) + != TYPE_MAIN_VARIANT (TREE_TYPE (tv)))) + { + error ("type variant has different TREE_TYPE"); + debug_tree (tv); + error ("type variant's TREE_TYPE"); + debug_tree (TREE_TYPE (tv)); + error ("type's TREE_TYPE"); + debug_tree (TREE_TYPE (t)); + return false; + } + if (type_with_alias_set_p (t) + && !gimple_canonical_types_compatible_p (t, tv, false)) + { + error ("type is not compatible with its variant"); + debug_tree (tv); + error ("type variant's TREE_TYPE"); + debug_tree (TREE_TYPE (tv)); + error ("type's TREE_TYPE"); + debug_tree (TREE_TYPE (t)); + return false; + } + return true; +#undef verify_variant_match +} + + +/* The TYPE_CANONICAL merging machinery. It should closely resemble + the middle-end types_compatible_p function. It needs to avoid + claiming types are different for types that should be treated + the same with respect to TBAA. Canonical types are also used + for IL consistency checks via the useless_type_conversion_p + predicate which does not handle all type kinds itself but falls + back to pointer-comparison of TYPE_CANONICAL for aggregates + for example. */ + +/* Return true if TYPE_UNSIGNED of TYPE should be ignored for canonical + type calculation because we need to allow inter-operability between signed + and unsigned variants. */ + +bool +type_with_interoperable_signedness (const_tree type) +{ + /* Fortran standard require C_SIGNED_CHAR to be interoperable with both + signed char and unsigned char. Similarly fortran FE builds + C_SIZE_T as signed type, while C defines it unsigned. */ + + return tree_code_for_canonical_type_merging (TREE_CODE (type)) + == INTEGER_TYPE + && (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node) + || TYPE_PRECISION (type) == TYPE_PRECISION (size_type_node)); +} + +/* Return true iff T1 and T2 are structurally identical for what + TBAA is concerned. + This function is used both by lto.c canonical type merging and by the + verifier. If TRUST_TYPE_CANONICAL we do not look into structure of types + that have TYPE_CANONICAL defined and assume them equivalent. This is useful + only for LTO because only in these cases TYPE_CANONICAL equivalence + correspond to one defined by gimple_canonical_types_compatible_p. */ + +bool +gimple_canonical_types_compatible_p (const_tree t1, const_tree t2, + bool trust_type_canonical) +{ + /* Type variants should be same as the main variant. When not doing sanity + checking to verify this fact, go to main variants and save some work. */ + if (trust_type_canonical) + { + t1 = TYPE_MAIN_VARIANT (t1); + t2 = TYPE_MAIN_VARIANT (t2); + } + + /* Check first for the obvious case of pointer identity. */ + if (t1 == t2) + return true; + + /* Check that we have two types to compare. */ + if (t1 == NULL_TREE || t2 == NULL_TREE) + return false; + + /* We consider complete types always compatible with incomplete type. + This does not make sense for canonical type calculation and thus we + need to ensure that we are never called on it. + + FIXME: For more correctness the function probably should have three modes + 1) mode assuming that types are complete mathcing their structure + 2) mode allowing incomplete types but producing equivalence classes + and thus ignoring all info from complete types + 3) mode allowing incomplete types to match complete but checking + compatibility between complete types. + + 1 and 2 can be used for canonical type calculation. 3 is the real + definition of type compatibility that can be used i.e. for warnings during + declaration merging. */ + + gcc_assert (!trust_type_canonical + || (type_with_alias_set_p (t1) && type_with_alias_set_p (t2))); + /* If the types have been previously registered and found equal + they still are. */ + + if (TYPE_CANONICAL (t1) && TYPE_CANONICAL (t2) + && trust_type_canonical) + { + /* Do not use TYPE_CANONICAL of pointer types. For LTO streamed types + they are always NULL, but they are set to non-NULL for types + constructed by build_pointer_type and variants. In this case the + TYPE_CANONICAL is more fine grained than the equivalnce we test (where + all pointers are considered equal. Be sure to not return false + negatives. */ + gcc_checking_assert (canonical_type_used_p (t1) + && canonical_type_used_p (t2)); + return TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2); + } + + /* Can't be the same type if the types don't have the same code. */ + enum tree_code code = tree_code_for_canonical_type_merging (TREE_CODE (t1)); + if (code != tree_code_for_canonical_type_merging (TREE_CODE (t2))) + return false; + + /* Qualifiers do not matter for canonical type comparison purposes. */ + + /* Void types and nullptr types are always the same. */ + if (TREE_CODE (t1) == VOID_TYPE + || TREE_CODE (t1) == NULLPTR_TYPE) + return true; + + /* Can't be the same type if they have different mode. */ + if (TYPE_MODE (t1) != TYPE_MODE (t2)) + return false; + + /* Non-aggregate types can be handled cheaply. */ + if (INTEGRAL_TYPE_P (t1) + || SCALAR_FLOAT_TYPE_P (t1) + || FIXED_POINT_TYPE_P (t1) + || TREE_CODE (t1) == VECTOR_TYPE + || TREE_CODE (t1) == COMPLEX_TYPE + || TREE_CODE (t1) == OFFSET_TYPE + || POINTER_TYPE_P (t1)) + { + /* Can't be the same type if they have different recision. */ + if (TYPE_PRECISION (t1) != TYPE_PRECISION (t2)) + return false; + + /* In some cases the signed and unsigned types are required to be + inter-operable. */ + if (TYPE_UNSIGNED (t1) != TYPE_UNSIGNED (t2) + && !type_with_interoperable_signedness (t1)) + return false; + + /* Fortran's C_SIGNED_CHAR is !TYPE_STRING_FLAG but needs to be + interoperable with "signed char". Unless all frontends are revisited + to agree on these types, we must ignore the flag completely. */ + + /* Fortran standard define C_PTR type that is compatible with every + C pointer. For this reason we need to glob all pointers into one. + Still pointers in different address spaces are not compatible. */ + if (POINTER_TYPE_P (t1)) + { + if (TYPE_ADDR_SPACE (TREE_TYPE (t1)) + != TYPE_ADDR_SPACE (TREE_TYPE (t2))) + return false; + } + + /* Tail-recurse to components. */ + if (TREE_CODE (t1) == VECTOR_TYPE + || TREE_CODE (t1) == COMPLEX_TYPE) + return gimple_canonical_types_compatible_p (TREE_TYPE (t1), + TREE_TYPE (t2), + trust_type_canonical); + + return true; + } + + /* Do type-specific comparisons. */ + switch (TREE_CODE (t1)) + { + case ARRAY_TYPE: + /* Array types are the same if the element types are the same and + the number of elements are the same. */ + if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2), + trust_type_canonical) + || TYPE_STRING_FLAG (t1) != TYPE_STRING_FLAG (t2) + || TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2) + || TYPE_NONALIASED_COMPONENT (t1) != TYPE_NONALIASED_COMPONENT (t2)) + return false; + else + { + tree i1 = TYPE_DOMAIN (t1); + tree i2 = TYPE_DOMAIN (t2); + + /* For an incomplete external array, the type domain can be + NULL_TREE. Check this condition also. */ + if (i1 == NULL_TREE && i2 == NULL_TREE) + return true; + else if (i1 == NULL_TREE || i2 == NULL_TREE) + return false; + else + { + tree min1 = TYPE_MIN_VALUE (i1); + tree min2 = TYPE_MIN_VALUE (i2); + tree max1 = TYPE_MAX_VALUE (i1); + tree max2 = TYPE_MAX_VALUE (i2); + + /* The minimum/maximum values have to be the same. */ + if ((min1 == min2 + || (min1 && min2 + && ((TREE_CODE (min1) == PLACEHOLDER_EXPR + && TREE_CODE (min2) == PLACEHOLDER_EXPR) + || operand_equal_p (min1, min2, 0)))) + && (max1 == max2 + || (max1 && max2 + && ((TREE_CODE (max1) == PLACEHOLDER_EXPR + && TREE_CODE (max2) == PLACEHOLDER_EXPR) + || operand_equal_p (max1, max2, 0))))) + return true; + else + return false; + } + } + + case METHOD_TYPE: + case FUNCTION_TYPE: + /* Function types are the same if the return type and arguments types + are the same. */ + if (!gimple_canonical_types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2), + trust_type_canonical)) + return false; + + if (TYPE_ARG_TYPES (t1) == TYPE_ARG_TYPES (t2)) + return true; + else + { + tree parms1, parms2; + + for (parms1 = TYPE_ARG_TYPES (t1), parms2 = TYPE_ARG_TYPES (t2); + parms1 && parms2; + parms1 = TREE_CHAIN (parms1), parms2 = TREE_CHAIN (parms2)) + { + if (!gimple_canonical_types_compatible_p + (TREE_VALUE (parms1), TREE_VALUE (parms2), + trust_type_canonical)) + return false; + } + + if (parms1 || parms2) + return false; + + return true; + } + + case RECORD_TYPE: + case UNION_TYPE: + case QUAL_UNION_TYPE: + { + tree f1, f2; + + /* Don't try to compare variants of an incomplete type, before + TYPE_FIELDS has been copied around. */ + if (!COMPLETE_TYPE_P (t1) && !COMPLETE_TYPE_P (t2)) + return true; + + + if (TYPE_REVERSE_STORAGE_ORDER (t1) != TYPE_REVERSE_STORAGE_ORDER (t2)) + return false; + + /* For aggregate types, all the fields must be the same. */ + for (f1 = TYPE_FIELDS (t1), f2 = TYPE_FIELDS (t2); + f1 || f2; + f1 = TREE_CHAIN (f1), f2 = TREE_CHAIN (f2)) + { + /* Skip non-fields and zero-sized fields. */ + while (f1 && (TREE_CODE (f1) != FIELD_DECL + || (DECL_SIZE (f1) + && integer_zerop (DECL_SIZE (f1))))) + f1 = TREE_CHAIN (f1); + while (f2 && (TREE_CODE (f2) != FIELD_DECL + || (DECL_SIZE (f2) + && integer_zerop (DECL_SIZE (f2))))) + f2 = TREE_CHAIN (f2); + if (!f1 || !f2) + break; + /* The fields must have the same name, offset and type. */ + if (DECL_NONADDRESSABLE_P (f1) != DECL_NONADDRESSABLE_P (f2) + || !gimple_compare_field_offset (f1, f2) + || !gimple_canonical_types_compatible_p + (TREE_TYPE (f1), TREE_TYPE (f2), + trust_type_canonical)) + return false; + } + + /* If one aggregate has more fields than the other, they + are not the same. */ + if (f1 || f2) + return false; + + return true; + } + + default: + /* Consider all types with language specific trees in them mutually + compatible. This is executed only from verify_type and false + positives can be tolerated. */ + gcc_assert (!in_lto_p); + return true; + } +} + +/* Verify type T. */ + +void +verify_type (const_tree t) +{ + bool error_found = false; + tree mv = TYPE_MAIN_VARIANT (t); + if (!mv) + { + error ("Main variant is not defined"); + error_found = true; + } + else if (mv != TYPE_MAIN_VARIANT (mv)) + { + error ("TYPE_MAIN_VARIANT has different TYPE_MAIN_VARIANT"); + debug_tree (mv); + error_found = true; + } + else if (t != mv && !verify_type_variant (t, mv)) + error_found = true; + + tree ct = TYPE_CANONICAL (t); + if (!ct) + ; + else if (TYPE_CANONICAL (t) != ct) + { + error ("TYPE_CANONICAL has different TYPE_CANONICAL"); + debug_tree (ct); + error_found = true; + } + /* Method and function types can not be used to address memory and thus + TYPE_CANONICAL really matters only for determining useless conversions. + + FIXME: C++ FE produce declarations of builtin functions that are not + compatible with main variants. */ + else if (TREE_CODE (t) == FUNCTION_TYPE) + ; + else if (t != ct + /* FIXME: gimple_canonical_types_compatible_p can not compare types + with variably sized arrays because their sizes possibly + gimplified to different variables. */ + && !variably_modified_type_p (ct, NULL) + && !gimple_canonical_types_compatible_p (t, ct, false)) + { + error ("TYPE_CANONICAL is not compatible"); + debug_tree (ct); + error_found = true; + } + + if (COMPLETE_TYPE_P (t) && TYPE_CANONICAL (t) + && TYPE_MODE (t) != TYPE_MODE (TYPE_CANONICAL (t))) + { + error ("TYPE_MODE of TYPE_CANONICAL is not compatible"); + debug_tree (ct); + error_found = true; + } + if (TYPE_MAIN_VARIANT (t) == t && ct && TYPE_MAIN_VARIANT (ct) != ct) + { + error ("TYPE_CANONICAL of main variant is not main variant"); + debug_tree (ct); + debug_tree (TYPE_MAIN_VARIANT (ct)); + error_found = true; + } + + + /* Check various uses of TYPE_MIN_VALUE_RAW. */ + if (RECORD_OR_UNION_TYPE_P (t)) + { + /* FIXME: C FE uses TYPE_VFIELD to record C_TYPE_INCOMPLETE_VARS + and danagle the pointer from time to time. */ + if (TYPE_VFIELD (t) + && TREE_CODE (TYPE_VFIELD (t)) != FIELD_DECL + && TREE_CODE (TYPE_VFIELD (t)) != TREE_LIST) + { + error ("TYPE_VFIELD is not FIELD_DECL nor TREE_LIST"); + debug_tree (TYPE_VFIELD (t)); + error_found = true; + } + } + else if (TREE_CODE (t) == POINTER_TYPE) + { + if (TYPE_NEXT_PTR_TO (t) + && TREE_CODE (TYPE_NEXT_PTR_TO (t)) != POINTER_TYPE) + { + error ("TYPE_NEXT_PTR_TO is not POINTER_TYPE"); + debug_tree (TYPE_NEXT_PTR_TO (t)); + error_found = true; + } + } + else if (TREE_CODE (t) == REFERENCE_TYPE) + { + if (TYPE_NEXT_REF_TO (t) + && TREE_CODE (TYPE_NEXT_REF_TO (t)) != REFERENCE_TYPE) + { + error ("TYPE_NEXT_REF_TO is not REFERENCE_TYPE"); + debug_tree (TYPE_NEXT_REF_TO (t)); + error_found = true; + } + } + else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE + || TREE_CODE (t) == FIXED_POINT_TYPE) + { + /* FIXME: The following check should pass: + useless_type_conversion_p (const_cast <tree> (t), + TREE_TYPE (TYPE_MIN_VALUE (t)) + but does not for C sizetypes in LTO. */ + } + + /* Check various uses of TYPE_MAXVAL_RAW. */ + if (RECORD_OR_UNION_TYPE_P (t)) + { + if (!TYPE_BINFO (t)) + ; + else if (TREE_CODE (TYPE_BINFO (t)) != TREE_BINFO) + { + error ("TYPE_BINFO is not TREE_BINFO"); + debug_tree (TYPE_BINFO (t)); + error_found = true; + } + else if (TREE_TYPE (TYPE_BINFO (t)) != TYPE_MAIN_VARIANT (t)) + { + error ("TYPE_BINFO type is not TYPE_MAIN_VARIANT"); + debug_tree (TREE_TYPE (TYPE_BINFO (t))); + error_found = true; + } + } + else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE) + { + if (TYPE_METHOD_BASETYPE (t) + && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != RECORD_TYPE + && TREE_CODE (TYPE_METHOD_BASETYPE (t)) != UNION_TYPE) + { + error ("TYPE_METHOD_BASETYPE is not record nor union"); + debug_tree (TYPE_METHOD_BASETYPE (t)); + error_found = true; + } + } + else if (TREE_CODE (t) == OFFSET_TYPE) + { + if (TYPE_OFFSET_BASETYPE (t) + && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != RECORD_TYPE + && TREE_CODE (TYPE_OFFSET_BASETYPE (t)) != UNION_TYPE) + { + error ("TYPE_OFFSET_BASETYPE is not record nor union"); + debug_tree (TYPE_OFFSET_BASETYPE (t)); + error_found = true; + } + } + else if (INTEGRAL_TYPE_P (t) || TREE_CODE (t) == REAL_TYPE + || TREE_CODE (t) == FIXED_POINT_TYPE) + { + /* FIXME: The following check should pass: + useless_type_conversion_p (const_cast <tree> (t), + TREE_TYPE (TYPE_MAX_VALUE (t)) + but does not for C sizetypes in LTO. */ + } + else if (TREE_CODE (t) == ARRAY_TYPE) + { + if (TYPE_ARRAY_MAX_SIZE (t) + && TREE_CODE (TYPE_ARRAY_MAX_SIZE (t)) != INTEGER_CST) + { + error ("TYPE_ARRAY_MAX_SIZE not INTEGER_CST"); + debug_tree (TYPE_ARRAY_MAX_SIZE (t)); + error_found = true; + } + } + else if (TYPE_MAX_VALUE_RAW (t)) + { + error ("TYPE_MAX_VALUE_RAW non-NULL"); + debug_tree (TYPE_MAX_VALUE_RAW (t)); + error_found = true; + } + + if (TYPE_LANG_SLOT_1 (t) && in_lto_p) + { + error ("TYPE_LANG_SLOT_1 (binfo) field is non-NULL"); + debug_tree (TYPE_LANG_SLOT_1 (t)); + error_found = true; + } + + /* Check various uses of TYPE_VALUES_RAW. */ + if (TREE_CODE (t) == ENUMERAL_TYPE) + for (tree l = TYPE_VALUES (t); l; l = TREE_CHAIN (l)) + { + tree value = TREE_VALUE (l); + tree name = TREE_PURPOSE (l); + + /* C FE porduce INTEGER_CST of INTEGER_TYPE, while C++ FE uses + CONST_DECL of ENUMERAL TYPE. */ + if (TREE_CODE (value) != INTEGER_CST && TREE_CODE (value) != CONST_DECL) + { + error ("Enum value is not CONST_DECL or INTEGER_CST"); + debug_tree (value); + debug_tree (name); + error_found = true; + } + if (TREE_CODE (TREE_TYPE (value)) != INTEGER_TYPE + && !useless_type_conversion_p (const_cast <tree> (t), TREE_TYPE (value))) + { + error ("Enum value type is not INTEGER_TYPE nor convertible to the enum"); + debug_tree (value); + debug_tree (name); + error_found = true; + } + if (TREE_CODE (name) != IDENTIFIER_NODE) + { + error ("Enum value name is not IDENTIFIER_NODE"); + debug_tree (value); + debug_tree (name); + error_found = true; + } + } + else if (TREE_CODE (t) == ARRAY_TYPE) + { + if (TYPE_DOMAIN (t) && TREE_CODE (TYPE_DOMAIN (t)) != INTEGER_TYPE) + { + error ("Array TYPE_DOMAIN is not integer type"); + debug_tree (TYPE_DOMAIN (t)); + error_found = true; + } + } + else if (RECORD_OR_UNION_TYPE_P (t)) + { + if (TYPE_FIELDS (t) && !COMPLETE_TYPE_P (t) && in_lto_p) + { + error ("TYPE_FIELDS defined in incomplete type"); + error_found = true; + } + for (tree fld = TYPE_FIELDS (t); fld; fld = TREE_CHAIN (fld)) + { + /* TODO: verify properties of decls. */ + if (TREE_CODE (fld) == FIELD_DECL) + ; + else if (TREE_CODE (fld) == TYPE_DECL) + ; + else if (TREE_CODE (fld) == CONST_DECL) + ; + else if (VAR_P (fld)) + ; + else if (TREE_CODE (fld) == TEMPLATE_DECL) + ; + else if (TREE_CODE (fld) == USING_DECL) + ; + else if (TREE_CODE (fld) == FUNCTION_DECL) + ; + else + { + error ("Wrong tree in TYPE_FIELDS list"); + debug_tree (fld); + error_found = true; + } + } + } + else if (TREE_CODE (t) == INTEGER_TYPE + || TREE_CODE (t) == BOOLEAN_TYPE + || TREE_CODE (t) == OFFSET_TYPE + || TREE_CODE (t) == REFERENCE_TYPE + || TREE_CODE (t) == NULLPTR_TYPE + || TREE_CODE (t) == POINTER_TYPE) + { + if (TYPE_CACHED_VALUES_P (t) != (TYPE_CACHED_VALUES (t) != NULL)) + { + error ("TYPE_CACHED_VALUES_P is %i while TYPE_CACHED_VALUES is %p", + TYPE_CACHED_VALUES_P (t), (void *)TYPE_CACHED_VALUES (t)); + error_found = true; + } + else if (TYPE_CACHED_VALUES_P (t) && TREE_CODE (TYPE_CACHED_VALUES (t)) != TREE_VEC) + { + error ("TYPE_CACHED_VALUES is not TREE_VEC"); + debug_tree (TYPE_CACHED_VALUES (t)); + error_found = true; + } + /* Verify just enough of cache to ensure that no one copied it to new type. + All copying should go by copy_node that should clear it. */ + else if (TYPE_CACHED_VALUES_P (t)) + { + int i; + for (i = 0; i < TREE_VEC_LENGTH (TYPE_CACHED_VALUES (t)); i++) + if (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i) + && TREE_TYPE (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)) != t) + { + error ("wrong TYPE_CACHED_VALUES entry"); + debug_tree (TREE_VEC_ELT (TYPE_CACHED_VALUES (t), i)); + error_found = true; + break; + } + } + } + else if (TREE_CODE (t) == FUNCTION_TYPE || TREE_CODE (t) == METHOD_TYPE) + for (tree l = TYPE_ARG_TYPES (t); l; l = TREE_CHAIN (l)) + { + /* C++ FE uses TREE_PURPOSE to store initial values. */ + if (TREE_PURPOSE (l) && in_lto_p) + { + error ("TREE_PURPOSE is non-NULL in TYPE_ARG_TYPES list"); + debug_tree (l); + error_found = true; + } + if (!TYPE_P (TREE_VALUE (l))) + { + error ("Wrong entry in TYPE_ARG_TYPES list"); + debug_tree (l); + error_found = true; + } + } + else if (!is_lang_specific (t) && TYPE_VALUES_RAW (t)) + { + error ("TYPE_VALUES_RAW field is non-NULL"); + debug_tree (TYPE_VALUES_RAW (t)); + error_found = true; + } + if (TREE_CODE (t) != INTEGER_TYPE + && TREE_CODE (t) != BOOLEAN_TYPE + && TREE_CODE (t) != OFFSET_TYPE + && TREE_CODE (t) != REFERENCE_TYPE + && TREE_CODE (t) != NULLPTR_TYPE + && TREE_CODE (t) != POINTER_TYPE + && TYPE_CACHED_VALUES_P (t)) + { + error ("TYPE_CACHED_VALUES_P is set while it should not"); + error_found = true; + } + if (TYPE_STRING_FLAG (t) + && TREE_CODE (t) != ARRAY_TYPE && TREE_CODE (t) != INTEGER_TYPE) + { + error ("TYPE_STRING_FLAG is set on wrong type code"); + error_found = true; + } + + /* ipa-devirt makes an assumption that TYPE_METHOD_BASETYPE is always + TYPE_MAIN_VARIANT and it would be odd to add methods only to variatns + of a type. */ + if (TREE_CODE (t) == METHOD_TYPE + && TYPE_MAIN_VARIANT (TYPE_METHOD_BASETYPE (t)) != TYPE_METHOD_BASETYPE (t)) + { + error ("TYPE_METHOD_BASETYPE is not main variant"); + error_found = true; + } + + if (error_found) + { + debug_tree (const_cast <tree> (t)); + internal_error ("verify_type failed"); + } +} + + +/* Return 1 if ARG interpreted as signed in its precision is known to be + always positive or 2 if ARG is known to be always negative, or 3 if + ARG may be positive or negative. */ + +int +get_range_pos_neg (tree arg) +{ + if (arg == error_mark_node) + return 3; + + int prec = TYPE_PRECISION (TREE_TYPE (arg)); + int cnt = 0; + if (TREE_CODE (arg) == INTEGER_CST) + { + wide_int w = wi::sext (wi::to_wide (arg), prec); + if (wi::neg_p (w)) + return 2; + else + return 1; + } + while (CONVERT_EXPR_P (arg) + && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (arg, 0))) + && TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg, 0))) <= prec) + { + arg = TREE_OPERAND (arg, 0); + /* Narrower value zero extended into wider type + will always result in positive values. */ + if (TYPE_UNSIGNED (TREE_TYPE (arg)) + && TYPE_PRECISION (TREE_TYPE (arg)) < prec) + return 1; + prec = TYPE_PRECISION (TREE_TYPE (arg)); + if (++cnt > 30) + return 3; + } + + if (TREE_CODE (arg) != SSA_NAME) + return 3; + wide_int arg_min, arg_max; + while (get_range_info (arg, &arg_min, &arg_max) != VR_RANGE) + { + gimple *g = SSA_NAME_DEF_STMT (arg); + if (is_gimple_assign (g) + && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (g))) + { + tree t = gimple_assign_rhs1 (g); + if (INTEGRAL_TYPE_P (TREE_TYPE (t)) + && TYPE_PRECISION (TREE_TYPE (t)) <= prec) + { + if (TYPE_UNSIGNED (TREE_TYPE (t)) + && TYPE_PRECISION (TREE_TYPE (t)) < prec) + return 1; + prec = TYPE_PRECISION (TREE_TYPE (t)); + arg = t; + if (++cnt > 30) + return 3; + continue; + } + } + return 3; + } + if (TYPE_UNSIGNED (TREE_TYPE (arg))) + { + /* For unsigned values, the "positive" range comes + below the "negative" range. */ + if (!wi::neg_p (wi::sext (arg_max, prec), SIGNED)) + return 1; + if (wi::neg_p (wi::sext (arg_min, prec), SIGNED)) + return 2; + } + else + { + if (!wi::neg_p (wi::sext (arg_min, prec), SIGNED)) + return 1; + if (wi::neg_p (wi::sext (arg_max, prec), SIGNED)) + return 2; + } + return 3; +} + + + + +/* Return true if ARG is marked with the nonnull attribute in the + current function signature. */ + +bool +nonnull_arg_p (const_tree arg) +{ + tree t, attrs, fntype; + unsigned HOST_WIDE_INT arg_num; + + gcc_assert (TREE_CODE (arg) == PARM_DECL + && (POINTER_TYPE_P (TREE_TYPE (arg)) + || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)); + + /* The static chain decl is always non null. */ + if (arg == cfun->static_chain_decl) + return true; + + /* THIS argument of method is always non-NULL. */ + if (TREE_CODE (TREE_TYPE (cfun->decl)) == METHOD_TYPE + && arg == DECL_ARGUMENTS (cfun->decl) + && flag_delete_null_pointer_checks) + return true; + + /* Values passed by reference are always non-NULL. */ + if (TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE + && flag_delete_null_pointer_checks) + return true; + + fntype = TREE_TYPE (cfun->decl); + for (attrs = TYPE_ATTRIBUTES (fntype); attrs; attrs = TREE_CHAIN (attrs)) + { + attrs = lookup_attribute ("nonnull", attrs); + + /* If "nonnull" wasn't specified, we know nothing about the argument. */ + if (attrs == NULL_TREE) + return false; + + /* If "nonnull" applies to all the arguments, then ARG is non-null. */ + if (TREE_VALUE (attrs) == NULL_TREE) + return true; + + /* Get the position number for ARG in the function signature. */ + for (arg_num = 1, t = DECL_ARGUMENTS (cfun->decl); + t; + t = DECL_CHAIN (t), arg_num++) + { + if (t == arg) + break; + } + + gcc_assert (t == arg); + + /* Now see if ARG_NUM is mentioned in the nonnull list. */ + for (t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t)) + { + if (compare_tree_int (TREE_VALUE (t), arg_num) == 0) + return true; + } + } + + return false; +} + +/* Combine LOC and BLOCK to a combined adhoc loc, retaining any range + information. */ + +location_t +set_block (location_t loc, tree block) +{ + location_t pure_loc = get_pure_location (loc); + source_range src_range = get_range_from_loc (line_table, loc); + return COMBINE_LOCATION_DATA (line_table, pure_loc, src_range, block); +} + +location_t +set_source_range (tree expr, location_t start, location_t finish) +{ + source_range src_range; + src_range.m_start = start; + src_range.m_finish = finish; + return set_source_range (expr, src_range); +} + +location_t +set_source_range (tree expr, source_range src_range) +{ + if (!EXPR_P (expr)) + return UNKNOWN_LOCATION; + + location_t pure_loc = get_pure_location (EXPR_LOCATION (expr)); + location_t adhoc = COMBINE_LOCATION_DATA (line_table, + pure_loc, + src_range, + NULL); + SET_EXPR_LOCATION (expr, adhoc); + return adhoc; +} + +/* Return the name of combined function FN, for debugging purposes. */ + +const char * +combined_fn_name (combined_fn fn) +{ + if (builtin_fn_p (fn)) + { + tree fndecl = builtin_decl_explicit (as_builtin_fn (fn)); + return IDENTIFIER_POINTER (DECL_NAME (fndecl)); + } + else + return internal_fn_name (as_internal_fn (fn)); +} + +/* Return a bitmap with a bit set corresponding to each argument in + a function call type FNTYPE declared with attribute nonnull, + or null if none of the function's argument are nonnull. The caller + must free the bitmap. */ + +bitmap +get_nonnull_args (const_tree fntype) +{ + if (fntype == NULL_TREE) + return NULL; + + tree attrs = TYPE_ATTRIBUTES (fntype); + if (!attrs) + return NULL; + + bitmap argmap = NULL; + + /* A function declaration can specify multiple attribute nonnull, + each with zero or more arguments. The loop below creates a bitmap + representing a union of all the arguments. An empty (but non-null) + bitmap means that all arguments have been declaraed nonnull. */ + for ( ; attrs; attrs = TREE_CHAIN (attrs)) + { + attrs = lookup_attribute ("nonnull", attrs); + if (!attrs) + break; + + if (!argmap) + argmap = BITMAP_ALLOC (NULL); + + if (!TREE_VALUE (attrs)) + { + /* Clear the bitmap in case a previous attribute nonnull + set it and this one overrides it for all arguments. */ + bitmap_clear (argmap); + return argmap; + } + + /* Iterate over the indices of the format arguments declared nonnull + and set a bit for each. */ + for (tree idx = TREE_VALUE (attrs); idx; idx = TREE_CHAIN (idx)) + { + unsigned int val = TREE_INT_CST_LOW (TREE_VALUE (idx)) - 1; + bitmap_set_bit (argmap, val); + } + } + + return argmap; +} + +/* List of pointer types used to declare builtins before we have seen their + real declaration. + + Keep the size up to date in tree.h ! */ +const builtin_structptr_type builtin_structptr_types[6] = +{ + { fileptr_type_node, ptr_type_node, "FILE" }, + { const_tm_ptr_type_node, const_ptr_type_node, "tm" }, + { fenv_t_ptr_type_node, ptr_type_node, "fenv_t" }, + { const_fenv_t_ptr_type_node, const_ptr_type_node, "fenv_t" }, + { fexcept_t_ptr_type_node, ptr_type_node, "fexcept_t" }, + { const_fexcept_t_ptr_type_node, const_ptr_type_node, "fexcept_t" } +}; + +#if CHECKING_P + +namespace selftest { + +/* Selftests for tree. */ + +/* Verify that integer constants are sane. */ + +static void +test_integer_constants () +{ + ASSERT_TRUE (integer_type_node != NULL); + ASSERT_TRUE (build_int_cst (integer_type_node, 0) != NULL); + + tree type = integer_type_node; + + tree zero = build_zero_cst (type); + ASSERT_EQ (INTEGER_CST, TREE_CODE (zero)); + ASSERT_EQ (type, TREE_TYPE (zero)); + + tree one = build_int_cst (type, 1); + ASSERT_EQ (INTEGER_CST, TREE_CODE (one)); + ASSERT_EQ (type, TREE_TYPE (zero)); +} + +/* Verify identifiers. */ + +static void +test_identifiers () +{ + tree identifier = get_identifier ("foo"); + ASSERT_EQ (3, IDENTIFIER_LENGTH (identifier)); + ASSERT_STREQ ("foo", IDENTIFIER_POINTER (identifier)); +} + +/* Verify LABEL_DECL. */ + +static void +test_labels () +{ + tree identifier = get_identifier ("err"); + tree label_decl = build_decl (UNKNOWN_LOCATION, LABEL_DECL, + identifier, void_type_node); + ASSERT_EQ (-1, LABEL_DECL_UID (label_decl)); + ASSERT_FALSE (FORCED_LABEL (label_decl)); +} + +/* Run all of the selftests within this file. */ + +void +tree_c_tests () +{ + test_integer_constants (); + test_identifiers (); + test_labels (); +} + +} // namespace selftest + +#endif /* CHECKING_P */ + #include "gt-tree.h"