+++ /dev/null
-/* Language-independent node constructors for parse phase of GNU compiler.
- Copyright (C) 1987-2021 Free Software Foundation, Inc.
-
-This file is part of GCC.
-
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
-
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-for more details.
-
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3. If not see
-<http://www.gnu.org/licenses/>. */
-
-/* This file contains the low level primitives for operating on tree nodes,
- including allocation, list operations, interning of identifiers,
- construction of data type nodes and statement nodes,
- and construction of type conversion nodes. It also contains
- tables index by tree code that describe how to take apart
- nodes of that code.
-
- It is intended to be language-independent but can occasionally
- calls language-dependent routines. */
-
-#include "config.h"
-#include "system.h"
-#include "coretypes.h"
-#include "backend.h"
-#include "target.h"
-#include "tree.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 "common/common-target.h"
-#include "langhooks.h"
-#include "tree-inline.h"
-#include "tree-iterator.h"
-#include "internal-fn.h"
-#include "gimple-iterator.h"
-#include "gimplify.h"
-#include "tree-dfa.h"
-#include "langhooks-def.h"
-#include "tree-diagnostic.h"
-#include "except.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"
-#include "tree-vector-builder.h"
-#include "gimple-fold.h"
-#include "escaped_string.h"
-#include "gimple-range.h"
-
-/* Tree code classes. */
-
-#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
-#define END_OF_BASE_TREE_CODES tcc_exceptional,
-
-const enum tree_code_class tree_code_type[] = {
-#include "all-tree.def"
-};
-
-#undef DEFTREECODE
-#undef END_OF_BASE_TREE_CODES
-
-/* Table indexed by tree code giving number of expression
- operands beyond the fixed part of the node structure.
- Not used for types or decls. */
-
-#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
-#define END_OF_BASE_TREE_CODES 0,
-
-const unsigned char tree_code_length[] = {
-#include "all-tree.def"
-};
-
-#undef DEFTREECODE
-#undef END_OF_BASE_TREE_CODES
-
-/* Names of tree components.
- Used for printing out the tree and error messages. */
-#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
-#define END_OF_BASE_TREE_CODES "@dummy",
-
-static const char *const tree_code_name[] = {
-#include "all-tree.def"
-};
-
-#undef DEFTREECODE
-#undef END_OF_BASE_TREE_CODES
-
-/* Each tree code class has an associated string representation.
- These must correspond to the tree_code_class entries. */
-
-const char *const tree_code_class_strings[] =
-{
- "exceptional",
- "constant",
- "type",
- "declaration",
- "reference",
- "comparison",
- "unary",
- "binary",
- "statement",
- "vl_exp",
- "expression"
-};
-
-/* obstack.[ch] explicitly declined to prototype this. */
-extern int _obstack_allocated_p (struct obstack *h, void *obj);
-
-/* Statistics-gathering stuff. */
-
-static uint64_t tree_code_counts[MAX_TREE_CODES];
-uint64_t tree_node_counts[(int) all_kinds];
-uint64_t tree_node_sizes[(int) all_kinds];
-
-/* Keep in sync with tree.h:enum tree_node_kind. */
-static const char * const tree_node_kind_names[] = {
- "decls",
- "types",
- "blocks",
- "stmts",
- "refs",
- "exprs",
- "constants",
- "identifiers",
- "vecs",
- "binfos",
- "ssa names",
- "constructors",
- "random kinds",
- "lang_decl kinds",
- "lang_type kinds",
- "omp clauses",
-};
-
-/* Unique id for next decl created. */
-static GTY(()) int next_decl_uid;
-/* Unique id for next type created. */
-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;
-
-/* Since we cannot rehash a type after it is in the table, we have to
- keep the hash code. */
-
-struct GTY((for_user)) type_hash {
- unsigned long hash;
- tree type;
-};
-
-/* 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
- array index range types, for now). While all these live in the
- same table, they are completely independent, and the hash code is
- computed differently for each of these. */
-
-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;
-
-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;
-
-/* Class and variable for making sure that there is a single POLY_INT_CST
- for a given value. */
-struct poly_int_cst_hasher : ggc_cache_ptr_hash<tree_node>
-{
- typedef std::pair<tree, const poly_wide_int *> compare_type;
- static hashval_t hash (tree t);
- static bool equal (tree x, const compare_type &y);
-};
-
-static GTY ((cache)) hash_table<poly_int_cst_hasher> *poly_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
- optimization and target option nodes. The assumption is most of the time
- the options created will already be in the hash table, so we avoid
- allocating and freeing up a node repeatably. */
-static GTY (()) tree cl_optimization_node;
-static GTY (()) tree cl_target_option_node;
-
-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 ((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 void print_type_hash_statistics (void);
-static void print_debug_expr_statistics (void);
-static void print_value_expr_statistics (void);
-
-tree global_trees[TI_MAX];
-tree integer_types[itk_none];
-
-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[] =
-{
- 0, /* OMP_CLAUSE_ERROR */
- 1, /* OMP_CLAUSE_PRIVATE */
- 1, /* OMP_CLAUSE_SHARED */
- 1, /* OMP_CLAUSE_FIRSTPRIVATE */
- 2, /* OMP_CLAUSE_LASTPRIVATE */
- 5, /* OMP_CLAUSE_REDUCTION */
- 5, /* OMP_CLAUSE_TASK_REDUCTION */
- 5, /* OMP_CLAUSE_IN_REDUCTION */
- 1, /* OMP_CLAUSE_COPYIN */
- 1, /* OMP_CLAUSE_COPYPRIVATE */
- 3, /* OMP_CLAUSE_LINEAR */
- 1, /* OMP_CLAUSE_AFFINITY */
- 2, /* OMP_CLAUSE_ALIGNED */
- 2, /* OMP_CLAUSE_ALLOCATE */
- 1, /* OMP_CLAUSE_DEPEND */
- 1, /* OMP_CLAUSE_NONTEMPORAL */
- 1, /* OMP_CLAUSE_UNIFORM */
- 1, /* OMP_CLAUSE_TO_DECLARE */
- 1, /* OMP_CLAUSE_LINK */
- 1, /* OMP_CLAUSE_DETACH */
- 1, /* OMP_CLAUSE_USE_DEVICE_PTR */
- 1, /* OMP_CLAUSE_USE_DEVICE_ADDR */
- 1, /* OMP_CLAUSE_IS_DEVICE_PTR */
- 1, /* OMP_CLAUSE_INCLUSIVE */
- 1, /* OMP_CLAUSE_EXCLUSIVE */
- 2, /* OMP_CLAUSE_FROM */
- 2, /* OMP_CLAUSE_TO */
- 2, /* OMP_CLAUSE_MAP */
- 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__REDUCTEMP_ */
- 1, /* OMP_CLAUSE__CONDTEMP_ */
- 1, /* OMP_CLAUSE__SCANTEMP_ */
- 1, /* OMP_CLAUSE_IF */
- 1, /* OMP_CLAUSE_NUM_THREADS */
- 1, /* OMP_CLAUSE_SCHEDULE */
- 0, /* OMP_CLAUSE_NOWAIT */
- 1, /* OMP_CLAUSE_ORDERED */
- 0, /* OMP_CLAUSE_DEFAULT */
- 3, /* OMP_CLAUSE_COLLAPSE */
- 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_DEVICE_TYPE */
- 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_DEFAULTMAP */
- 0, /* OMP_CLAUSE_ORDER */
- 0, /* OMP_CLAUSE_BIND */
- 1, /* OMP_CLAUSE_FILTER */
- 1, /* OMP_CLAUSE__SIMDUID_ */
- 0, /* OMP_CLAUSE__SIMT_ */
- 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 */
- 0, /* OMP_CLAUSE_IF_PRESENT */
- 0, /* OMP_CLAUSE_FINALIZE */
- 0, /* OMP_CLAUSE_NOHOST */
-};
-
-const char * const omp_clause_code_name[] =
-{
- "error_clause",
- "private",
- "shared",
- "firstprivate",
- "lastprivate",
- "reduction",
- "task_reduction",
- "in_reduction",
- "copyin",
- "copyprivate",
- "linear",
- "affinity",
- "aligned",
- "allocate",
- "depend",
- "nontemporal",
- "uniform",
- "to",
- "link",
- "detach",
- "use_device_ptr",
- "use_device_addr",
- "is_device_ptr",
- "inclusive",
- "exclusive",
- "from",
- "to",
- "map",
- "_cache_",
- "gang",
- "async",
- "wait",
- "auto",
- "seq",
- "_looptemp_",
- "_reductemp_",
- "_condtemp_",
- "_scantemp_",
- "if",
- "num_threads",
- "schedule",
- "nowait",
- "ordered",
- "default",
- "collapse",
- "untied",
- "final",
- "mergeable",
- "device",
- "dist_schedule",
- "inbranch",
- "notinbranch",
- "num_teams",
- "thread_limit",
- "proc_bind",
- "safelen",
- "simdlen",
- "device_type",
- "for",
- "parallel",
- "sections",
- "taskgroup",
- "priority",
- "grainsize",
- "num_tasks",
- "nogroup",
- "threads",
- "simd",
- "hint",
- "defaultmap",
- "order",
- "bind",
- "filter",
- "_simduid_",
- "_simt_",
- "independent",
- "worker",
- "vector",
- "num_gangs",
- "num_workers",
- "vector_length",
- "tile",
- "if_present",
- "finalize",
- "nohost",
-};
-
-
-/* Return the tree node structure used by tree code CODE. */
-
-static inline enum tree_node_structure_enum
-tree_node_structure_for_code (enum tree_code code)
-{
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_declaration:
- switch (code)
- {
- case CONST_DECL: return TS_CONST_DECL;
- case DEBUG_EXPR_DECL: return TS_DECL_WRTL;
- case FIELD_DECL: return TS_FIELD_DECL;
- case FUNCTION_DECL: return TS_FUNCTION_DECL;
- case LABEL_DECL: return TS_LABEL_DECL;
- case PARM_DECL: return TS_PARM_DECL;
- case RESULT_DECL: return TS_RESULT_DECL;
- case TRANSLATION_UNIT_DECL: return TS_TRANSLATION_UNIT_DECL;
- case TYPE_DECL: return TS_TYPE_DECL;
- case VAR_DECL: return TS_VAR_DECL;
- default: return TS_DECL_NON_COMMON;
- }
-
- case tcc_type: return TS_TYPE_NON_COMMON;
-
- case tcc_binary:
- case tcc_comparison:
- case tcc_expression:
- case tcc_reference:
- case tcc_statement:
- case tcc_unary:
- case tcc_vl_exp: return TS_EXP;
-
- default: /* tcc_constant and tcc_exceptional */
- break;
- }
-
- switch (code)
- {
- /* tcc_constant cases. */
- case COMPLEX_CST: return TS_COMPLEX;
- case FIXED_CST: return TS_FIXED_CST;
- case INTEGER_CST: return TS_INT_CST;
- case POLY_INT_CST: return TS_POLY_INT_CST;
- case REAL_CST: return TS_REAL_CST;
- case STRING_CST: return TS_STRING;
- case VECTOR_CST: return TS_VECTOR;
- case VOID_CST: return TS_TYPED;
-
- /* tcc_exceptional cases. */
- case BLOCK: return TS_BLOCK;
- case CONSTRUCTOR: return TS_CONSTRUCTOR;
- case ERROR_MARK: return TS_COMMON;
- case IDENTIFIER_NODE: return TS_IDENTIFIER;
- case OMP_CLAUSE: return TS_OMP_CLAUSE;
- case OPTIMIZATION_NODE: return TS_OPTIMIZATION;
- case PLACEHOLDER_EXPR: return TS_COMMON;
- case SSA_NAME: return TS_SSA_NAME;
- case STATEMENT_LIST: return TS_STATEMENT_LIST;
- case TARGET_OPTION_NODE: return TS_TARGET_OPTION;
- case TREE_BINFO: return TS_BINFO;
- case TREE_LIST: return TS_LIST;
- case TREE_VEC: return TS_VEC;
-
- default:
- gcc_unreachable ();
- }
-}
-
-
-/* Initialize tree_contains_struct to describe the hierarchy of tree
- nodes. */
-
-static void
-initialize_tree_contains_struct (void)
-{
- unsigned i;
-
- for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
- {
- enum tree_code code;
- enum tree_node_structure_enum ts_code;
-
- code = (enum tree_code) i;
- ts_code = tree_node_structure_for_code (code);
-
- /* Mark the TS structure itself. */
- tree_contains_struct[code][ts_code] = 1;
-
- /* Mark all the structures that TS is derived from. */
- switch (ts_code)
- {
- 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_POLY_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_COMMON:
- case TS_LIST:
- case TS_VEC:
- case TS_BINFO:
- case TS_OMP_CLAUSE:
- 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;
-
- case TS_DECL_NON_COMMON:
- MARK_TS_DECL_WITH_VIS (code);
- break;
-
- case TS_DECL_WITH_VIS:
- case TS_PARM_DECL:
- case TS_LABEL_DECL:
- case TS_RESULT_DECL:
- MARK_TS_DECL_WRTL (code);
- break;
-
- case TS_FIELD_DECL:
- MARK_TS_DECL_COMMON (code);
- break;
-
- case TS_VAR_DECL:
- MARK_TS_DECL_WITH_VIS (code);
- break;
-
- case TS_TYPE_DECL:
- case TS_FUNCTION_DECL:
- MARK_TS_DECL_NON_COMMON (code);
- break;
-
- case TS_TRANSLATION_UNIT_DECL:
- MARK_TS_DECL_COMMON (code);
- break;
-
- default:
- gcc_unreachable ();
- }
- }
-
- /* Basic consistency checks for attributes used in fold. */
- gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
- gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
- gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
- gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
- gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
- gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
- gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
- gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
- 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[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]);
- gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
- gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
- gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
- gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
- gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
- gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
- gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
- gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
- gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
- gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
- gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
- gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
- 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]);
- gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_MINIMAL]);
- gcc_assert (tree_contains_struct[NAMELIST_DECL][TS_DECL_COMMON]);
-}
-
-
-/* Init tree.c. */
-
-void
-init_ttree (void)
-{
- /* Initialize the hash table of types. */
- 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);
-
- poly_int_cst_hash_table = hash_table<poly_int_cst_hasher>::create_ggc (64);
-
- 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);
-
- /* Initialize the tree_contains_struct array. */
- initialize_tree_contains_struct ();
- lang_hooks.init_ts ();
-}
-
-\f
-/* The name of the object as the assembler will see it (but before any
- translations made by ASM_OUTPUT_LABELREF). Often this is the same
- as DECL_NAME. It is an IDENTIFIER_NODE. */
-tree
-decl_assembler_name (tree decl)
-{
- if (!DECL_ASSEMBLER_NAME_SET_P (decl))
- lang_hooks.set_decl_assembler_name (decl);
- return DECL_ASSEMBLER_NAME_RAW (decl);
-}
-
-/* The DECL_ASSEMBLER_NAME_RAW of DECL is being explicitly set to NAME
- (either of which may be NULL). Inform the FE, if this changes the
- name. */
-
-void
-overwrite_decl_assembler_name (tree decl, tree name)
-{
- if (DECL_ASSEMBLER_NAME_RAW (decl) != name)
- lang_hooks.overwrite_decl_assembler_name (decl, name);
-}
-
-/* Return true if DECL may need an assembler name to be set. */
-
-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 (TREE_CODE (decl) == TYPE_DECL)
- {
- if (DECL_NAME (decl)
- && decl == TYPE_NAME (TREE_TYPE (decl))
- && TYPE_MAIN_VARIANT (TREE_TYPE (decl)) == TREE_TYPE (decl)
- && !TYPE_ARTIFICIAL (TREE_TYPE (decl))
- && ((TREE_CODE (TREE_TYPE (decl)) != RECORD_TYPE
- && TREE_CODE (TREE_TYPE (decl)) != UNION_TYPE)
- || TYPE_CXX_ODR_P (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);
- return false;
- }
- /* Only FUNCTION_DECLs and VAR_DECLs are considered. */
- if (!VAR_OR_FUNCTION_DECL_P (decl))
- return false;
-
- /* If DECL already has its assembler name set, it does not need a
- new one. */
- if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
- || DECL_ASSEMBLER_NAME_SET_P (decl))
- return false;
-
- /* Abstract decls do not need an assembler name. */
- if (DECL_ABSTRACT_P (decl))
- return false;
-
- /* For VAR_DECLs, only static, public and external symbols need an
- assembler name. */
- if (VAR_P (decl)
- && !TREE_STATIC (decl)
- && !TREE_PUBLIC (decl)
- && !DECL_EXTERNAL (decl))
- return false;
-
- if (TREE_CODE (decl) == FUNCTION_DECL)
- {
- /* Do not set assembler name on builtins. Allow RTL expansion to
- decide whether to expand inline or via a regular call. */
- if (fndecl_built_in_p (decl)
- && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
- return false;
-
- /* Functions represented in the callgraph need an assembler name. */
- if (cgraph_node::get (decl) != NULL)
- return true;
-
- /* Unused and not public functions don't need an assembler name. */
- if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
- return false;
- }
-
- return true;
-}
-
-/* If T needs an assembler name, have one created for it. */
-
-void
-assign_assembler_name_if_needed (tree t)
-{
- if (need_assembler_name_p (t))
- {
- /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
- diagnostics that use input_location to show locus
- information. The problem here is that, at this point,
- input_location is generally anchored to the end of the file
- (since the parser is long gone), so we don't have a good
- position to pin it to.
-
- To alleviate this problem, this uses the location of T's
- declaration. Examples of this are
- testsuite/g++.dg/template/cond2.C and
- testsuite/g++.dg/template/pr35240.C. */
- location_t saved_location = input_location;
- input_location = DECL_SOURCE_LOCATION (t);
-
- decl_assembler_name (t);
-
- input_location = saved_location;
- }
-}
-
-/* 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);
-}
-
-/* Set section name of NODE to match the section name of OTHER.
-
- set_decl_section_name (decl, other) is equivalent to
- set_decl_section_name (decl, DECL_SECTION_NAME (other)), but possibly more
- efficient. */
-void
-set_decl_section_name (tree decl, const_tree other)
-{
- struct symtab_node *other_node = symtab_node::get (other);
- if (other_node)
- {
- struct symtab_node *decl_node;
- if (VAR_P (decl))
- decl_node = varpool_node::get_create (decl);
- else
- decl_node = cgraph_node::get_create (decl);
- decl_node->set_section (*other_node);
- }
- else
- {
- struct symtab_node *decl_node = symtab_node::get (decl);
- if (!decl_node)
- return;
- decl_node->set_section (NULL);
- }
-}
-
-/* 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, 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 (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 */
- switch (code)
- {
- case OFFSET_TYPE:
- case ENUMERAL_TYPE:
- case BOOLEAN_TYPE:
- case INTEGER_TYPE:
- case REAL_TYPE:
- case OPAQUE_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 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 */
- case tcc_statement: /* an expression with side effects */
- case tcc_comparison: /* a comparison expression */
- case tcc_unary: /* a unary arithmetic expression */
- case tcc_binary: /* a binary arithmetic expression */
- return (sizeof (struct tree_exp)
- + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
-
- case tcc_constant: /* a constant */
- switch (code)
- {
- case VOID_CST: return sizeof (tree_typed);
- case INTEGER_CST: gcc_unreachable ();
- case POLY_INT_CST: return sizeof (tree_poly_int_cst);
- 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: gcc_unreachable ();
- case STRING_CST: gcc_unreachable ();
- default:
- gcc_checking_assert (code >= NUM_TREE_CODES);
- return lang_hooks.tree_size (code);
- }
-
- case tcc_exceptional: /* something random, like an identifier. */
- switch (code)
- {
- case IDENTIFIER_NODE: return lang_hooks.identifier_size;
- case TREE_LIST: return sizeof (tree_list);
-
- case ERROR_MARK:
- case PLACEHOLDER_EXPR: return sizeof (tree_common);
-
- case TREE_VEC: gcc_unreachable ();
- case OMP_CLAUSE: gcc_unreachable ();
-
- 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 (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);
- }
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* Compute the number of bytes occupied by NODE. This routine only
- looks at TREE_CODE, except for those nodes that have variable sizes. */
-size_t
-tree_size (const_tree node)
-{
- 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<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_encoded_nelts (node) - 1) * sizeof (tree));
-
- case STRING_CST:
- return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
-
- case OMP_CLAUSE:
- return (sizeof (struct tree_omp_clause)
- + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
- * sizeof (tree));
-
- default:
- if (TREE_CODE_CLASS (code) == tcc_vl_exp)
- return (sizeof (struct tree_exp)
- + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
- else
- return tree_code_size (code);
- }
-}
-
-/* Return tree node kind based on tree CODE. */
-
-static tree_node_kind
-get_stats_node_kind (enum tree_code code)
-{
- enum tree_code_class type = TREE_CODE_CLASS (code);
-
- switch (type)
- {
- case tcc_declaration: /* A decl node */
- return d_kind;
- case tcc_type: /* a type node */
- return t_kind;
- case tcc_statement: /* an expression with side effects */
- return s_kind;
- case tcc_reference: /* a reference */
- return r_kind;
- case tcc_expression: /* an expression */
- case tcc_comparison: /* a comparison expression */
- case tcc_unary: /* a unary arithmetic expression */
- case tcc_binary: /* a binary arithmetic expression */
- return e_kind;
- case tcc_constant: /* a constant */
- return c_kind;
- case tcc_exceptional: /* something random, like an identifier. */
- switch (code)
- {
- case IDENTIFIER_NODE:
- return id_kind;
- case TREE_VEC:
- return vec_kind;
- case TREE_BINFO:
- return binfo_kind;
- case SSA_NAME:
- return ssa_name_kind;
- case BLOCK:
- return b_kind;
- case CONSTRUCTOR:
- return constr_kind;
- case OMP_CLAUSE:
- return omp_clause_kind;
- default:
- return x_kind;
- }
- break;
- case tcc_vl_exp:
- return e_kind;
- default:
- gcc_unreachable ();
- }
-}
-
-/* Record interesting allocation statistics for a tree node with CODE
- and LENGTH. */
-
-static void
-record_node_allocation_statistics (enum tree_code code, size_t length)
-{
- if (!GATHER_STATISTICS)
- return;
-
- tree_node_kind kind = get_stats_node_kind (code);
-
- tree_code_counts[(int) code]++;
- tree_node_counts[(int) kind]++;
- tree_node_sizes[(int) kind] += length;
-}
-
-/* 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)
- {
- case tcc_statement:
- if (code != DEBUG_BEGIN_STMT)
- TREE_SIDE_EFFECTS (t) = 1;
- break;
-
- case tcc_declaration:
- if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
- {
- if (code == FUNCTION_DECL)
- {
- SET_DECL_ALIGN (t, FUNCTION_ALIGNMENT (FUNCTION_BOUNDARY));
- SET_DECL_MODE (t, FUNCTION_MODE);
- }
- else
- 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) = allocate_decl_uid ();
- SET_DECL_PT_UID (t, -1);
- }
- if (TREE_CODE (t) == LABEL_DECL)
- LABEL_DECL_UID (t) = -1;
-
- break;
-
- case tcc_type:
- TYPE_UID (t) = next_type_uid++;
- SET_TYPE_ALIGN (t, BITS_PER_UNIT);
- TYPE_USER_ALIGN (t) = 0;
- TYPE_MAIN_VARIANT (t) = t;
- TYPE_CANONICAL (t) = t;
-
- /* Default to no attributes for type, but let target change that. */
- TYPE_ATTRIBUTES (t) = NULL_TREE;
- targetm.set_default_type_attributes (t);
-
- /* We have not yet computed the alias set for this type. */
- TYPE_ALIAS_SET (t) = -1;
- break;
-
- case tcc_constant:
- TREE_CONSTANT (t) = 1;
- break;
-
- case tcc_expression:
- switch (code)
- {
- case INIT_EXPR:
- case MODIFY_EXPR:
- case VA_ARG_EXPR:
- case PREDECREMENT_EXPR:
- case PREINCREMENT_EXPR:
- case POSTDECREMENT_EXPR:
- case POSTINCREMENT_EXPR:
- /* All of these have side-effects, no matter what their
- operands are. */
- TREE_SIDE_EFFECTS (t) = 1;
- break;
-
- default:
- break;
- }
- 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;
- }
-
- return t;
-}
-
-/* Free tree node. */
-
-void
-free_node (tree node)
-{
- enum tree_code code = TREE_CODE (node);
- if (GATHER_STATISTICS)
- {
- enum tree_node_kind kind = get_stats_node_kind (code);
-
- gcc_checking_assert (tree_code_counts[(int) TREE_CODE (node)] != 0);
- gcc_checking_assert (tree_node_counts[(int) kind] != 0);
- gcc_checking_assert (tree_node_sizes[(int) kind] >= tree_size (node));
-
- tree_code_counts[(int) TREE_CODE (node)]--;
- tree_node_counts[(int) kind]--;
- tree_node_sizes[(int) 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));
- else if (code == OPTIMIZATION_NODE)
- cl_optimization_option_free (TREE_OPTIMIZATION (node));
- else if (code == TARGET_OPTION_NODE)
- cl_target_option_free (TREE_TARGET_OPTION (node));
- ggc_free (node);
-}
-\f
-/* Return a new node with the same contents as NODE except that its
- 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);
- size_t length;
-
- gcc_assert (code != STATEMENT_LIST);
-
- length = tree_size (node);
- record_node_allocation_statistics (code, length);
- t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
- memcpy (t, node, length);
-
- if (CODE_CONTAINS_STRUCT (code, TS_COMMON))
- TREE_CHAIN (t) = 0;
- TREE_ASM_WRITTEN (t) = 0;
- TREE_VISITED (t) = 0;
-
- if (TREE_CODE_CLASS (code) == tcc_declaration)
- {
- if (code == DEBUG_EXPR_DECL)
- DECL_UID (t) = --next_debug_decl_uid;
- else
- {
- 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 || 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;
- }
- /* DECL_DEBUG_EXPR is copied explicitly 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)
- {
- TYPE_UID (t) = next_type_uid++;
- /* The following is so that the debug code for
- the copy is different from the original type.
- The two statements usually duplicate each other
- (because they clear fields of the same union),
- but the optimizer should catch that. */
- TYPE_SYMTAB_ADDRESS (t) = 0;
- TYPE_SYMTAB_DIE (t) = 0;
-
- /* Do not copy the values cache. */
- 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;
-}
-
-/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
- For example, this can copy a list made of TREE_LIST nodes. */
-
-tree
-copy_list (tree list)
-{
- tree head;
- tree prev, next;
-
- if (list == 0)
- return 0;
-
- head = prev = copy_node (list);
- next = TREE_CHAIN (list);
- while (next)
- {
- TREE_CHAIN (prev) = copy_node (next);
- prev = TREE_CHAIN (prev);
- next = TREE_CHAIN (next);
- }
- return head;
-}
-
-\f
-/* 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;
-}
-
-/* Return a new POLY_INT_CST with coefficients COEFFS and type TYPE. */
-
-static tree
-build_new_poly_int_cst (tree type, tree (&coeffs)[NUM_POLY_INT_COEFFS]
- CXX_MEM_STAT_INFO)
-{
- size_t length = sizeof (struct tree_poly_int_cst);
- record_node_allocation_statistics (POLY_INT_CST, length);
-
- tree t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
-
- TREE_SET_CODE (t, POLY_INT_CST);
- TREE_CONSTANT (t) = 1;
- TREE_TYPE (t) = type;
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- POLY_INT_CST_COEFF (t, i) = coeffs[i];
- return t;
-}
-
-/* Create a constant tree that contains CST sign-extended to TYPE. */
-
-tree
-build_int_cst (tree type, poly_int64 cst)
-{
- /* Support legacy code. */
- if (!type)
- type = integer_type_node;
-
- return wide_int_to_tree (type, wi::shwi (cst, TYPE_PRECISION (type)));
-}
-
-/* Create a constant tree that contains CST zero-extended to TYPE. */
-
-tree
-build_int_cstu (tree type, poly_uint64 cst)
-{
- return wide_int_to_tree (type, wi::uhwi (cst, TYPE_PRECISION (type)));
-}
-
-/* Create a constant tree that contains CST sign-extended to TYPE. */
-
-tree
-build_int_cst_type (tree type, poly_int64 cst)
-{
- gcc_assert (type);
- return wide_int_to_tree (type, wi::shwi (cst, TYPE_PRECISION (type)));
-}
-
-/* Constructs tree in type TYPE from with value given by CST. Signedness
- of CST is assumed to be the same as the signedness of TYPE. */
-
-tree
-double_int_to_tree (tree type, double_int cst)
-{
- 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
- indicates whether overflow has already occurred. CONST_OVERFLOWED
- indicates whether constant overflow has already occurred. We force
- T's value to be within range of T's type (by setting to 0 or 1 all
- the bits outside the type's range). We set TREE_OVERFLOWED if,
- 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 wide_int. The node
- is shared if no overflow flags are set. */
-
-
-tree
-force_fit_type (tree type, const poly_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 || !wi::fits_to_tree_p (cst, type))
- {
- if (overflowed
- || overflowable < 0
- || (overflowable > 0 && sign == SIGNED))
- {
- poly_wide_int tmp = poly_wide_int::from (cst, TYPE_PRECISION (type),
- sign);
- tree t;
- if (tmp.is_constant ())
- t = build_new_int_cst (type, tmp.coeffs[0]);
- else
- {
- tree coeffs[NUM_POLY_INT_COEFFS];
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- {
- coeffs[i] = build_new_int_cst (type, tmp.coeffs[i]);
- TREE_OVERFLOW (coeffs[i]) = 1;
- }
- t = build_new_poly_int_cst (type, coeffs);
- }
- TREE_OVERFLOW (t) = 1;
- return t;
- }
- }
-
- /* Else build a shared node. */
- 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 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. */
-
-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;
-}
-
-/* Cache wide_int CST into the TYPE_CACHED_VALUES cache for TYPE.
- SLOT is the slot entry to store it in, and MAX_SLOTS is the maximum
- number of slots that can be cached for the type. */
-
-static inline tree
-cache_wide_int_in_type_cache (tree type, const wide_int &cst,
- int slot, int max_slots)
-{
- gcc_checking_assert (slot >= 0);
- /* Initialize cache. */
- if (!TYPE_CACHED_VALUES_P (type))
- {
- TYPE_CACHED_VALUES_P (type) = 1;
- TYPE_CACHED_VALUES (type) = make_tree_vec (max_slots);
- }
- tree t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), slot);
- if (!t)
- {
- /* Create a new shared int. */
- t = build_new_int_cst (type, cst);
- TREE_VEC_ELT (TYPE_CACHED_VALUES (type), slot) = t;
- }
- return t;
-}
-
-/* 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.
- 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. */
-
-static tree
-wide_int_to_tree_1 (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);
-
- enum tree_code code = TREE_CODE (type);
- if (code == POINTER_TYPE || code == REFERENCE_TYPE)
- {
- /* Cache NULL pointer and zero bounds. */
- if (cst == 0)
- ix = 0;
- /* Cache upper bounds of pointers. */
- else if (cst == wi::max_value (prec, sgn))
- ix = 1;
- /* Cache 1 which is used for a non-zero range. */
- else if (cst == 1)
- ix = 2;
-
- if (ix >= 0)
- {
- t = cache_wide_int_in_type_cache (type, cst, ix, 3);
- /* Make sure no one is clobbering the shared constant. */
- gcc_checking_assert (TREE_TYPE (t) == type
- && cst == wi::to_wide (t));
- return t;
- }
- }
- 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 (code)
- {
- case NULLPTR_TYPE:
- gcc_assert (hwi == 0);
- /* Fallthru. */
-
- case POINTER_TYPE:
- case REFERENCE_TYPE:
- /* Ignore pointers, as they were already handled above. */
- 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 = param_integer_share_limit;
- if (IN_RANGE (hwi, 0, param_integer_share_limit - 1))
- ix = hwi;
- }
- else
- {
- /* Cache [-1, N). */
- limit = param_integer_share_limit + 1;
- if (IN_RANGE (hwi, -1, param_integer_share_limit - 1))
- ix = hwi + 1;
- }
- break;
-
- case ENUMERAL_TYPE:
- break;
-
- default:
- gcc_unreachable ();
- }
-
- if (ix >= 0)
- {
- t = cache_wide_int_in_type_cache (type, cst, ix, limit);
- /* 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);
- return 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;
- }
- else
- ggc_free (nt);
- }
-
- return t;
-}
-
-hashval_t
-poly_int_cst_hasher::hash (tree t)
-{
- inchash::hash hstate;
-
- hstate.add_int (TYPE_UID (TREE_TYPE (t)));
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- hstate.add_wide_int (wi::to_wide (POLY_INT_CST_COEFF (t, i)));
-
- return hstate.end ();
-}
-
-bool
-poly_int_cst_hasher::equal (tree x, const compare_type &y)
-{
- if (TREE_TYPE (x) != y.first)
- return false;
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- if (wi::to_wide (POLY_INT_CST_COEFF (x, i)) != y.second->coeffs[i])
- return false;
- return true;
-}
-
-/* Build a POLY_INT_CST node with type TYPE and with the elements in VALUES.
- The elements must also have type TYPE. */
-
-tree
-build_poly_int_cst (tree type, const poly_wide_int_ref &values)
-{
- unsigned int prec = TYPE_PRECISION (type);
- gcc_assert (prec <= values.coeffs[0].get_precision ());
- poly_wide_int c = poly_wide_int::from (values, prec, SIGNED);
-
- inchash::hash h;
- h.add_int (TYPE_UID (type));
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- h.add_wide_int (c.coeffs[i]);
- poly_int_cst_hasher::compare_type comp (type, &c);
- tree *slot = poly_int_cst_hash_table->find_slot_with_hash (comp, h.end (),
- INSERT);
- if (*slot == NULL_TREE)
- {
- tree coeffs[NUM_POLY_INT_COEFFS];
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- coeffs[i] = wide_int_to_tree_1 (type, c.coeffs[i]);
- *slot = build_new_poly_int_cst (type, coeffs);
- }
- return *slot;
-}
-
-/* Create a constant tree with value VALUE in type TYPE. */
-
-tree
-wide_int_to_tree (tree type, const poly_wide_int_ref &value)
-{
- if (value.is_constant ())
- return wide_int_to_tree_1 (type, value.coeffs[0]);
- return build_poly_int_cst (type, value);
-}
-
-/* Insert INTEGER_CST T into a cache of integer constants. And return
- the cached constant (which may or may not be T). If MIGHT_DUPLICATE
- is false, and T falls into the type's 'smaller values' range, there
- cannot be an existing entry. Otherwise, if MIGHT_DUPLICATE is true,
- or the value is large, should an existing entry exist, it is
- returned (rather than inserting T). */
-
-tree
-cache_integer_cst (tree t, bool might_duplicate ATTRIBUTE_UNUSED)
-{
- tree type = TREE_TYPE (t);
- int ix = -1;
- int limit = 0;
- int prec = TYPE_PRECISION (type);
-
- gcc_assert (!TREE_OVERFLOW (t));
-
- /* The caching indices here must match those in
- wide_int_to_type_1. */
- switch (TREE_CODE (type))
- {
- case NULLPTR_TYPE:
- gcc_checking_assert (integer_zerop (t));
- /* Fallthru. */
-
- case POINTER_TYPE:
- case REFERENCE_TYPE:
- {
- if (integer_zerop (t))
- ix = 0;
- else if (integer_onep (t))
- ix = 2;
-
- if (ix >= 0)
- limit = 3;
- }
- break;
-
- case BOOLEAN_TYPE:
- /* Cache false or true. */
- limit = 2;
- if (wi::ltu_p (wi::to_wide (t), 2))
- ix = TREE_INT_CST_ELT (t, 0);
- break;
-
- case INTEGER_TYPE:
- case OFFSET_TYPE:
- if (TYPE_UNSIGNED (type))
- {
- /* Cache 0..N */
- limit = param_integer_share_limit;
-
- /* This is a little hokie, but if the prec is smaller than
- what is necessary to hold param_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) param_integer_share_limit)
- ix = tree_to_uhwi (t);
- }
- else if (wi::ltu_p (wi::to_wide (t), param_integer_share_limit))
- ix = tree_to_uhwi (t);
- }
- else
- {
- /* Cache -1..N */
- limit = param_integer_share_limit + 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) < param_integer_share_limit)
- ix = tree_to_shwi (t) + 1;
- }
- else if (wi::ltu_p (wi::to_wide (t), param_integer_share_limit))
- ix = tree_to_shwi (t) + 1;
- }
- }
- break;
-
- case ENUMERAL_TYPE:
- /* The slot used by TYPE_CACHED_VALUES is used for the enum
- members. */
- 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);
- }
-
- if (tree r = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix))
- {
- gcc_checking_assert (might_duplicate);
- t = r;
- }
- else
- TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
- }
- else
- {
- /* Use the cache of larger shared ints. */
- tree *slot = int_cst_hash_table->find_slot (t, INSERT);
- if (tree r = *slot)
- {
- /* If there is already an entry for the number verify it's the
- same value. */
- gcc_checking_assert (wi::to_wide (tree (r)) == wi::to_wide (t));
- /* And return the cached value. */
- t = r;
- }
- else
- /* Otherwise insert this one into the hash table. */
- *slot = t;
- }
-
- return t;
-}
-
-
-/* Builds an integer constant in TYPE such that lowest BITS bits are ones
- and the rest are zeros. */
-
-tree
-build_low_bits_mask (tree type, unsigned bits)
-{
- gcc_assert (bits <= TYPE_PRECISION (type));
-
- 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)
- HOST_WIDE_INT without loss of precision. */
-
-bool
-cst_and_fits_in_hwi (const_tree x)
-{
- return (TREE_CODE (x) == INTEGER_CST
- && (tree_fits_shwi_p (x) || tree_fits_uhwi_p (x)));
-}
-
-/* Build a newly constructed VECTOR_CST with the given values of
- (VECTOR_CST_)LOG2_NPATTERNS and (VECTOR_CST_)NELTS_PER_PATTERN. */
-
-tree
-make_vector (unsigned log2_npatterns,
- unsigned int nelts_per_pattern MEM_STAT_DECL)
-{
- gcc_assert (IN_RANGE (nelts_per_pattern, 1, 3));
- tree t;
- unsigned npatterns = 1 << log2_npatterns;
- unsigned encoded_nelts = npatterns * nelts_per_pattern;
- unsigned length = (sizeof (struct tree_vector)
- + (encoded_nelts - 1) * sizeof (tree));
-
- 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_LOG2_NPATTERNS (t) = log2_npatterns;
- VECTOR_CST_NELTS_PER_PATTERN (t) = nelts_per_pattern;
-
- return t;
-}
-
-/* Return a new VECTOR_CST node whose type is TYPE and whose values
- are extracted from V, a vector of CONSTRUCTOR_ELT. */
-
-tree
-build_vector_from_ctor (tree type, const vec<constructor_elt, va_gc> *v)
-{
- if (vec_safe_length (v) == 0)
- return build_zero_cst (type);
-
- unsigned HOST_WIDE_INT idx, nelts;
- tree value;
-
- /* We can't construct a VECTOR_CST for a variable number of elements. */
- nelts = TYPE_VECTOR_SUBPARTS (type).to_constant ();
- tree_vector_builder vec (type, nelts, 1);
- FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
- {
- if (TREE_CODE (value) == VECTOR_CST)
- {
- /* If NELTS is constant then this must be too. */
- unsigned int sub_nelts = VECTOR_CST_NELTS (value).to_constant ();
- for (unsigned i = 0; i < sub_nelts; ++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 vec.build ();
-}
-
-/* Build a vector of type VECTYPE where all the elements are SCs. */
-tree
-build_vector_from_val (tree vectype, tree sc)
-{
- unsigned HOST_WIDE_INT i, nunits;
-
- if (sc == error_mark_node)
- return sc;
-
- /* Verify that the vector type is suitable for SC. Note that there
- is some inconsistency in the type-system with respect to restrict
- qualifications of pointers. Vector types always have a main-variant
- element type and the qualification is applied to the vector-type.
- So TREE_TYPE (vector-type) does not return a properly qualified
- vector element-type. */
- gcc_checking_assert (types_compatible_p (TYPE_MAIN_VARIANT (TREE_TYPE (sc)),
- TREE_TYPE (vectype)));
-
- if (CONSTANT_CLASS_P (sc))
- {
- tree_vector_builder v (vectype, 1, 1);
- v.quick_push (sc);
- return v.build ();
- }
- else if (!TYPE_VECTOR_SUBPARTS (vectype).is_constant (&nunits))
- return fold_build1 (VEC_DUPLICATE_EXPR, vectype, sc);
- 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);
- }
-}
-
-/* If TYPE is not a vector type, just return SC, otherwise return
- build_vector_from_val (TYPE, SC). */
-
-tree
-build_uniform_cst (tree type, tree sc)
-{
- if (!VECTOR_TYPE_P (type))
- return sc;
-
- return build_vector_from_val (type, sc);
-}
-
-/* Build a vector series of type TYPE in which element I has the value
- BASE + I * STEP. The result is a constant if BASE and STEP are constant
- and a VEC_SERIES_EXPR otherwise. */
-
-tree
-build_vec_series (tree type, tree base, tree step)
-{
- if (integer_zerop (step))
- return build_vector_from_val (type, base);
- if (TREE_CODE (base) == INTEGER_CST && TREE_CODE (step) == INTEGER_CST)
- {
- tree_vector_builder builder (type, 1, 3);
- tree elt1 = wide_int_to_tree (TREE_TYPE (base),
- wi::to_wide (base) + wi::to_wide (step));
- tree elt2 = wide_int_to_tree (TREE_TYPE (base),
- wi::to_wide (elt1) + wi::to_wide (step));
- builder.quick_push (base);
- builder.quick_push (elt1);
- builder.quick_push (elt2);
- return builder.build ();
- }
- return build2 (VEC_SERIES_EXPR, type, base, step);
-}
-
-/* Return a vector with the same number of units and number of bits
- as VEC_TYPE, but in which the elements are a linear series of unsigned
- integers { BASE, BASE + STEP, BASE + STEP * 2, ... }. */
-
-tree
-build_index_vector (tree vec_type, poly_uint64 base, poly_uint64 step)
-{
- tree index_vec_type = vec_type;
- tree index_elt_type = TREE_TYPE (vec_type);
- poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vec_type);
- if (!INTEGRAL_TYPE_P (index_elt_type) || !TYPE_UNSIGNED (index_elt_type))
- {
- index_elt_type = build_nonstandard_integer_type
- (GET_MODE_BITSIZE (SCALAR_TYPE_MODE (index_elt_type)), true);
- index_vec_type = build_vector_type (index_elt_type, nunits);
- }
-
- tree_vector_builder v (index_vec_type, 1, 3);
- for (unsigned int i = 0; i < 3; ++i)
- v.quick_push (build_int_cstu (index_elt_type, base + i * step));
- return v.build ();
-}
-
-/* Return a VECTOR_CST of type VEC_TYPE in which the first NUM_A
- elements are A and the rest are B. */
-
-tree
-build_vector_a_then_b (tree vec_type, unsigned int num_a, tree a, tree b)
-{
- gcc_assert (known_le (num_a, TYPE_VECTOR_SUBPARTS (vec_type)));
- unsigned int count = constant_lower_bound (TYPE_VECTOR_SUBPARTS (vec_type));
- /* Optimize the constant case. */
- if ((count & 1) == 0 && TYPE_VECTOR_SUBPARTS (vec_type).is_constant ())
- count /= 2;
- tree_vector_builder builder (vec_type, count, 2);
- for (unsigned int i = 0; i < count * 2; ++i)
- builder.quick_push (i < num_a ? a : b);
- return builder.build ();
-}
-
-/* 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, va_gc> *vals MEM_STAT_DECL)
-{
- tree c = make_node (CONSTRUCTOR PASS_MEM_STAT);
-
- TREE_TYPE (c) = type;
- CONSTRUCTOR_ELTS (c) = vals;
-
- recompute_constructor_flags (c);
-
- return c;
-}
-
-/* Build a CONSTRUCTOR node made of a single initializer, with the specified
- INDEX and VALUE. */
-tree
-build_constructor_single (tree type, tree index, tree 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);
-}
-
-
-/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
- are in a list pointed to by VALS. */
-tree
-build_constructor_from_list (tree type, tree vals)
-{
- tree t;
- vec<constructor_elt, va_gc> *v = NULL;
-
- if (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));
- }
-
- return build_constructor (type, v);
-}
-
-/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
- are in a vector pointed to by VALS. Note that the TREE_PURPOSE
- fields in the constructor remain null. */
-
-tree
-build_constructor_from_vec (tree type, const vec<tree, va_gc> *vals)
-{
- vec<constructor_elt, va_gc> *v = NULL;
-
- for (tree t : vals)
- CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, t);
-
- 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 node of type TYPE for which TREE_CLOBBER_P is true. */
-
-tree
-build_clobber (tree type)
-{
- tree clobber = build_constructor (type, NULL);
- TREE_THIS_VOLATILE (clobber) = true;
- return clobber;
-}
-
-/* Return a new FIXED_CST node whose type is TYPE and value is F. */
-
-tree
-build_fixed (tree type, FIXED_VALUE_TYPE f)
-{
- tree v;
- FIXED_VALUE_TYPE *fp;
-
- v = make_node (FIXED_CST);
- fp = ggc_alloc<fixed_value> ();
- memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
-
- TREE_TYPE (v) = type;
- TREE_FIXED_CST_PTR (v) = fp;
- return v;
-}
-
-/* Return a new REAL_CST node whose type is TYPE and value is D. */
-
-tree
-build_real (tree type, REAL_VALUE_TYPE d)
-{
- tree v;
- REAL_VALUE_TYPE *dp;
- int overflow = 0;
-
- /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
- Consider doing it via real_convert now. */
-
- v = make_node (REAL_CST);
- dp = ggc_alloc<real_value> ();
- memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
-
- TREE_TYPE (v) = type;
- TREE_REAL_CST_PTR (v) = dp;
- TREE_OVERFLOW (v) = overflow;
- 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. */
-
-REAL_VALUE_TYPE
-real_value_from_int_cst (const_tree type, const_tree i)
-{
- REAL_VALUE_TYPE d;
-
- /* Clear all bits of the real value type so that we can later do
- bitwise comparisons to see if two values are the same. */
- memset (&d, 0, sizeof d);
-
- real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, wi::to_wide (i),
- TYPE_SIGN (TREE_TYPE (i)));
- return d;
-}
-
-/* Given a tree representing an integer constant I, return a tree
- representing the same value as a floating-point constant of type TYPE. */
-
-tree
-build_real_from_int_cst (tree type, const_tree i)
-{
- tree v;
- int overflow = TREE_OVERFLOW (i);
-
- v = build_real (type, real_value_from_int_cst (type, i));
-
- TREE_OVERFLOW (v) |= overflow;
- return v;
-}
-
-/* Return a new REAL_CST node whose type is TYPE
- and whose value is the integer value I which has sign SGN. */
-
-tree
-build_real_from_wide (tree type, const wide_int_ref &i, signop sgn)
-{
- REAL_VALUE_TYPE d;
-
- /* Clear all bits of the real value type so that we can later do
- bitwise comparisons to see if two values are the same. */
- memset (&d, 0, sizeof d);
-
- real_from_integer (&d, TYPE_MODE (type), i, sgn);
- return build_real (type, d);
-}
-
-/* Return a newly constructed STRING_CST node whose value is the LEN
- characters at STR when STR is nonnull, or all zeros otherwise.
- Note that for a C string literal, LEN should include the trailing NUL.
- The TREE_TYPE is not initialized. */
-
-tree
-build_string (unsigned len, const char *str /*= NULL */)
-{
- /* Do not waste bytes provided by padding of struct tree_string. */
- unsigned size = len + offsetof (struct tree_string, str) + 1;
-
- record_node_allocation_statistics (STRING_CST, size);
-
- tree s = (tree) ggc_internal_alloc (size);
-
- memset (s, 0, sizeof (struct tree_typed));
- TREE_SET_CODE (s, STRING_CST);
- TREE_CONSTANT (s) = 1;
- TREE_STRING_LENGTH (s) = len;
- if (str)
- memcpy (s->string.str, str, len);
- else
- memset (s->string.str, 0, len);
- s->string.str[len] = '\0';
-
- return s;
-}
-
-/* Return a newly constructed COMPLEX_CST node whose value is
- specified by the real and imaginary parts REAL and IMAG.
- Both REAL and IMAG should be constant nodes. TYPE, if specified,
- will be the type of the COMPLEX_CST; otherwise a new type will be made. */
-
-tree
-build_complex (tree type, tree real, tree imag)
-{
- gcc_assert (CONSTANT_CLASS_P (real));
- gcc_assert (CONSTANT_CLASS_P (imag));
-
- tree t = make_node (COMPLEX_CST);
-
- TREE_REALPART (t) = real;
- TREE_IMAGPART (t) = imag;
- TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
- TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
- 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. */
-
-tree
-build_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, dconst1);
-
- 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)));
-
- case VECTOR_TYPE:
- {
- tree scalar = build_one_cst (TREE_TYPE (type));
-
- return build_vector_from_val (type, scalar);
- }
-
- case COMPLEX_TYPE:
- return build_complex (type,
- build_one_cst (TREE_TYPE (type)),
- build_zero_cst (TREE_TYPE (type)));
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* 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). */
-
-tree
-build_zero_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: case NULLPTR_TYPE:
- return build_int_cst (type, 0);
-
- case REAL_TYPE:
- return build_real (type, dconst0);
-
- case FIXED_POINT_TYPE:
- return build_fixed (type, FCONST0 (TYPE_MODE (type)));
-
- case VECTOR_TYPE:
- {
- tree scalar = build_zero_cst (TREE_TYPE (type));
-
- return build_vector_from_val (type, scalar);
- }
-
- case COMPLEX_TYPE:
- {
- tree zero = build_zero_cst (TREE_TYPE (type));
-
- return build_complex (type, zero, zero);
- }
-
- default:
- if (!AGGREGATE_TYPE_P (type))
- return fold_convert (type, integer_zero_node);
- return build_constructor (type, NULL);
- }
-}
-
-
-/* Build a BINFO with LEN language slots. */
-
-tree
-make_tree_binfo (unsigned base_binfos MEM_STAT_DECL)
-{
- tree t;
- size_t length = (offsetof (struct tree_binfo, base_binfos)
- + 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);
-
- 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 (int len MEM_STAT_DECL)
-{
- tree t;
- 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;
-}
-\f
-/* Return 1 if EXPR is the constant zero, whether it is integral, float or
- fixed, and scalar, complex or vector. */
-
-bool
-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, or a location wrapper for such a constant. */
-
-bool
-integer_zerop (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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:
- return (VECTOR_CST_NPATTERNS (expr) == 1
- && VECTOR_CST_DUPLICATE_P (expr)
- && integer_zerop (VECTOR_CST_ENCODED_ELT (expr, 0)));
- default:
- return false;
- }
-}
-
-/* Return 1 if EXPR is the integer constant one or the corresponding
- complex constant, or a location wrapper for such a constant. */
-
-bool
-integer_onep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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:
- return (VECTOR_CST_NPATTERNS (expr) == 1
- && VECTOR_CST_DUPLICATE_P (expr)
- && integer_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
- 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.
- Also return 1 for location wrappers for such a constant. */
-
-bool
-integer_each_onep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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, or a complex or vector whose subparts are such integers,
- or a location wrapper for such a constant. */
-
-bool
-integer_all_onesp (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (expr);
-
- if (TREE_CODE (expr) == COMPLEX_CST
- && integer_all_onesp (TREE_REALPART (expr))
- && integer_all_onesp (TREE_IMAGPART (expr)))
- return true;
-
- else if (TREE_CODE (expr) == VECTOR_CST)
- return (VECTOR_CST_NPATTERNS (expr) == 1
- && VECTOR_CST_DUPLICATE_P (expr)
- && integer_all_onesp (VECTOR_CST_ENCODED_ELT (expr, 0)));
-
- else if (TREE_CODE (expr) != INTEGER_CST)
- return false;
-
- return (wi::max_value (TYPE_PRECISION (TREE_TYPE (expr)), UNSIGNED)
- == wi::to_wide (expr));
-}
-
-/* Return 1 if EXPR is the integer constant minus one, or a location wrapper
- for such a constant. */
-
-bool
-integer_minus_onep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (expr);
-
- if (TREE_CODE (expr) == COMPLEX_CST)
- return (integer_all_onesp (TREE_REALPART (expr))
- && integer_zerop (TREE_IMAGPART (expr)));
- else
- return integer_all_onesp (expr);
-}
-
-/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
- one bit on), or a location wrapper for such a constant. */
-
-bool
-integer_pow2p (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (expr);
-
- if (TREE_CODE (expr) == COMPLEX_CST
- && integer_pow2p (TREE_REALPART (expr))
- && integer_zerop (TREE_IMAGPART (expr)))
- return true;
-
- if (TREE_CODE (expr) != INTEGER_CST)
- return false;
-
- return wi::popcount (wi::to_wide (expr)) == 1;
-}
-
-/* Return 1 if EXPR is an integer constant other than zero or a
- complex constant other than zero, or a location wrapper for such a
- constant. */
-
-bool
-integer_nonzerop (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (expr);
-
- return ((TREE_CODE (expr) == INTEGER_CST
- && 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).
- Also return 1 for location wrappers for such a constant. */
-
-bool
-integer_truep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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, or a location wrapper
- for such a constant. */
-
-bool
-fixed_zerop (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (expr);
-
- return (TREE_CODE (expr) == FIXED_CST
- && TREE_FIXED_CST (expr).data.is_zero ());
-}
-
-/* Return the power of two represented by a tree node known to be a
- power of two. */
-
-int
-tree_log2 (const_tree expr)
-{
- if (TREE_CODE (expr) == COMPLEX_CST)
- return tree_log2 (TREE_REALPART (expr));
-
- return wi::exact_log2 (wi::to_wide (expr));
-}
-
-/* Similar, but return the largest integer Y such that 2 ** Y is less
- than or equal to EXPR. */
-
-int
-tree_floor_log2 (const_tree expr)
-{
- if (TREE_CODE (expr) == COMPLEX_CST)
- return tree_log2 (TREE_REALPART (expr));
-
- 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
- decimal float constants, so don't return 1 for them.
- Also return 1 for location wrappers around such a constant. */
-
-bool
-real_zerop (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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:
- {
- /* Don't simply check for a duplicate because the predicate
- accepts both +0.0 and -0.0. */
- unsigned count = vector_cst_encoded_nelts (expr);
- for (unsigned int i = 0; i < count; ++i)
- if (!real_zerop (VECTOR_CST_ENCODED_ELT (expr, i)))
- return false;
- return true;
- }
- default:
- return false;
- }
-}
-
-/* Return 1 if EXPR is the real constant one in real or complex form.
- Trailing zeroes matter for decimal float constants, so don't return
- 1 for them.
- Also return 1 for location wrappers around such a constant. */
-
-bool
-real_onep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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:
- return (VECTOR_CST_NPATTERNS (expr) == 1
- && VECTOR_CST_DUPLICATE_P (expr)
- && real_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
- default:
- return false;
- }
-}
-
-/* Return 1 if EXPR is the real constant minus one. Trailing zeroes
- matter for decimal float constants, so don't return 1 for them.
- Also return 1 for location wrappers around such a constant. */
-
-bool
-real_minus_onep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (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:
- return (VECTOR_CST_NPATTERNS (expr) == 1
- && VECTOR_CST_DUPLICATE_P (expr)
- && real_minus_onep (VECTOR_CST_ENCODED_ELT (expr, 0)));
- default:
- return false;
- }
-}
-
-/* Nonzero if EXP is a constant or a cast of a constant. */
-
-bool
-really_constant_p (const_tree exp)
-{
- /* This is not quite the same as STRIP_NOPS. It does more. */
- while (CONVERT_EXPR_P (exp)
- || TREE_CODE (exp) == NON_LVALUE_EXPR)
- exp = TREE_OPERAND (exp, 0);
- return TREE_CONSTANT (exp);
-}
-
-/* Return true if T holds a polynomial pointer difference, storing it in
- *VALUE if so. A true return means that T's precision is no greater
- than 64 bits, which is the largest address space we support, so *VALUE
- never loses precision. However, the signedness of the result does
- not necessarily match the signedness of T: sometimes an unsigned type
- like sizetype is used to encode a value that is actually negative. */
-
-bool
-ptrdiff_tree_p (const_tree t, poly_int64_pod *value)
-{
- if (!t)
- return false;
- if (TREE_CODE (t) == INTEGER_CST)
- {
- if (!cst_and_fits_in_hwi (t))
- return false;
- *value = int_cst_value (t);
- return true;
- }
- if (POLY_INT_CST_P (t))
- {
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- if (!cst_and_fits_in_hwi (POLY_INT_CST_COEFF (t, i)))
- return false;
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- value->coeffs[i] = int_cst_value (POLY_INT_CST_COEFF (t, i));
- return true;
- }
- return false;
-}
-
-poly_int64
-tree_to_poly_int64 (const_tree t)
-{
- gcc_assert (tree_fits_poly_int64_p (t));
- if (POLY_INT_CST_P (t))
- return poly_int_cst_value (t).force_shwi ();
- return TREE_INT_CST_LOW (t);
-}
-
-poly_uint64
-tree_to_poly_uint64 (const_tree t)
-{
- gcc_assert (tree_fits_poly_uint64_p (t));
- if (POLY_INT_CST_P (t))
- return poly_int_cst_value (t).force_uhwi ();
- return TREE_INT_CST_LOW (t);
-}
-\f
-/* Return first list element whose TREE_VALUE is ELEM.
- Return 0 if ELEM is not in LIST. */
-
-tree
-value_member (tree elem, tree list)
-{
- while (list)
- {
- if (elem == TREE_VALUE (list))
- return list;
- list = TREE_CHAIN (list);
- }
- return NULL_TREE;
-}
-
-/* Return first list element whose TREE_PURPOSE is ELEM.
- Return 0 if ELEM is not in LIST. */
-
-tree
-purpose_member (const_tree elem, tree list)
-{
- while (list)
- {
- if (elem == TREE_PURPOSE (list))
- return list;
- list = TREE_CHAIN (list);
- }
- return NULL_TREE;
-}
-
-/* Return true if ELEM is in V. */
-
-bool
-vec_member (const_tree elem, vec<tree, va_gc> *v)
-{
- unsigned ix;
- tree t;
- FOR_EACH_VEC_SAFE_ELT (v, ix, t)
- if (elem == t)
- return true;
- return false;
-}
-
-/* Returns element number IDX (zero-origin) of chain CHAIN, or
- NULL_TREE. */
-
-tree
-chain_index (int idx, tree chain)
-{
- for (; chain && idx > 0; --idx)
- chain = TREE_CHAIN (chain);
- return chain;
-}
-
-/* Return nonzero if ELEM is part of the chain CHAIN. */
-
-bool
-chain_member (const_tree elem, const_tree chain)
-{
- while (chain)
- {
- if (elem == chain)
- return true;
- chain = DECL_CHAIN (chain);
- }
-
- return false;
-}
-
-/* Return the length of a chain of nodes chained through TREE_CHAIN.
- We expect a null pointer to mark the end of the chain.
- This is the Lisp primitive `length'. */
-
-int
-list_length (const_tree t)
-{
- const_tree p = t;
-#ifdef ENABLE_TREE_CHECKING
- const_tree q = t;
-#endif
- int len = 0;
-
- while (p)
- {
- p = TREE_CHAIN (p);
-#ifdef ENABLE_TREE_CHECKING
- if (len % 2)
- q = TREE_CHAIN (q);
- gcc_assert (p != q);
-#endif
- len++;
- }
-
- return len;
-}
-
-/* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
- UNION_TYPE TYPE, or NULL_TREE if none. */
-
-tree
-first_field (const_tree type)
-{
- tree t = TYPE_FIELDS (type);
- while (t && TREE_CODE (t) != FIELD_DECL)
- t = TREE_CHAIN (t);
- return t;
-}
-
-/* Returns the last FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
- UNION_TYPE TYPE, or NULL_TREE if none. */
-
-tree
-last_field (const_tree type)
-{
- tree last = NULL_TREE;
-
- for (tree fld = TYPE_FIELDS (type); fld; fld = TREE_CHAIN (fld))
- {
- if (TREE_CODE (fld) != FIELD_DECL)
- continue;
-
- last = fld;
- }
-
- return last;
-}
-
-/* Concatenate two chains of nodes (chained through TREE_CHAIN)
- by modifying the last node in chain 1 to point to chain 2.
- This is the Lisp primitive `nconc'. */
-
-tree
-chainon (tree op1, tree op2)
-{
- tree t1;
-
- if (!op1)
- return op2;
- if (!op2)
- return op1;
-
- for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
- continue;
- TREE_CHAIN (t1) = op2;
-
-#ifdef ENABLE_TREE_CHECKING
- {
- tree t2;
- for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
- gcc_assert (t2 != t1);
- }
-#endif
-
- return op1;
-}
-
-/* Return the last node in a chain of nodes (chained through TREE_CHAIN). */
-
-tree
-tree_last (tree chain)
-{
- tree next;
- if (chain)
- while ((next = TREE_CHAIN (chain)))
- chain = next;
- return chain;
-}
-
-/* Reverse the order of elements in the chain T,
- and return the new head of the chain (old last element). */
-
-tree
-nreverse (tree t)
-{
- tree prev = 0, decl, next;
- for (decl = t; decl; decl = next)
- {
- /* We shouldn't be using this function to reverse BLOCK chains; we
- have blocks_nreverse for that. */
- gcc_checking_assert (TREE_CODE (decl) != BLOCK);
- next = TREE_CHAIN (decl);
- TREE_CHAIN (decl) = prev;
- prev = decl;
- }
- return prev;
-}
-\f
-/* Return a newly created TREE_LIST node whose
- purpose and value fields are PARM and VALUE. */
-
-tree
-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;
-}
-
-/* Build a chain of TREE_LIST nodes from a vector. */
-
-tree
-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_SAFE_ELT (vec, i, t)
- {
- *pp = build_tree_list (NULL, t PASS_MEM_STAT);
- pp = &TREE_CHAIN (*pp);
- }
- return ret;
-}
-
-/* Return a newly created TREE_LIST node whose
- purpose and value fields are PURPOSE and VALUE
- and whose TREE_CHAIN is CHAIN. */
-
-tree
-tree_cons (tree purpose, tree value, tree chain MEM_STAT_DECL)
-{
- tree node;
-
- node = ggc_alloc_tree_node_stat (sizeof (struct tree_list) PASS_MEM_STAT);
- memset (node, 0, sizeof (struct tree_common));
-
- record_node_allocation_statistics (TREE_LIST, sizeof (struct tree_list));
-
- TREE_SET_CODE (node, TREE_LIST);
- TREE_CHAIN (node) = chain;
- TREE_PURPOSE (node) = purpose;
- TREE_VALUE (node) = value;
- return node;
-}
-
-/* Return the values of the elements of a CONSTRUCTOR as a vector of
- trees. */
-
-vec<tree, va_gc> *
-ctor_to_vec (tree 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 (val);
-
- return vec;
-}
-\f
-/* Return the size nominally occupied by an object of type TYPE
- when it resides in memory. The value is measured in units of bytes,
- and its data type is that normally used for type sizes
- (which is the first type created by make_signed_type or
- make_unsigned_type). */
-
-tree
-size_in_bytes_loc (location_t loc, const_tree type)
-{
- tree t;
-
- if (type == error_mark_node)
- return integer_zero_node;
-
- type = TYPE_MAIN_VARIANT (type);
- t = TYPE_SIZE_UNIT (type);
-
- if (t == 0)
- {
- lang_hooks.types.incomplete_type_error (loc, NULL_TREE, type);
- return size_zero_node;
- }
-
- return t;
-}
-
-/* Return the size of TYPE (in bytes) as a wide integer
- or return -1 if the size can vary or is larger than an integer. */
-
-HOST_WIDE_INT
-int_size_in_bytes (const_tree type)
-{
- tree t;
-
- if (type == error_mark_node)
- return 0;
-
- type = TYPE_MAIN_VARIANT (type);
- t = TYPE_SIZE_UNIT (type);
-
- if (t && tree_fits_uhwi_p (t))
- return TREE_INT_CST_LOW (t);
- else
- return -1;
-}
-
-/* Return the maximum size of TYPE (in bytes) as a wide integer
- or return -1 if the size can vary or is larger than an integer. */
-
-HOST_WIDE_INT
-max_int_size_in_bytes (const_tree type)
-{
- HOST_WIDE_INT size = -1;
- tree size_tree;
-
- /* If this is an array type, check for a possible MAX_SIZE attached. */
-
- if (TREE_CODE (type) == ARRAY_TYPE)
- {
- size_tree = TYPE_ARRAY_MAX_SIZE (type);
-
- 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
- can compute a maximum size. */
-
- if (size == -1)
- {
- size_tree = lang_hooks.types.max_size (type);
-
- if (size_tree && tree_fits_uhwi_p (size_tree))
- size = tree_to_uhwi (size_tree);
- }
-
- return size;
-}
-\f
-/* Return the bit position of FIELD, in bits from the start of the record.
- This is a tree of type bitsizetype. */
-
-tree
-bit_position (const_tree field)
-{
- return bit_from_pos (DECL_FIELD_OFFSET (field),
- DECL_FIELD_BIT_OFFSET (field));
-}
-\f
-/* Return the byte position of FIELD, in bytes from the start of the record.
- This is a tree of type sizetype. */
-
-tree
-byte_position (const_tree field)
-{
- return byte_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_byte_position (const_tree field)
-{
- return tree_to_shwi (byte_position (field));
-}
-\f
-/* Return, as a tree node, the number of elements for TYPE (which is an
- ARRAY_TYPE) minus one. This counts only elements of the top array. */
-
-tree
-array_type_nelts (const_tree type)
-{
- tree index_type, min, max;
-
- /* If they did it with unspecified bounds, then we should have already
- given an error about it before we got here. */
- if (! TYPE_DOMAIN (type))
- return error_mark_node;
-
- index_type = TYPE_DOMAIN (type);
- 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)
- {
- /* zero sized arrays are represented from C FE as complete types with
- NULL TYPE_MAX_VALUE and zero TYPE_SIZE, while C++ FE represents
- them as min 0, max -1. */
- if (COMPLETE_TYPE_P (type)
- && integer_zerop (TYPE_SIZE (type))
- && integer_zerop (min))
- return build_int_cst (TREE_TYPE (min), -1);
-
- return error_mark_node;
- }
-
- return (integer_zerop (min)
- ? max
- : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
-}
-\f
-/* If arg is static -- a reference to an object in static storage -- then
- return the object. This is not the same as the C meaning of `static'.
- If arg isn't static, return NULL. */
-
-tree
-staticp (tree arg)
-{
- switch (TREE_CODE (arg))
- {
- case FUNCTION_DECL:
- /* Nested functions are static, even though taking their address will
- involve a trampoline as we unnest the nested function and create
- the trampoline on the tree level. */
- return arg;
-
- case VAR_DECL:
- return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
- && ! DECL_THREAD_LOCAL_P (arg)
- && ! DECL_DLLIMPORT_P (arg)
- ? arg : NULL);
-
- case CONST_DECL:
- return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
- ? arg : NULL);
-
- case CONSTRUCTOR:
- return TREE_STATIC (arg) ? arg : NULL;
-
- case LABEL_DECL:
- case STRING_CST:
- return arg;
-
- case COMPONENT_REF:
- /* If the thing being referenced is not a field, then it is
- something language specific. */
- gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
-
- /* If we are referencing a bitfield, we can't evaluate an
- ADDR_EXPR at compile time and so it isn't a constant. */
- if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
- return NULL;
-
- return staticp (TREE_OPERAND (arg, 0));
-
- case BIT_FIELD_REF:
- return NULL;
-
- case INDIRECT_REF:
- return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
-
- case ARRAY_REF:
- case ARRAY_RANGE_REF:
- if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
- && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
- return staticp (TREE_OPERAND (arg, 0));
- else
- return NULL;
-
- case COMPOUND_LITERAL_EXPR:
- return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
-
- default:
- return NULL;
- }
-}
-
-\f
-
-
-/* Return whether OP is a DECL whose address is function-invariant. */
-
-bool
-decl_address_invariant_p (const_tree op)
-{
- /* The conditions below are slightly less strict than the one in
- staticp. */
-
- switch (TREE_CODE (op))
- {
- case PARM_DECL:
- case RESULT_DECL:
- case LABEL_DECL:
- case FUNCTION_DECL:
- return true;
-
- case VAR_DECL:
- if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
- || DECL_THREAD_LOCAL_P (op)
- || DECL_CONTEXT (op) == current_function_decl
- || decl_function_context (op) == current_function_decl)
- return true;
- break;
-
- case CONST_DECL:
- if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
- || decl_function_context (op) == current_function_decl)
- return true;
- break;
-
- default:
- break;
- }
-
- return false;
-}
-
-/* Return whether OP is a DECL whose address is interprocedural-invariant. */
-
-bool
-decl_address_ip_invariant_p (const_tree op)
-{
- /* The conditions below are slightly less strict than the one in
- staticp. */
-
- switch (TREE_CODE (op))
- {
- case LABEL_DECL:
- case FUNCTION_DECL:
- case STRING_CST:
- return true;
-
- case VAR_DECL:
- if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
- && !DECL_DLLIMPORT_P (op))
- || DECL_THREAD_LOCAL_P (op))
- return true;
- break;
-
- case CONST_DECL:
- if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
- return true;
- break;
-
- default:
- break;
- }
-
- return false;
-}
-
-
-/* Return true if T is function-invariant (internal function, does
- not handle arithmetic; that's handled in skip_simple_arithmetic and
- tree_invariant_p). */
-
-static bool
-tree_invariant_p_1 (tree t)
-{
- tree op;
-
- if (TREE_CONSTANT (t)
- || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
- return true;
-
- switch (TREE_CODE (t))
- {
- case SAVE_EXPR:
- return true;
-
- case ADDR_EXPR:
- op = TREE_OPERAND (t, 0);
- while (handled_component_p (op))
- {
- switch (TREE_CODE (op))
- {
- case ARRAY_REF:
- case ARRAY_RANGE_REF:
- if (!tree_invariant_p (TREE_OPERAND (op, 1))
- || TREE_OPERAND (op, 2) != NULL_TREE
- || TREE_OPERAND (op, 3) != NULL_TREE)
- return false;
- break;
-
- case COMPONENT_REF:
- if (TREE_OPERAND (op, 2) != NULL_TREE)
- return false;
- break;
-
- default:;
- }
- op = TREE_OPERAND (op, 0);
- }
-
- return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
-
- default:
- break;
- }
-
- return false;
-}
-
-/* Return true if T is function-invariant. */
-
-bool
-tree_invariant_p (tree t)
-{
- tree inner = skip_simple_arithmetic (t);
- return tree_invariant_p_1 (inner);
-}
-
-/* Wrap a SAVE_EXPR around EXPR, if appropriate.
- Do this to any expression which may be used in more than one place,
- but must be evaluated only once.
-
- Normally, expand_expr would reevaluate the expression each time.
- Calling save_expr produces something that is evaluated and recorded
- the first time expand_expr is called on it. Subsequent calls to
- expand_expr just reuse the recorded value.
-
- The call to expand_expr that generates code that actually computes
- the value is the first call *at compile time*. Subsequent calls
- *at compile time* generate code to use the saved value.
- This produces correct result provided that *at run time* control
- always flows through the insns made by the first expand_expr
- before reaching the other places where the save_expr was evaluated.
- You, the caller of save_expr, must make sure this is so.
-
- Constants, and certain read-only nodes, are returned with no
- SAVE_EXPR because that is safe. Expressions containing placeholders
- are not touched; see tree.def for an explanation of what these
- are used for. */
-
-tree
-save_expr (tree expr)
-{
- tree inner;
-
- /* If the tree evaluates to a constant, then we don't want to hide that
- fact (i.e. this allows further folding, and direct checks for constants).
- 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 (expr);
- if (TREE_CODE (inner) == ERROR_MARK)
- return inner;
-
- if (tree_invariant_p_1 (inner))
- 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 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 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 (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)
-{
- /* We don't care about whether this can be used as an lvalue in this
- context. */
- while (TREE_CODE (expr) == NON_LVALUE_EXPR)
- expr = TREE_OPERAND (expr, 0);
-
- /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
- a constant, it will be more efficient to not make another SAVE_EXPR since
- it will allow better simplification and GCSE will be able to merge the
- computations if they actually occur. */
- 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;
- }
- else
- break;
- }
-
- 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. */
-
-enum tree_node_structure_enum
-tree_node_structure (const_tree t)
-{
- const enum tree_code code = TREE_CODE (t);
- return tree_node_structure_for_code (code);
-}
-
-/* Set various status flags when building a CALL_EXPR object T. */
-
-static void
-process_call_operands (tree t)
-{
- bool side_effects = TREE_SIDE_EFFECTS (t);
- bool read_only = false;
- int i = call_expr_flags (t);
-
- /* Calls have side-effects, except those to const or pure functions. */
- if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
- side_effects = true;
- /* Propagate TREE_READONLY of arguments for const functions. */
- if (i & ECF_CONST)
- read_only = true;
-
- if (!side_effects || read_only)
- for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
- {
- tree op = TREE_OPERAND (t, i);
- if (op && TREE_SIDE_EFFECTS (op))
- side_effects = true;
- if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
- read_only = false;
- }
-
- TREE_SIDE_EFFECTS (t) = side_effects;
- TREE_READONLY (t) = read_only;
-}
-\f
-/* Return true if EXP contains a PLACEHOLDER_EXPR, i.e. if it represents a
- size or offset that depends on a field within a record. */
-
-bool
-contains_placeholder_p (const_tree exp)
-{
- enum tree_code code;
-
- if (!exp)
- return 0;
-
- code = TREE_CODE (exp);
- if (code == PLACEHOLDER_EXPR)
- return 1;
-
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_reference:
- /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
- position computations since they will be converted into a
- WITH_RECORD_EXPR involving the reference, which will assume
- here will be valid. */
- return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
-
- case tcc_exceptional:
- if (code == TREE_LIST)
- return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
- || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
- break;
-
- case tcc_unary:
- case tcc_binary:
- case tcc_comparison:
- case tcc_expression:
- switch (code)
- {
- case COMPOUND_EXPR:
- /* Ignoring the first operand isn't quite right, but works best. */
- return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
-
- case COND_EXPR:
- return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
- || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
- || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
-
- case SAVE_EXPR:
- /* The save_expr function never wraps anything containing
- a PLACEHOLDER_EXPR. */
- return 0;
-
- default:
- break;
- }
-
- switch (TREE_CODE_LENGTH (code))
- {
- case 1:
- return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
- case 2:
- return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
- || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
- default:
- return 0;
- }
-
- case tcc_vl_exp:
- switch (code)
- {
- case CALL_EXPR:
- {
- const_tree arg;
- const_call_expr_arg_iterator iter;
- FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
- if (CONTAINS_PLACEHOLDER_P (arg))
- return 1;
- return 0;
- }
- default:
- return 0;
- }
-
- default:
- return 0;
- }
- return 0;
-}
-
-/* Return true if any part of the structure of TYPE involves a PLACEHOLDER_EXPR
- directly. This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and
- field positions. */
-
-static bool
-type_contains_placeholder_1 (const_tree type)
-{
- /* If the size contains a placeholder or the parent type (component type in
- the case of arrays) type involves a placeholder, this type does. */
- if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
- || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
- || (!POINTER_TYPE_P (type)
- && TREE_TYPE (type)
- && type_contains_placeholder_p (TREE_TYPE (type))))
- return true;
-
- /* Now do type-specific checks. Note that the last part of the check above
- greatly limits what we have to do below. */
- switch (TREE_CODE (type))
- {
- case VOID_TYPE:
- case OPAQUE_TYPE:
- case COMPLEX_TYPE:
- case ENUMERAL_TYPE:
- case BOOLEAN_TYPE:
- case POINTER_TYPE:
- case OFFSET_TYPE:
- case REFERENCE_TYPE:
- case METHOD_TYPE:
- case FUNCTION_TYPE:
- case VECTOR_TYPE:
- case NULLPTR_TYPE:
- return false;
-
- case INTEGER_TYPE:
- case REAL_TYPE:
- case FIXED_POINT_TYPE:
- /* Here we just check the bounds. */
- return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
- || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
-
- case ARRAY_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:
- case QUAL_UNION_TYPE:
- {
- tree field;
-
- for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
- if (TREE_CODE (field) == FIELD_DECL
- && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
- || (TREE_CODE (type) == QUAL_UNION_TYPE
- && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
- || type_contains_placeholder_p (TREE_TYPE (field))))
- return true;
-
- return false;
- }
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* Wrapper around above function used to cache its result. */
-
-bool
-type_contains_placeholder_p (tree type)
-{
- bool result;
-
- /* If the contains_placeholder_bits field has been initialized,
- then we know the answer. */
- if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
- return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
-
- /* Indicate that we've seen this type node, and the answer is false.
- This is what we want to return if we run into recursion via fields. */
- TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
-
- /* Compute the real value. */
- result = type_contains_placeholder_1 (type);
-
- /* Store the real value. */
- TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
-
- return result;
-}
-\f
-/* Push tree EXP onto vector QUEUE if it is not already present. */
-
-static void
-push_without_duplicates (tree exp, vec<tree> *queue)
-{
- unsigned int i;
- tree iter;
-
- FOR_EACH_VEC_ELT (*queue, i, iter)
- if (simple_cst_equal (iter, exp) == 1)
- break;
-
- if (!iter)
- 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
- or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
- argument list. */
-
-void
-find_placeholder_in_expr (tree exp, vec<tree> *refs)
-{
- enum tree_code code = TREE_CODE (exp);
- tree inner;
- int i;
-
- /* We handle TREE_LIST and COMPONENT_REF separately. */
- if (code == TREE_LIST)
- {
- FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
- FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
- }
- else if (code == COMPONENT_REF)
- {
- for (inner = TREE_OPERAND (exp, 0);
- REFERENCE_CLASS_P (inner);
- inner = TREE_OPERAND (inner, 0))
- ;
-
- if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
- push_without_duplicates (exp, refs);
- else
- FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
- }
- else
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_constant:
- break;
-
- case tcc_declaration:
- /* Variables allocated to static storage can stay. */
- if (!TREE_STATIC (exp))
- push_without_duplicates (exp, refs);
- break;
-
- case tcc_expression:
- /* This is the pattern built in ada/make_aligning_type. */
- if (code == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
- {
- push_without_duplicates (exp, refs);
- break;
- }
-
- /* Fall through. */
-
- case tcc_exceptional:
- case tcc_unary:
- case tcc_binary:
- case tcc_comparison:
- case tcc_reference:
- for (i = 0; i < TREE_CODE_LENGTH (code); i++)
- FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
- break;
-
- case tcc_vl_exp:
- for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
- FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
- break;
-
- default:
- gcc_unreachable ();
- }
-}
-
-/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
- return a tree with all occurrences of references to F in a
- PLACEHOLDER_EXPR replaced by R. Also handle VAR_DECLs and
- CONST_DECLs. Note that we assume here that EXP contains only
- arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
- occurring only in their argument list. */
-
-tree
-substitute_in_expr (tree exp, tree f, tree r)
-{
- enum tree_code code = TREE_CODE (exp);
- tree op0, op1, op2, op3;
- tree new_tree;
-
- /* We handle TREE_LIST and COMPONENT_REF separately. */
- if (code == TREE_LIST)
- {
- op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
- op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
- if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
- return exp;
-
- return tree_cons (TREE_PURPOSE (exp), op1, op0);
- }
- else if (code == COMPONENT_REF)
- {
- tree inner;
-
- /* If this expression is getting a value from a PLACEHOLDER_EXPR
- and it is the right field, replace it with R. */
- for (inner = TREE_OPERAND (exp, 0);
- REFERENCE_CLASS_P (inner);
- inner = TREE_OPERAND (inner, 0))
- ;
-
- /* The field. */
- op1 = TREE_OPERAND (exp, 1);
-
- if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
- return r;
-
- /* If this expression hasn't been completed let, leave it alone. */
- if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
- return exp;
-
- op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
- if (op0 == TREE_OPERAND (exp, 0))
- return exp;
-
- new_tree
- = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
- }
- else
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_constant:
- return exp;
-
- case tcc_declaration:
- if (exp == f)
- return r;
- else
- return exp;
-
- case tcc_expression:
- if (exp == f)
- return r;
-
- /* Fall through. */
-
- case tcc_exceptional:
- case tcc_unary:
- case tcc_binary:
- case tcc_comparison:
- case tcc_reference:
- switch (TREE_CODE_LENGTH (code))
- {
- case 0:
- return exp;
-
- case 1:
- op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
- if (op0 == TREE_OPERAND (exp, 0))
- return exp;
-
- new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
- break;
-
- case 2:
- op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
- op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
-
- if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
- return exp;
-
- new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
- break;
-
- case 3:
- op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
- op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
- op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
-
- if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
- && op2 == TREE_OPERAND (exp, 2))
- return exp;
-
- new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
- break;
-
- case 4:
- op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
- op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
- op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
- op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
-
- if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
- && op2 == TREE_OPERAND (exp, 2)
- && op3 == TREE_OPERAND (exp, 3))
- return exp;
-
- new_tree
- = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
- break;
-
- default:
- gcc_unreachable ();
- }
- break;
-
- case tcc_vl_exp:
- {
- int i;
-
- new_tree = NULL_TREE;
-
- /* 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 (code == CALL_EXPR)
- {
- 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++)
- {
- tree op = TREE_OPERAND (exp, i);
- tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
- if (new_op != op)
- {
- if (!new_tree)
- new_tree = copy_node (exp);
- TREE_OPERAND (new_tree, i) = new_op;
- }
- }
-
- if (new_tree)
- {
- new_tree = fold (new_tree);
- if (TREE_CODE (new_tree) == CALL_EXPR)
- process_call_operands (new_tree);
- }
- else
- return exp;
- }
- break;
-
- default:
- gcc_unreachable ();
- }
-
- TREE_READONLY (new_tree) |= TREE_READONLY (exp);
-
- if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
- TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
-
- return new_tree;
-}
-
-/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
- for it within OBJ, a tree that is an object or a chain of references. */
-
-tree
-substitute_placeholder_in_expr (tree exp, tree obj)
-{
- enum tree_code code = TREE_CODE (exp);
- tree op0, op1, op2, op3;
- tree new_tree;
-
- /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
- in the chain of OBJ. */
- if (code == PLACEHOLDER_EXPR)
- {
- tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
- tree elt;
-
- for (elt = obj; elt != 0;
- elt = ((TREE_CODE (elt) == COMPOUND_EXPR
- || TREE_CODE (elt) == COND_EXPR)
- ? TREE_OPERAND (elt, 1)
- : (REFERENCE_CLASS_P (elt)
- || UNARY_CLASS_P (elt)
- || BINARY_CLASS_P (elt)
- || VL_EXP_CLASS_P (elt)
- || EXPRESSION_CLASS_P (elt))
- ? TREE_OPERAND (elt, 0) : 0))
- if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
- return elt;
-
- for (elt = obj; elt != 0;
- elt = ((TREE_CODE (elt) == COMPOUND_EXPR
- || TREE_CODE (elt) == COND_EXPR)
- ? TREE_OPERAND (elt, 1)
- : (REFERENCE_CLASS_P (elt)
- || UNARY_CLASS_P (elt)
- || BINARY_CLASS_P (elt)
- || VL_EXP_CLASS_P (elt)
- || EXPRESSION_CLASS_P (elt))
- ? TREE_OPERAND (elt, 0) : 0))
- if (POINTER_TYPE_P (TREE_TYPE (elt))
- && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
- == need_type))
- return fold_build1 (INDIRECT_REF, need_type, elt);
-
- /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it
- survives until RTL generation, there will be an error. */
- return exp;
- }
-
- /* TREE_LIST is special because we need to look at TREE_VALUE
- and TREE_CHAIN, not TREE_OPERANDS. */
- else if (code == TREE_LIST)
- {
- op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
- op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
- if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
- return exp;
-
- return tree_cons (TREE_PURPOSE (exp), op1, op0);
- }
- else
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_constant:
- case tcc_declaration:
- return exp;
-
- case tcc_exceptional:
- case tcc_unary:
- case tcc_binary:
- case tcc_comparison:
- case tcc_expression:
- case tcc_reference:
- case tcc_statement:
- switch (TREE_CODE_LENGTH (code))
- {
- case 0:
- return exp;
-
- case 1:
- op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
- if (op0 == TREE_OPERAND (exp, 0))
- return exp;
-
- new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
- break;
-
- case 2:
- op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
- op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
-
- if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
- return exp;
-
- new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
- break;
-
- case 3:
- op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
- op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
- op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
-
- if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
- && op2 == TREE_OPERAND (exp, 2))
- return exp;
-
- new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
- break;
-
- case 4:
- op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
- op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
- op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
- op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
-
- if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
- && op2 == TREE_OPERAND (exp, 2)
- && op3 == TREE_OPERAND (exp, 3))
- return exp;
-
- new_tree
- = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
- break;
-
- default:
- gcc_unreachable ();
- }
- break;
-
- case tcc_vl_exp:
- {
- int i;
-
- new_tree = NULL_TREE;
-
- for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
- {
- tree op = TREE_OPERAND (exp, i);
- tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
- if (new_op != op)
- {
- if (!new_tree)
- new_tree = copy_node (exp);
- TREE_OPERAND (new_tree, i) = new_op;
- }
- }
-
- if (new_tree)
- {
- new_tree = fold (new_tree);
- if (TREE_CODE (new_tree) == CALL_EXPR)
- process_call_operands (new_tree);
- }
- else
- return exp;
- }
- break;
-
- default:
- gcc_unreachable ();
- }
-
- TREE_READONLY (new_tree) |= TREE_READONLY (exp);
-
- if (code == INDIRECT_REF || code == ARRAY_REF || code == ARRAY_RANGE_REF)
- TREE_THIS_NOTRAP (new_tree) |= TREE_THIS_NOTRAP (exp);
-
- return new_tree;
-}
-\f
-
-/* Subroutine of stabilize_reference; this is called for subtrees of
- references. Any expression with side-effects must be put in a SAVE_EXPR
- to ensure that it is only evaluated once.
-
- We don't put SAVE_EXPR nodes around everything, because assigning very
- simple expressions to temporaries causes us to miss good opportunities
- for optimizations. Among other things, the opportunity to fold in the
- addition of a constant into an addressing mode often gets lost, e.g.
- "y[i+1] += x;". In general, we take the approach that we should not make
- an assignment unless we are forced into it - i.e., that any non-side effect
- operator should be allowed, and that cse should take care of coalescing
- multiple utterances of the same expression should that prove fruitful. */
-
-static tree
-stabilize_reference_1 (tree e)
-{
- tree result;
- enum tree_code code = TREE_CODE (e);
-
- /* We cannot ignore const expressions because it might be a reference
- to a const array but whose index contains side-effects. But we can
- ignore things that are actual constant or that already have been
- handled by this function. */
-
- if (tree_invariant_p (e))
- return e;
-
- switch (TREE_CODE_CLASS (code))
- {
- case tcc_exceptional:
- /* Always wrap STATEMENT_LIST into SAVE_EXPR, even if it doesn't
- have side-effects. */
- if (code == STATEMENT_LIST)
- return save_expr (e);
- /* FALLTHRU */
- case tcc_type:
- case tcc_declaration:
- case tcc_comparison:
- case tcc_statement:
- case tcc_expression:
- case tcc_reference:
- case tcc_vl_exp:
- /* If the expression has side-effects, then encase it in a SAVE_EXPR
- so that it will only be evaluated once. */
- /* The reference (r) and comparison (<) classes could be handled as
- below, but it is generally faster to only evaluate them once. */
- if (TREE_SIDE_EFFECTS (e))
- return save_expr (e);
- return e;
-
- case tcc_constant:
- /* Constants need no processing. In fact, we should never reach
- here. */
- return e;
-
- case tcc_binary:
- /* Division is slow and tends to be compiled with jumps,
- especially the division by powers of 2 that is often
- found inside of an array reference. So do it just once. */
- if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
- || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
- || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
- || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
- return save_expr (e);
- /* Recursively stabilize each operand. */
- result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
- stabilize_reference_1 (TREE_OPERAND (e, 1)));
- break;
-
- case tcc_unary:
- /* Recursively stabilize each operand. */
- result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
- break;
-
- default:
- gcc_unreachable ();
- }
-
- TREE_TYPE (result) = TREE_TYPE (e);
- TREE_READONLY (result) = TREE_READONLY (e);
- TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
- TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
-
- 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;
-}
-\f
-/* Low-level constructors for expressions. */
-
-/* A helper function for build1 and constant folders. Set TREE_CONSTANT,
- and TREE_SIDE_EFFECTS for an ADDR_EXPR. */
-
-void
-recompute_tree_invariant_for_addr_expr (tree t)
-{
- 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.
- Also check for side-effects.
-
- ??? Note that this code makes no attempt to deal with the case where
- taking the address of something causes a copy due to misalignment. */
-
-#define UPDATE_FLAGS(NODE) \
-do { tree _node = (NODE); \
- if (_node && !TREE_CONSTANT (_node)) tc = false; \
- if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
-
- for (node = TREE_OPERAND (t, 0); handled_component_p (node);
- node = TREE_OPERAND (node, 0))
- {
- /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
- array reference (probably made temporarily by the G++ front end),
- so ignore all the operands. */
- if ((TREE_CODE (node) == ARRAY_REF
- || TREE_CODE (node) == ARRAY_RANGE_REF)
- && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
- {
- UPDATE_FLAGS (TREE_OPERAND (node, 1));
- if (TREE_OPERAND (node, 2))
- UPDATE_FLAGS (TREE_OPERAND (node, 2));
- if (TREE_OPERAND (node, 3))
- UPDATE_FLAGS (TREE_OPERAND (node, 3));
- }
- /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
- FIELD_DECL, apparently. The G++ front end can put something else
- there, at least temporarily. */
- else if (TREE_CODE (node) == COMPONENT_REF
- && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
- {
- if (TREE_OPERAND (node, 2))
- UPDATE_FLAGS (TREE_OPERAND (node, 2));
- }
- }
-
- node = lang_hooks.expr_to_decl (node, &tc, &se);
-
- /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from
- the address, since &(*a)->b is a form of addition. If it's a constant, the
- address is constant too. If it's a decl, its address is constant if the
- decl is static. Everything else is not constant and, furthermore,
- taking the address of a volatile variable is not volatile. */
- if (TREE_CODE (node) == INDIRECT_REF
- || TREE_CODE (node) == MEM_REF)
- UPDATE_FLAGS (TREE_OPERAND (node, 0));
- else if (CONSTANT_CLASS_P (node))
- ;
- else if (DECL_P (node))
- tc &= (staticp (node) != NULL_TREE);
- else
- {
- tc = false;
- se |= TREE_SIDE_EFFECTS (node);
- }
-
-
- TREE_CONSTANT (t) = tc;
- TREE_SIDE_EFFECTS (t) = se;
-#undef UPDATE_FLAGS
-}
-
-/* Build an expression of code CODE, data type TYPE, and operands as
- specified. Expressions and reference nodes can be created this way.
- Constants, decls, types and misc nodes cannot be.
-
- We define 5 non-variadic functions, from 0 to 4 arguments. This is
- enough for all extant tree codes. */
-
-tree
-build0 (enum tree_code code, tree tt MEM_STAT_DECL)
-{
- tree t;
-
- gcc_assert (TREE_CODE_LENGTH (code) == 0);
-
- t = make_node (code PASS_MEM_STAT);
- TREE_TYPE (t) = tt;
-
- return t;
-}
-
-tree
-build1 (enum tree_code code, tree type, tree node MEM_STAT_DECL)
-{
- int length = sizeof (struct tree_exp);
- tree t;
-
- record_node_allocation_statistics (code, length);
-
- gcc_assert (TREE_CODE_LENGTH (code) == 1);
-
- t = ggc_alloc_tree_node_stat (length PASS_MEM_STAT);
-
- memset (t, 0, sizeof (struct tree_common));
-
- TREE_SET_CODE (t, code);
-
- TREE_TYPE (t) = type;
- SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
- TREE_OPERAND (t, 0) = node;
- if (node && !TYPE_P (node))
- {
- TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
- TREE_READONLY (t) = TREE_READONLY (node);
- }
-
- if (TREE_CODE_CLASS (code) == tcc_statement)
- {
- if (code != DEBUG_BEGIN_STMT)
- TREE_SIDE_EFFECTS (t) = 1;
- }
- else switch (code)
- {
- case VA_ARG_EXPR:
- /* All of these have side-effects, no matter what their
- operands are. */
- TREE_SIDE_EFFECTS (t) = 1;
- TREE_READONLY (t) = 0;
- break;
-
- case INDIRECT_REF:
- /* Whether a dereference is readonly has nothing to do with whether
- its operand is readonly. */
- TREE_READONLY (t) = 0;
- break;
-
- case ADDR_EXPR:
- if (node)
- recompute_tree_invariant_for_addr_expr (t);
- break;
-
- default:
- if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
- && node && !TYPE_P (node)
- && TREE_CONSTANT (node))
- TREE_CONSTANT (t) = 1;
- if (TREE_CODE_CLASS (code) == tcc_reference
- && node && TREE_THIS_VOLATILE (node))
- TREE_THIS_VOLATILE (t) = 1;
- break;
- }
-
- return t;
-}
-
-#define PROCESS_ARG(N) \
- do { \
- TREE_OPERAND (t, N) = arg##N; \
- if (arg##N &&!TYPE_P (arg##N)) \
- { \
- if (TREE_SIDE_EFFECTS (arg##N)) \
- side_effects = 1; \
- if (!TREE_READONLY (arg##N) \
- && !CONSTANT_CLASS_P (arg##N)) \
- (void) (read_only = 0); \
- if (!TREE_CONSTANT (arg##N)) \
- (void) (constant = 0); \
- } \
- } while (0)
-
-tree
-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);
-
- if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
- && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
- /* When sizetype precision doesn't match that of pointers
- we need to be able to build explicit extensions or truncations
- of the offset argument. */
- && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
- gcc_assert (TREE_CODE (arg0) == INTEGER_CST
- && TREE_CODE (arg1) == INTEGER_CST);
-
- if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
- gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
- && 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
- result based on those same flags for the arguments. But if the
- arguments aren't really even `tree' expressions, we shouldn't be trying
- to do this. */
-
- /* Expressions without side effects may be constant if their
- arguments are as well. */
- constant = (TREE_CODE_CLASS (code) == tcc_comparison
- || TREE_CODE_CLASS (code) == tcc_binary);
- read_only = 1;
- side_effects = TREE_SIDE_EFFECTS (t);
-
- 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;
- 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 (enum tree_code code, tree tt, tree arg0, tree arg1,
- tree arg2 MEM_STAT_DECL)
-{
- bool constant, read_only, side_effects;
- tree t;
-
- gcc_assert (TREE_CODE_LENGTH (code) == 3);
- gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
-
- t = make_node (code PASS_MEM_STAT);
- TREE_TYPE (t) = tt;
-
- read_only = 1;
-
- /* As a special exception, if COND_EXPR has NULL branches, we
- assume that it is a gimple statement and always consider
- it to have side effects. */
- if (code == COND_EXPR
- && tt == void_type_node
- && arg1 == NULL_TREE
- && arg2 == NULL_TREE)
- side_effects = true;
- else
- side_effects = TREE_SIDE_EFFECTS (t);
-
- PROCESS_ARG (0);
- PROCESS_ARG (1);
- PROCESS_ARG (2);
-
- if (code == COND_EXPR)
- TREE_READONLY (t) = read_only;
-
- TREE_SIDE_EFFECTS (t) = side_effects;
- TREE_THIS_VOLATILE (t)
- = (TREE_CODE_CLASS (code) == tcc_reference
- && arg0 && TREE_THIS_VOLATILE (arg0));
-
- return t;
-}
-
-tree
-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 (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);
-
- TREE_SIDE_EFFECTS (t) = side_effects;
- TREE_THIS_VOLATILE (t)
- = (TREE_CODE_CLASS (code) == tcc_reference
- && arg0 && TREE_THIS_VOLATILE (arg0));
-
- return t;
-}
-
-tree
-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 (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);
-
- TREE_SIDE_EFFECTS (t) = side_effects;
- if (code == TARGET_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_THIS_VOLATILE (t)
- = (TREE_CODE_CLASS (code) == tcc_reference
- && arg0 && TREE_THIS_VOLATILE (arg0));
-
- return t;
-}
-
-/* Build a simple MEM_REF tree with the sematics of a plain INDIRECT_REF
- on the pointer PTR. */
-
-tree
-build_simple_mem_ref_loc (location_t loc, tree ptr)
-{
- poly_int64 offset = 0;
- tree ptype = TREE_TYPE (ptr);
- tree tem;
- /* For convenience allow addresses that collapse to a simple base
- and offset. */
- if (TREE_CODE (ptr) == ADDR_EXPR
- && (handled_component_p (TREE_OPERAND (ptr, 0))
- || TREE_CODE (TREE_OPERAND (ptr, 0)) == MEM_REF))
- {
- ptr = get_addr_base_and_unit_offset (TREE_OPERAND (ptr, 0), &offset);
- gcc_assert (ptr);
- if (TREE_CODE (ptr) == MEM_REF)
- {
- offset += mem_ref_offset (ptr).force_shwi ();
- ptr = TREE_OPERAND (ptr, 0);
- }
- else
- ptr = build_fold_addr_expr (ptr);
- gcc_assert (is_gimple_reg (ptr) || is_gimple_min_invariant (ptr));
- }
- tem = build2 (MEM_REF, TREE_TYPE (ptype),
- ptr, build_int_cst (ptype, offset));
- SET_EXPR_LOCATION (tem, loc);
- return tem;
-}
-
-/* Return the constant offset of a MEM_REF or TARGET_MEM_REF tree T. */
-
-poly_offset_int
-mem_ref_offset (const_tree t)
-{
- return poly_offset_int::from (wi::to_poly_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, poly_int64 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
- and leave the TREE_SIDE_EFFECTS as 0.
- It is permissible for arguments to be null,
- or even garbage if their values do not matter. */
-
-tree
-build_nt (enum tree_code code, ...)
-{
- tree t;
- int length;
- int i;
- va_list p;
-
- gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
-
- va_start (p, code);
-
- t = make_node (code);
- length = TREE_CODE_LENGTH (code);
-
- for (i = 0; i < length; i++)
- TREE_OPERAND (t, i) = va_arg (p, tree);
-
- va_end (p);
- return t;
-}
-
-/* Similar to build_nt, but for creating a CALL_EXPR object with a
- 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_safe_length (args) + 3);
- CALL_EXPR_FN (ret) = fn;
- CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
- FOR_EACH_VEC_SAFE_ELT (args, ix, t)
- CALL_EXPR_ARG (ret, ix) = t;
- return ret;
-}
-\f
-/* Create a DECL_... node of code CODE, name NAME (if non-null)
- and data type TYPE.
- We do NOT enter this node in any sort of symbol table.
-
- LOC is the location of the decl.
-
- layout_decl is used to set up the decl's storage layout.
- Other slots are initialized to 0 or null pointers. */
-
-tree
-build_decl (location_t loc, enum tree_code code, tree name,
- tree type MEM_STAT_DECL)
-{
- tree t;
-
- t = make_node (code PASS_MEM_STAT);
- DECL_SOURCE_LOCATION (t) = loc;
-
-/* if (type == error_mark_node)
- type = integer_type_node; */
-/* That is not done, deliberately, so that having error_mark_node
- as the type can suppress useless errors in the use of this variable. */
-
- DECL_NAME (t) = name;
- TREE_TYPE (t) = type;
-
- if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
- layout_decl (t, 0);
-
- return t;
-}
-
-/* Builds and returns function declaration with NAME and TYPE. */
-
-tree
-build_fn_decl (const char *name, tree type)
-{
- tree id = get_identifier (name);
- tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
-
- DECL_EXTERNAL (decl) = 1;
- TREE_PUBLIC (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- TREE_NOTHROW (decl) = 1;
-
- return decl;
-}
-
-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. */
-
-tree
-build_translation_unit_decl (tree name)
-{
- tree tu = build_decl (UNKNOWN_LOCATION, TRANSLATION_UNIT_DECL,
- name, NULL_TREE);
- TRANSLATION_UNIT_LANGUAGE (tu) = lang_hooks.name;
- vec_safe_push (all_translation_units, tu);
- return tu;
-}
-
-\f
-/* BLOCK nodes are used to represent the structure of binding contours
- and declarations, once those contours have been exited and their contents
- compiled. This information is used for outputting debugging info. */
-
-tree
-build_block (tree vars, tree subblocks, tree supercontext, tree chain)
-{
- tree block = make_node (BLOCK);
-
- BLOCK_VARS (block) = vars;
- BLOCK_SUBBLOCKS (block) = subblocks;
- BLOCK_SUPERCONTEXT (block) = supercontext;
- BLOCK_CHAIN (block) = chain;
- return block;
-}
-
-\f
-/* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
-
- LOC is the location to use in tree T. */
-
-void
-protected_set_expr_location (tree t, location_t loc)
-{
- if (CAN_HAVE_LOCATION_P (t))
- SET_EXPR_LOCATION (t, loc);
- else if (t && TREE_CODE (t) == STATEMENT_LIST)
- {
- t = expr_single (t);
- if (t && CAN_HAVE_LOCATION_P (t))
- SET_EXPR_LOCATION (t, loc);
- }
-}
-
-/* Like PROTECTED_SET_EXPR_LOCATION, but only do that if T has
- UNKNOWN_LOCATION. */
-
-void
-protected_set_expr_location_if_unset (tree t, location_t loc)
-{
- t = expr_single (t);
- if (t && !EXPR_HAS_LOCATION (t))
- protected_set_expr_location (t, loc);
-}
-\f
-/* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
- of the various TYPE_QUAL values. */
-
-static void
-set_type_quals (tree type, int type_quals)
-{
- 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);
-}
-
-/* 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 (const_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;
-}
-
-/* Returns true iff unqualified CAND and BASE are equivalent. */
-
-bool
-check_base_type (const_tree cand, const_tree base)
-{
- if (TYPE_NAME (cand) != TYPE_NAME (base)
- /* Apparently this is needed for Objective-C. */
- || TYPE_CONTEXT (cand) != TYPE_CONTEXT (base)
- || !attribute_list_equal (TYPE_ATTRIBUTES (cand),
- TYPE_ATTRIBUTES (base)))
- return false;
- /* Check alignment. */
- if (TYPE_ALIGN (cand) == TYPE_ALIGN (base)
- && TYPE_USER_ALIGN (cand) == TYPE_USER_ALIGN (base))
- return true;
- /* Atomic types increase minimal alignment. We must to do so as well
- or we get duplicated canonical types. See PR88686. */
- if ((TYPE_QUALS (cand) & TYPE_QUAL_ATOMIC))
- {
- /* See if this object can map to a basic atomic type. */
- tree atomic_type = find_atomic_core_type (cand);
- if (atomic_type && TYPE_ALIGN (atomic_type) == TYPE_ALIGN (cand))
- return true;
- }
- return false;
-}
-
-/* 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
- && check_base_type (cand, base)
- && check_lang_type (cand, base));
-}
-
-/* Returns true iff CAND is equivalent to BASE with ALIGN. */
-
-static bool
-check_aligned_type (const_tree cand, const_tree base, unsigned int align)
-{
- return (TYPE_QUALS (cand) == TYPE_QUALS (base)
- && TYPE_NAME (cand) == TYPE_NAME (base)
- /* Apparently this is needed for Objective-C. */
- && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
- /* Check alignment. */
- && TYPE_ALIGN (cand) == align
- /* Check this is a user-aligned type as build_aligned_type
- would create. */
- && TYPE_USER_ALIGN (cand)
- && attribute_list_equal (TYPE_ATTRIBUTES (cand),
- TYPE_ATTRIBUTES (base))
- && check_lang_type (cand, base));
-}
-
-/* Return a version of the TYPE, qualified as indicated by the
- TYPE_QUALS, if one exists. If no qualified version exists yet,
- return NULL_TREE. */
-
-tree
-get_qualified_type (tree type, int type_quals)
-{
- if (TYPE_QUALS (type) == type_quals)
- return type;
-
- tree mv = TYPE_MAIN_VARIANT (type);
- if (check_qualified_type (mv, type, type_quals))
- return mv;
-
- /* Search the chain of variants to see if there is already one there just
- like the one we need to have. If so, use that existing one. We must
- preserve the TYPE_NAME, since there is code that depends on this. */
- for (tree *tp = &TYPE_NEXT_VARIANT (mv); *tp; tp = &TYPE_NEXT_VARIANT (*tp))
- if (check_qualified_type (*tp, type, type_quals))
- {
- /* Put the found variant at the head of the variant list so
- frequently searched variants get found faster. The C++ FE
- benefits greatly from this. */
- tree t = *tp;
- *tp = TYPE_NEXT_VARIANT (t);
- TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (mv);
- TYPE_NEXT_VARIANT (mv) = t;
- return t;
- }
-
- return NULL_TREE;
-}
-
-/* Like get_qualified_type, but creates the type if it does not
- exist. This function never returns NULL_TREE. */
-
-tree
-build_qualified_type (tree type, int type_quals MEM_STAT_DECL)
-{
- tree t;
-
- /* See if we already have the appropriate qualified variant. */
- t = get_qualified_type (type, type_quals);
-
- /* If not, build it. */
- if (!t)
- {
- 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. */
- {
- 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;
-
- }
-
- return t;
-}
-
-/* Create a variant of type T with alignment ALIGN. */
-
-tree
-build_aligned_type (tree type, unsigned int align)
-{
- tree t;
-
- if (TYPE_PACKED (type)
- || TYPE_ALIGN (type) == align)
- return type;
-
- for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
- if (check_aligned_type (t, type, align))
- return t;
-
- t = build_variant_type_copy (type);
- SET_TYPE_ALIGN (t, align);
- TYPE_USER_ALIGN (t) = 1;
-
- return t;
-}
-
-/* Create a new distinct copy of TYPE. The new type is made its own
- MAIN_VARIANT. If TYPE requires structural equality checks, the
- resulting type requires structural equality checks; otherwise, its
- TYPE_CANONICAL points to itself. */
-
-tree
-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;
-
- /* Set the canonical type either to a new equivalence class, or
- propagate the need for structural equality checks. */
- if (TYPE_STRUCTURAL_EQUALITY_P (type))
- SET_TYPE_STRUCTURAL_EQUALITY (t);
- else
- TYPE_CANONICAL (t) = t;
-
- /* Make it its own variant. */
- TYPE_MAIN_VARIANT (t) = t;
- TYPE_NEXT_VARIANT (t) = 0;
-
- /* Note that it is now possible for TYPE_MIN_VALUE to be a value
- whose TREE_TYPE is not t. This can also happen in the Ada
- frontend when using subtypes. */
-
- return t;
-}
-
-/* Create a new variant of TYPE, equivalent but distinct. This is so
- the caller can modify it. TYPE_CANONICAL for the return type will
- be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
- are considered equal by the language itself (or that both types
- require structural equality checks). */
-
-tree
-build_variant_type_copy (tree type MEM_STAT_DECL)
-{
- tree t, m = TYPE_MAIN_VARIANT (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);
- TYPE_NEXT_VARIANT (m) = t;
- TYPE_MAIN_VARIANT (t) = m;
-
- return t;
-}
-\f
-/* Return true if the from tree in both tree maps are equal. */
-
-int
-tree_map_base_eq (const void *va, const void *vb)
-{
- const struct tree_map_base *const a = (const struct tree_map_base *) va,
- *const b = (const struct tree_map_base *) vb;
- return (a->from == b->from);
-}
-
-/* Hash a from tree in a tree_base_map. */
-
-unsigned int
-tree_map_base_hash (const void *item)
-{
- return htab_hash_pointer (((const struct tree_map_base *)item)->from);
-}
-
-/* Return true if this tree map structure is marked for garbage collection
- purposes. We simply return true if the from tree is marked, so that this
- structure goes away when the from tree goes away. */
-
-int
-tree_map_base_marked_p (const void *p)
-{
- return ggc_marked_p (((const struct tree_map_base *) p)->from);
-}
-
-/* Hash a from tree in a tree_map. */
-
-unsigned int
-tree_map_hash (const void *item)
-{
- return (((const struct tree_map *) item)->hash);
-}
-
-/* Hash a from tree in a tree_decl_map. */
-
-unsigned int
-tree_decl_map_hash (const void *item)
-{
- return DECL_UID (((const struct tree_decl_map *) item)->base.from);
-}
-
-/* Return the initialization priority for DECL. */
-
-priority_type
-decl_init_priority_lookup (tree decl)
-{
- symtab_node *snode = symtab_node::get (decl);
-
- if (!snode)
- return DEFAULT_INIT_PRIORITY;
- return
- snode->get_init_priority ();
-}
-
-/* Return the finalization priority for DECL. */
-
-priority_type
-decl_fini_priority_lookup (tree decl)
-{
- 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. */
-
-void
-decl_init_priority_insert (tree decl, priority_type 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. */
-
-void
-decl_fini_priority_insert (tree decl, priority_type 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. */
-
-static void
-print_debug_expr_statistics (void)
-{
- fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n",
- (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. */
-
-static void
-print_value_expr_statistics (void)
-{
- fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n",
- (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. */
-
-tree
-decl_debug_expr_lookup (tree from)
-{
- struct tree_decl_map *h, in;
- in.base.from = from;
-
- h = debug_expr_for_decl->find_with_hash (&in, DECL_UID (from));
- if (h)
- return h->to;
- return NULL_TREE;
-}
-
-/* Insert a mapping FROM->TO in the debug expression hashtable. */
-
-void
-decl_debug_expr_insert (tree from, tree to)
-{
- struct tree_decl_map *h;
-
- h = ggc_alloc<tree_decl_map> ();
- h->base.from = from;
- h->to = to;
- *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. */
-
-tree
-decl_value_expr_lookup (tree from)
-{
- struct tree_decl_map *h, in;
- in.base.from = from;
-
- h = value_expr_for_decl->find_with_hash (&in, DECL_UID (from));
- if (h)
- return h->to;
- return NULL_TREE;
-}
-
-/* Insert a mapping FROM->TO in the value expression hashtable. */
-
-void
-decl_value_expr_insert (tree from, tree to)
-{
- struct tree_decl_map *h;
-
- h = ggc_alloc<tree_decl_map> ();
- h->base.from = from;
- h->to = to;
- *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'. */
-
-/* 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:
- hstate.add_poly_int (TYPE_VECTOR_SUBPARTS (type));
- break;
-
- default:
- break;
- }
-
- return hstate.end ();
-}
-
-/* These are the Hashtable callback functions. */
-
-/* Returns true iff the types are equivalent. */
-
-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)
- || TREE_TYPE (a->type) != TREE_TYPE (b->type)
- || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
- TYPE_ATTRIBUTES (b->type))
- || (TREE_CODE (a->type) != COMPLEX_TYPE
- && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
- return 0;
-
- /* Be careful about comparing arrays before and after the element type
- has been completed; don't compare TYPE_ALIGN unless both types are
- complete. */
- if (COMPLETE_TYPE_P (a->type) && COMPLETE_TYPE_P (b->type)
- && (TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
- || TYPE_MODE (a->type) != TYPE_MODE (b->type)))
- return 0;
-
- switch (TREE_CODE (a->type))
- {
- case VOID_TYPE:
- case OPAQUE_TYPE:
- case COMPLEX_TYPE:
- case POINTER_TYPE:
- case REFERENCE_TYPE:
- case NULLPTR_TYPE:
- return 1;
-
- case VECTOR_TYPE:
- return known_eq (TYPE_VECTOR_SUBPARTS (a->type),
- TYPE_VECTOR_SUBPARTS (b->type));
-
- case ENUMERAL_TYPE:
- if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
- && !(TYPE_VALUES (a->type)
- && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
- && TYPE_VALUES (b->type)
- && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
- && type_list_equal (TYPE_VALUES (a->type),
- TYPE_VALUES (b->type))))
- return 0;
-
- /* 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)))
- && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
- || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
- TYPE_MIN_VALUE (b->type))));
-
- case FIXED_POINT_TYPE:
- return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
-
- case OFFSET_TYPE:
- return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
-
- case METHOD_TYPE:
- if (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
- && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
- || (TYPE_ARG_TYPES (a->type)
- && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
- && TYPE_ARG_TYPES (b->type)
- && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
- && type_list_equal (TYPE_ARG_TYPES (a->type),
- TYPE_ARG_TYPES (b->type)))))
- break;
- return 0;
- case ARRAY_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:
- case QUAL_UNION_TYPE:
- return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
- || (TYPE_FIELDS (a->type)
- && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
- && TYPE_FIELDS (b->type)
- && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
- && type_list_equal (TYPE_FIELDS (a->type),
- TYPE_FIELDS (b->type))));
-
- case FUNCTION_TYPE:
- if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
- || (TYPE_ARG_TYPES (a->type)
- && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
- && TYPE_ARG_TYPES (b->type)
- && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
- && type_list_equal (TYPE_ARG_TYPES (a->type),
- TYPE_ARG_TYPES (b->type))))
- break;
- return 0;
-
- default:
- return 0;
- }
-
- if (lang_hooks.types.type_hash_eq != NULL)
- return lang_hooks.types.type_hash_eq (a->type, b->type);
-
- return 1;
-}
-
-/* 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.
-
- To use this function, first create a type of the sort you want.
- Then compute its hash code from the fields of the type that
- make it different from other similar types.
- Then call this function and use the value. */
-
-tree
-type_hash_canon (unsigned int hashcode, tree type)
-{
- 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);
-
- /* 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
- && t1 != type);
- 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)
- {
- /* Zero is always in TYPE_CACHED_VALUES. */
- if (! TYPE_UNSIGNED (type))
- int_cst_hash_table->remove_elt (TYPE_MIN_VALUE (type));
- ggc_free (TYPE_MIN_VALUE (type));
- }
- if (TYPE_MAX_VALUE (type)
- && TREE_TYPE (TYPE_MAX_VALUE (type)) == type)
- {
- int_cst_hash_table->remove_elt (TYPE_MAX_VALUE (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
- {
- struct type_hash *h;
-
- h = ggc_alloc<type_hash> ();
- h->hash = hashcode;
- h->type = type;
- *loc = h;
-
- return type;
- }
-}
-
-static void
-print_type_hash_statistics (void)
-{
- fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
- (long) type_hash_table->size (),
- (long) type_hash_table->elements (),
- type_hash_table->collisions ());
-}
-
-/* Given two lists of types
- (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
- return 1 if the lists contain the same types in the same order.
- Also, the TREE_PURPOSEs must match. */
-
-bool
-type_list_equal (const_tree l1, const_tree l2)
-{
- const_tree t1, t2;
-
- for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
- if (TREE_VALUE (t1) != TREE_VALUE (t2)
- || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
- && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
- && (TREE_TYPE (TREE_PURPOSE (t1))
- == TREE_TYPE (TREE_PURPOSE (t2))))))
- return false;
-
- return t1 == t2;
-}
-
-/* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
- given by TYPE. If the argument list accepts variable arguments,
- then this function counts only the ordinary arguments. */
-
-int
-type_num_arguments (const_tree fntype)
-{
- int i = 0;
-
- for (tree t = TYPE_ARG_TYPES (fntype); t; t = TREE_CHAIN (t))
- /* If the function does not take a variable number of arguments,
- the last element in the list will have type `void'. */
- if (VOID_TYPE_P (TREE_VALUE (t)))
- break;
- else
- ++i;
-
- return i;
-}
-
-/* Return the type of the function TYPE's argument ARGNO if known.
- For vararg function's where ARGNO refers to one of the variadic
- arguments return null. Otherwise, return a void_type_node for
- out-of-bounds ARGNO. */
-
-tree
-type_argument_type (const_tree fntype, unsigned argno)
-{
- /* Treat zero the same as an out-of-bounds argument number. */
- if (!argno)
- return void_type_node;
-
- function_args_iterator iter;
-
- tree argtype;
- unsigned i = 1;
- FOREACH_FUNCTION_ARGS (fntype, argtype, iter)
- {
- /* A vararg function's argument list ends in a null. Otherwise,
- an ordinary function's argument list ends with void. Return
- null if ARGNO refers to a vararg argument, void_type_node if
- it's out of bounds, and the formal argument type otherwise. */
- if (!argtype)
- break;
-
- if (i == argno || VOID_TYPE_P (argtype))
- return argtype;
-
- ++i;
- }
-
- return NULL_TREE;
-}
-
-/* Nonzero if integer constants T1 and T2
- represent the same constant value. */
-
-int
-tree_int_cst_equal (const_tree t1, const_tree t2)
-{
- if (t1 == t2)
- return 1;
-
- if (t1 == 0 || t2 == 0)
- return 0;
-
- STRIP_ANY_LOCATION_WRAPPER (t1);
- STRIP_ANY_LOCATION_WRAPPER (t2);
-
- if (TREE_CODE (t1) == INTEGER_CST
- && TREE_CODE (t2) == INTEGER_CST
- && wi::to_widest (t1) == wi::to_widest (t2))
- return 1;
-
- return 0;
-}
-
-/* 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 or POLY_INT_CST whose numerical
- value (extended according to TYPE_UNSIGNED) fits in a poly_int64. */
-
-bool
-tree_fits_poly_int64_p (const_tree t)
-{
- if (t == NULL_TREE)
- return false;
- if (POLY_INT_CST_P (t))
- {
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; i++)
- if (!wi::fits_shwi_p (wi::to_wide (POLY_INT_CST_COEFF (t, i))))
- return false;
- return true;
- }
- return (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)));
-}
-
-/* Return true if T is an INTEGER_CST or POLY_INT_CST whose numerical
- value (extended according to TYPE_UNSIGNED) fits in a poly_uint64. */
-
-bool
-tree_fits_poly_uint64_p (const_tree t)
-{
- if (t == NULL_TREE)
- return false;
- if (POLY_INT_CST_P (t))
- {
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; i++)
- if (!wi::fits_uhwi_p (wi::to_widest (POLY_INT_CST_COEFF (t, i))))
- return false;
- return true;
- }
- return (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_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.
- The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
- Note that -1 will never be returned if T's type is unsigned. */
-
-int
-tree_int_cst_sgn (const_tree t)
-{
- if (wi::to_wide (t) == 0)
- return 0;
- else if (TYPE_UNSIGNED (TREE_TYPE (t)))
- return 1;
- else if (wi::neg_p (wi::to_wide (t)))
- return -1;
- else
- return 1;
-}
-
-/* Return the minimum number of bits needed to represent VALUE in a
- signed or unsigned type, UNSIGNEDP says which. */
-
-unsigned int
-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
- a bit-wise negation, so use that operation instead. */
-
- if (tree_int_cst_sgn (value) < 0)
- 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.
- If value is 0 or -1, the minimum precision is 1 no matter
- whether unsignedp is true or false. */
-
- if (integer_zerop (value))
- return 1;
- else
- return tree_floor_log2 (value) + 1 + (sgn == SIGNED ? 1 : 0) ;
-}
-
-/* Return truthvalue of whether T1 is the same tree structure as T2.
- Return 1 if they are the same.
- Return 0 if they are understandably different.
- Return -1 if either contains tree structure not understood by
- this function. */
-
-int
-simple_cst_equal (const_tree t1, const_tree t2)
-{
- enum tree_code code1, code2;
- int cmp;
- int i;
-
- if (t1 == t2)
- return 1;
- if (t1 == 0 || t2 == 0)
- return 0;
-
- /* For location wrappers to be the same, they must be at the same
- source location (and wrap the same thing). */
- if (location_wrapper_p (t1) && location_wrapper_p (t2))
- {
- if (EXPR_LOCATION (t1) != EXPR_LOCATION (t2))
- return 0;
- return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
- }
-
- code1 = TREE_CODE (t1);
- code2 = TREE_CODE (t2);
-
- if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
- {
- if (CONVERT_EXPR_CODE_P (code2)
- || code2 == NON_LVALUE_EXPR)
- return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
- else
- return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
- }
-
- else if (CONVERT_EXPR_CODE_P (code2)
- || code2 == NON_LVALUE_EXPR)
- return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
-
- if (code1 != code2)
- return 0;
-
- switch (code1)
- {
- case INTEGER_CST:
- return wi::to_widest (t1) == wi::to_widest (t2);
-
- case REAL_CST:
- 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));
-
- case STRING_CST:
- return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
- && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
- TREE_STRING_LENGTH (t1)));
-
- case CONSTRUCTOR:
- {
- unsigned HOST_WIDE_INT idx;
- 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_safe_length (v1); ++idx)
- /* ??? Should we handle also fields here? */
- if (!simple_cst_equal ((*v1)[idx].value, (*v2)[idx].value))
- return false;
- return true;
- }
-
- case SAVE_EXPR:
- return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
-
- case CALL_EXPR:
- cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
- if (cmp <= 0)
- return cmp;
- if (call_expr_nargs (t1) != call_expr_nargs (t2))
- return 0;
- {
- const_tree arg1, arg2;
- const_call_expr_arg_iterator iter1, iter2;
- for (arg1 = first_const_call_expr_arg (t1, &iter1),
- arg2 = first_const_call_expr_arg (t2, &iter2);
- arg1 && arg2;
- arg1 = next_const_call_expr_arg (&iter1),
- arg2 = next_const_call_expr_arg (&iter2))
- {
- cmp = simple_cst_equal (arg1, arg2);
- if (cmp <= 0)
- return cmp;
- }
- return arg1 == arg2;
- }
-
- case TARGET_EXPR:
- /* Special case: if either target is an unallocated VAR_DECL,
- it means that it's going to be unified with whatever the
- TARGET_EXPR is really supposed to initialize, so treat it
- as being equivalent to anything. */
- if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
- && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
- && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
- || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
- && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
- && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
- cmp = 1;
- else
- cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
-
- if (cmp <= 0)
- return cmp;
-
- return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
-
- case WITH_CLEANUP_EXPR:
- cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
- if (cmp <= 0)
- return cmp;
-
- return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
-
- case COMPONENT_REF:
- if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
- return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
-
- return 0;
-
- case VAR_DECL:
- case PARM_DECL:
- case CONST_DECL:
- case FUNCTION_DECL:
- return 0;
-
- default:
- if (POLY_INT_CST_P (t1))
- /* A false return means maybe_ne rather than known_ne. */
- return known_eq (poly_widest_int::from (poly_int_cst_value (t1),
- TYPE_SIGN (TREE_TYPE (t1))),
- poly_widest_int::from (poly_int_cst_value (t2),
- TYPE_SIGN (TREE_TYPE (t2))));
- break;
- }
-
- /* This general rule works for most tree codes. All exceptions should be
- handled above. If this is a language-specific tree code, we can't
- trust what might be in the operand, so say we don't know
- the situation. */
- if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
- return -1;
-
- switch (TREE_CODE_CLASS (code1))
- {
- case tcc_unary:
- case tcc_binary:
- case tcc_comparison:
- case tcc_expression:
- case tcc_reference:
- case tcc_statement:
- cmp = 1;
- for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
- {
- cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
- if (cmp <= 0)
- return cmp;
- }
-
- return cmp;
-
- default:
- return -1;
- }
-}
-
-/* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
- Return -1, 0, or 1 if the value of T is less than, equal to, or greater
- than U, respectively. */
-
-int
-compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
-{
- if (tree_int_cst_sgn (t) < 0)
- return -1;
- else if (!tree_fits_uhwi_p (t))
- return 1;
- else if (TREE_INT_CST_LOW (t) == u)
- return 0;
- else if (TREE_INT_CST_LOW (t) < u)
- return -1;
- else
- 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).
- When PERR is non-null, set *PERR on failure to the description of
- why SIZE is not valid. */
-
-bool
-valid_constant_size_p (const_tree size, cst_size_error *perr /* = NULL */)
-{
- if (POLY_INT_CST_P (size))
- {
- if (TREE_OVERFLOW (size))
- return false;
- for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
- if (!valid_constant_size_p (POLY_INT_CST_COEFF (size, i)))
- return false;
- return true;
- }
-
- cst_size_error error;
- if (!perr)
- perr = &error;
-
- if (TREE_CODE (size) != INTEGER_CST)
- {
- *perr = cst_size_not_constant;
- return false;
- }
-
- if (TREE_OVERFLOW_P (size))
- {
- *perr = cst_size_overflow;
- return false;
- }
-
- if (tree_int_cst_sgn (size) < 0)
- {
- *perr = cst_size_negative;
- return false;
- }
- if (!tree_fits_uhwi_p (size)
- || (wi::to_widest (TYPE_MAX_VALUE (sizetype))
- < wi::to_widest (size) * 2))
- {
- *perr = cst_size_too_big;
- 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
-associative_tree_code (enum tree_code code)
-{
- switch (code)
- {
- case BIT_IOR_EXPR:
- case BIT_AND_EXPR:
- case BIT_XOR_EXPR:
- case PLUS_EXPR:
- case MULT_EXPR:
- case MIN_EXPR:
- case MAX_EXPR:
- return true;
-
- default:
- break;
- }
- return false;
-}
-
-/* Return true if CODE represents a commutative tree code. Otherwise
- return false. */
-bool
-commutative_tree_code (enum tree_code code)
-{
- switch (code)
- {
- case PLUS_EXPR:
- case MULT_EXPR:
- case MULT_HIGHPART_EXPR:
- case MIN_EXPR:
- case MAX_EXPR:
- case BIT_IOR_EXPR:
- case BIT_XOR_EXPR:
- case BIT_AND_EXPR:
- case NE_EXPR:
- case EQ_EXPR:
- case UNORDERED_EXPR:
- case ORDERED_EXPR:
- case UNEQ_EXPR:
- case LTGT_EXPR:
- 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:
- break;
- }
- return false;
-}
-
-/* Return true if CODE represents a ternary tree code for which the
- first two operands are commutative. Otherwise return false. */
-bool
-commutative_ternary_tree_code (enum tree_code code)
-{
- switch (code)
- {
- case WIDEN_MULT_PLUS_EXPR:
- case WIDEN_MULT_MINUS_EXPR:
- case DOT_PROD_EXPR:
- return true;
-
- default:
- break;
- }
- 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;
- }
-}
-
-/* Constructors for pointer, array and function types.
- (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
- constructed by language-dependent code, not here.) */
-
-/* Construct, lay out and return the type of pointers to TO_TYPE with
- mode MODE. If MODE is VOIDmode, a pointer mode for the address
- space of TO_TYPE will be picked. If CAN_ALIAS_ALL is TRUE,
- indicate this type can reference all of memory. If such a type has
- already been constructed, reuse it. */
-
-tree
-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;
-
- if (mode == VOIDmode)
- {
- addr_space_t as = TYPE_ADDR_SPACE (to_type);
- mode = targetm.addr_space.pointer_mode (as);
- }
-
- /* If the pointed-to type has the may_alias attribute set, force
- a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
- if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
- can_alias_all = true;
-
- /* In some cases, languages will have things that aren't a POINTER_TYPE
- (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
- In that case, return that type without regard to the rest of our
- operands.
-
- ??? This is a kludge, but consistent with the way this function has
- always operated and there doesn't seem to be a good way to avoid this
- at the moment. */
- if (TYPE_POINTER_TO (to_type) != 0
- && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
- return TYPE_POINTER_TO (to_type);
-
- /* First, if we already have a type for pointers to TO_TYPE and it's
- the proper mode, use it. */
- for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
- if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
- return t;
-
- t = make_node (POINTER_TYPE);
-
- TREE_TYPE (t) = to_type;
- SET_TYPE_MODE (t, mode);
- TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
- TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
- TYPE_POINTER_TO (to_type) = t;
-
- /* 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 || could_alias)
- TYPE_CANONICAL (t)
- = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
- mode, false);
-
- /* Lay out the type. This function has many callers that are concerned
- with expression-construction, and this simplifies them all. */
- layout_type (t);
-
- return t;
-}
-
-/* By default build pointers in ptr_mode. */
-
-tree
-build_pointer_type (tree to_type)
-{
- return build_pointer_type_for_mode (to_type, VOIDmode, false);
-}
-
-/* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */
-
-tree
-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;
-
- if (mode == VOIDmode)
- {
- addr_space_t as = TYPE_ADDR_SPACE (to_type);
- mode = targetm.addr_space.pointer_mode (as);
- }
-
- /* If the pointed-to type has the may_alias attribute set, force
- a TYPE_REF_CAN_ALIAS_ALL pointer to be generated. */
- if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
- can_alias_all = true;
-
- /* In some cases, languages will have things that aren't a REFERENCE_TYPE
- (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
- In that case, return that type without regard to the rest of our
- operands.
-
- ??? This is a kludge, but consistent with the way this function has
- always operated and there doesn't seem to be a good way to avoid this
- at the moment. */
- if (TYPE_REFERENCE_TO (to_type) != 0
- && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
- return TYPE_REFERENCE_TO (to_type);
-
- /* First, if we already have a type for pointers to TO_TYPE and it's
- the proper mode, use it. */
- for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
- if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
- return t;
-
- t = make_node (REFERENCE_TYPE);
-
- TREE_TYPE (t) = to_type;
- SET_TYPE_MODE (t, mode);
- TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
- TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
- TYPE_REFERENCE_TO (to_type) = t;
-
- /* 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 || could_alias)
- TYPE_CANONICAL (t)
- = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
- mode, false);
-
- layout_type (t);
-
- return t;
-}
-
-
-/* Build the node for the type of references-to-TO_TYPE by default
- in ptr_mode. */
-
-tree
-build_reference_type (tree to_type)
-{
- return build_reference_type_for_mode (to_type, VOIDmode, false);
-}
-
-#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];
-
-/* Builds a signed or unsigned integer type of precision PRECISION.
- Used for C bitfields whose precision does not match that of
- built-in target types. */
-tree
-build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
- int unsignedp)
-{
- tree itype, ret;
-
- if (unsignedp)
- unsignedp = MAX_INT_CACHED_PREC + 1;
-
- if (precision <= MAX_INT_CACHED_PREC)
- {
- itype = nonstandard_integer_type_cache[precision + unsignedp];
- if (itype)
- return itype;
- }
-
- itype = make_node (INTEGER_TYPE);
- TYPE_PRECISION (itype) = precision;
-
- if (unsignedp)
- fixup_unsigned_type (itype);
- else
- fixup_signed_type (itype);
-
- inchash::hash hstate;
- inchash::add_expr (TYPE_MAX_VALUE (itype), hstate);
- ret = type_hash_canon (hstate.end (), 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. */
-
-static tree
-build_range_type_1 (tree type, tree lowval, tree highval, bool shared)
-{
- tree itype = make_node (INTEGER_TYPE);
-
- TREE_TYPE (itype) = type;
-
- TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
- TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
-
- TYPE_PRECISION (itype) = TYPE_PRECISION (type);
- SET_TYPE_MODE (itype, TYPE_MODE (type));
- TYPE_SIZE (itype) = TYPE_SIZE (type);
- TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (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;
-
- if ((TYPE_MIN_VALUE (itype)
- && TREE_CODE (TYPE_MIN_VALUE (itype)) != INTEGER_CST)
- || (TYPE_MAX_VALUE (itype)
- && TREE_CODE (TYPE_MAX_VALUE (itype)) != INTEGER_CST))
- {
- /* Since we cannot reliably merge this type, we need to compare it using
- structural equality checks. */
- SET_TYPE_STRUCTURAL_EQUALITY (itype);
- return itype;
- }
-
- hashval_t hash = type_hash_canon_hash (itype);
- itype = type_hash_canon (hash, itype);
-
- return itype;
-}
-
-/* Wrapper around build_range_type_1 with SHARED set to true. */
-
-tree
-build_range_type (tree type, tree lowval, tree highval)
-{
- return build_range_type_1 (type, lowval, highval, true);
-}
-
-/* Wrapper around build_range_type_1 with SHARED set to false. */
-
-tree
-build_nonshared_range_type (tree type, tree lowval, tree highval)
-{
- return build_range_type_1 (type, lowval, highval, false);
-}
-
-/* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
- MAXVAL should be the maximum value in the domain
- (one less than the length of the array).
-
- The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
- We don't enforce this limit, that is up to caller (e.g. language front end).
- The limit exists because the result is a signed type and we don't handle
- sizes that use more than one HOST_WIDE_INT. */
-
-tree
-build_index_type (tree maxval)
-{
- return build_range_type (sizetype, size_zero_node, maxval);
-}
-
-/* Return true if the debug information for TYPE, a subtype, should be emitted
- as a subrange type. If so, set LOWVAL to the low bound and HIGHVAL to the
- high bound, respectively. Sometimes doing so unnecessarily obfuscates the
- debug info and doesn't reflect the source code. */
-
-bool
-subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
-{
- tree base_type = TREE_TYPE (type), low, high;
-
- /* Subrange types have a base type which is an integral type. */
- if (!INTEGRAL_TYPE_P (base_type))
- return false;
-
- /* Get the real bounds of the subtype. */
- if (lang_hooks.types.get_subrange_bounds)
- lang_hooks.types.get_subrange_bounds (type, &low, &high);
- else
- {
- low = TYPE_MIN_VALUE (type);
- high = TYPE_MAX_VALUE (type);
- }
-
- /* If the type and its base type have the same representation and the same
- name, then the type is not a subrange but a copy of the base type. */
- if ((TREE_CODE (base_type) == INTEGER_TYPE
- || 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))
- && TYPE_IDENTIFIER (type) == TYPE_IDENTIFIER (base_type))
- return false;
-
- if (lowval)
- *lowval = low;
- if (highval)
- *highval = high;
- return true;
-}
-
-/* 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.
- If SET_CANONICAL is true, compute TYPE_CANONICAL from the element type. */
-
-tree
-build_array_type_1 (tree elt_type, tree index_type, bool typeless_storage,
- bool shared, bool set_canonical)
-{
- tree t;
-
- if (TREE_CODE (elt_type) == FUNCTION_TYPE)
- {
- error ("arrays of functions are not meaningful");
- elt_type = integer_type_node;
- }
-
- t = make_node (ARRAY_TYPE);
- 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 (shared)
- {
- hashval_t hash = type_hash_canon_hash (t);
- t = type_hash_canon (hash, t);
- }
-
- if (TYPE_CANONICAL (t) == t && set_canonical)
- {
- if (TYPE_STRUCTURAL_EQUALITY_P (elt_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))
- TYPE_CANONICAL (t)
- = build_array_type_1 (TYPE_CANONICAL (elt_type),
- index_type
- ? TYPE_CANONICAL (index_type) : NULL_TREE,
- typeless_storage, shared, set_canonical);
- }
-
- return t;
-}
-
-/* Wrapper around build_array_type_1 with SHARED set to true. */
-
-tree
-build_array_type (tree elt_type, tree index_type, bool typeless_storage)
-{
- return
- build_array_type_1 (elt_type, index_type, typeless_storage, true, true);
-}
-
-/* Wrapper around build_array_type_1 with SHARED set to false. */
-
-tree
-build_nonshared_array_type (tree elt_type, tree index_type)
-{
- return build_array_type_1 (elt_type, index_type, false, false, true);
-}
-
-/* Return a representation of ELT_TYPE[NELTS], using indices of type
- sizetype. */
-
-tree
-build_array_type_nelts (tree elt_type, poly_uint64 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
- element type is found. */
-
-tree
-strip_array_types (tree type)
-{
- while (TREE_CODE (type) == ARRAY_TYPE)
- type = TREE_TYPE (type);
-
- return type;
-}
-
-/* Computes the canonical argument types from the argument type list
- ARGTYPES.
-
- Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
- on entry to this function, or if any of the ARGTYPES are
- structural.
-
- Upon return, *ANY_NONCANONICAL_P will be true iff either it was
- true on entry to this function, or if any of the ARGTYPES are
- non-canonical.
-
- Returns a canonical argument list, which may be ARGTYPES when the
- canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
- true) or would not differ from ARGTYPES. */
-
-static tree
-maybe_canonicalize_argtypes (tree argtypes,
- bool *any_structural_p,
- bool *any_noncanonical_p)
-{
- tree arg;
- bool any_noncanonical_argtypes_p = false;
-
- for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
- {
- if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
- /* Fail gracefully by stating that the type is structural. */
- *any_structural_p = true;
- else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
- *any_structural_p = true;
- else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
- || TREE_PURPOSE (arg))
- /* If the argument has a default argument, we consider it
- non-canonical even though the type itself is canonical.
- That way, different variants of function and method types
- with default arguments will all point to the variant with
- no defaults as their canonical type. */
- any_noncanonical_argtypes_p = true;
- }
-
- if (*any_structural_p)
- return argtypes;
-
- if (any_noncanonical_argtypes_p)
- {
- /* Build the canonical list of argument types. */
- tree canon_argtypes = NULL_TREE;
- bool is_void = false;
-
- for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
- {
- if (arg == void_list_node)
- is_void = true;
- else
- canon_argtypes = tree_cons (NULL_TREE,
- TYPE_CANONICAL (TREE_VALUE (arg)),
- canon_argtypes);
- }
-
- canon_argtypes = nreverse (canon_argtypes);
- if (is_void)
- canon_argtypes = chainon (canon_argtypes, void_list_node);
-
- /* There is a non-canonical type. */
- *any_noncanonical_p = true;
- return canon_argtypes;
- }
-
- /* The canonical argument types are the same as ARGTYPES. */
- return argtypes;
-}
-
-/* Construct, lay out and return
- the type of functions returning type VALUE_TYPE
- given arguments of types ARG_TYPES.
- ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
- are data type nodes for the arguments of the function.
- If such a type has already been constructed, reuse it. */
-
-tree
-build_function_type (tree value_type, tree arg_types)
-{
- tree t;
- inchash::hash hstate;
- bool any_structural_p, any_noncanonical_p;
- tree canon_argtypes;
-
- gcc_assert (arg_types != error_mark_node);
-
- if (TREE_CODE (value_type) == FUNCTION_TYPE)
- {
- error ("function return type cannot be function");
- value_type = integer_type_node;
- }
-
- /* Make a node of the sort we want. */
- t = make_node (FUNCTION_TYPE);
- TREE_TYPE (t) = value_type;
- TYPE_ARG_TYPES (t) = arg_types;
-
- /* If we already have such a type, use the old one. */
- 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);
- any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
- canon_argtypes = maybe_canonicalize_argtypes (arg_types,
- &any_structural_p,
- &any_noncanonical_p);
- if (any_structural_p)
- SET_TYPE_STRUCTURAL_EQUALITY (t);
- else if (any_noncanonical_p)
- TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
- canon_argtypes);
-
- if (!COMPLETE_TYPE_P (t))
- layout_type (t);
- return t;
-}
-
-/* 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
- 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)
-{
- tree t, args, last;
-
- t = va_arg (argp, tree);
- for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
- args = tree_cons (NULL_TREE, t, args);
-
- if (vaargs)
- {
- last = args;
- if (args != NULL_TREE)
- args = nreverse (args);
- gcc_assert (last != void_list_node);
- }
- else if (args == NULL_TREE)
- args = void_list_node;
- else
- {
- last = args;
- args = nreverse (args);
- TREE_CHAIN (last) = void_list_node;
- }
- args = build_function_type (return_type, args);
-
- return args;
-}
-
-/* Build a function type. The RETURN_TYPE is the type returned by the
- function. If additional arguments are provided, they are
- additional argument types. The list of argument types must always
- be terminated by NULL_TREE. */
-
-tree
-build_function_type_list (tree return_type, ...)
-{
- tree args;
- va_list p;
-
- va_start (p, return_type);
- args = build_function_type_list_1 (false, return_type, p);
- va_end (p);
- return args;
-}
-
-/* Build a variable argument function type. The RETURN_TYPE is the
- type returned by the function. If additional arguments are provided,
- they are additional argument types. The list of argument types must
- always be terminated by NULL_TREE. */
-
-tree
-build_varargs_function_type_list (tree return_type, ...)
-{
- tree args;
- va_list p;
-
- va_start (p, return_type);
- args = build_function_type_list_1 (true, return_type, p);
- va_end (p);
-
- 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
- pointer-to-BASETYPE) is added to the ARGTYPES. */
-
-tree
-build_method_type_directly (tree basetype,
- tree rettype,
- tree argtypes)
-{
- tree t;
- tree ptype;
- bool any_structural_p, any_noncanonical_p;
- tree canon_argtypes;
-
- /* Make a node of the sort we want. */
- t = make_node (METHOD_TYPE);
-
- TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
- TREE_TYPE (t) = rettype;
- ptype = build_pointer_type (basetype);
-
- /* The actual arglist for this function includes a "hidden" argument
- which is "this". Put it into the list of argument types. */
- argtypes = tree_cons (NULL_TREE, ptype, argtypes);
- TYPE_ARG_TYPES (t) = argtypes;
-
- /* If we already have such a type, use the old one. */
- 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 (basetype)
- || TYPE_STRUCTURAL_EQUALITY_P (rettype));
- any_noncanonical_p
- = (TYPE_CANONICAL (basetype) != basetype
- || TYPE_CANONICAL (rettype) != rettype);
- canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
- &any_structural_p,
- &any_noncanonical_p);
- if (any_structural_p)
- SET_TYPE_STRUCTURAL_EQUALITY (t);
- else if (any_noncanonical_p)
- TYPE_CANONICAL (t)
- = build_method_type_directly (TYPE_CANONICAL (basetype),
- TYPE_CANONICAL (rettype),
- canon_argtypes);
- if (!COMPLETE_TYPE_P (t))
- layout_type (t);
-
- return t;
-}
-
-/* Construct, lay out and return the type of methods belonging to class
- BASETYPE and whose arguments and values are described by TYPE.
- If that type exists already, reuse it.
- TYPE must be a FUNCTION_TYPE node. */
-
-tree
-build_method_type (tree basetype, tree type)
-{
- gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
-
- return build_method_type_directly (basetype,
- TREE_TYPE (type),
- TYPE_ARG_TYPES (type));
-}
-
-/* Construct, lay out and return the type of offsets to a value
- of type TYPE, within an object of type BASETYPE.
- If a suitable offset type exists already, reuse it. */
-
-tree
-build_offset_type (tree basetype, tree type)
-{
- tree t;
-
- /* Make a node of the sort we want. */
- t = make_node (OFFSET_TYPE);
-
- TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
- TREE_TYPE (t) = type;
-
- /* If we already have such a type, use the old one. */
- hashval_t hash = type_hash_canon_hash (t);
- t = type_hash_canon (hash, t);
-
- if (!COMPLETE_TYPE_P (t))
- layout_type (t);
-
- if (TYPE_CANONICAL (t) == t)
- {
- if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
- || TYPE_STRUCTURAL_EQUALITY_P (type))
- SET_TYPE_STRUCTURAL_EQUALITY (t);
- else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
- || TYPE_CANONICAL (type) != type)
- TYPE_CANONICAL (t)
- = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
- TYPE_CANONICAL (type));
- }
-
- return t;
-}
-
-/* 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)
-{
- gcc_assert (INTEGRAL_TYPE_P (component_type)
- || SCALAR_FLOAT_TYPE_P (component_type)
- || FIXED_POINT_TYPE_P (component_type));
-
- /* Make a node of the sort we want. */
- tree probe = make_node (COMPLEX_TYPE);
-
- TREE_TYPE (probe) = TYPE_MAIN_VARIANT (component_type);
-
- /* If we already have such a type, use the old one. */
- hashval_t hash = type_hash_canon_hash (probe);
- tree t = type_hash_canon (hash, probe);
-
- if (t == probe)
- {
- /* We created a new type. The hash insertion will have laid
- out the type. We need to check the canonicalization and
- maybe set the name. */
- gcc_checking_assert (COMPLETE_TYPE_P (t)
- && !TYPE_NAME (t)
- && TYPE_CANONICAL (t) == t);
-
- if (TYPE_STRUCTURAL_EQUALITY_P (TREE_TYPE (t)))
- SET_TYPE_STRUCTURAL_EQUALITY (t);
- else if (TYPE_CANONICAL (TREE_TYPE (t)) != TREE_TYPE (t))
- TYPE_CANONICAL (t)
- = build_complex_type (TYPE_CANONICAL (TREE_TYPE (t)), named);
-
- /* We need to create a name, since complex is a fundamental type. */
- if (named)
- {
- const char *name = NULL;
-
- if (TREE_TYPE (t) == char_type_node)
- name = "complex char";
- else if (TREE_TYPE (t) == signed_char_type_node)
- name = "complex signed char";
- else if (TREE_TYPE (t) == unsigned_char_type_node)
- name = "complex unsigned char";
- else if (TREE_TYPE (t) == short_integer_type_node)
- name = "complex short int";
- else if (TREE_TYPE (t) == short_unsigned_type_node)
- name = "complex short unsigned int";
- else if (TREE_TYPE (t) == integer_type_node)
- name = "complex int";
- else if (TREE_TYPE (t) == unsigned_type_node)
- name = "complex unsigned int";
- else if (TREE_TYPE (t) == long_integer_type_node)
- name = "complex long int";
- else if (TREE_TYPE (t) == long_unsigned_type_node)
- name = "complex long unsigned int";
- else if (TREE_TYPE (t) == long_long_integer_type_node)
- name = "complex long long int";
- else if (TREE_TYPE (t) == long_long_unsigned_type_node)
- name = "complex long long unsigned int";
-
- if (name != NULL)
- TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
- get_identifier (name), t);
- }
- }
-
- return build_qualified_type (t, TYPE_QUALS (component_type));
-}
-
-/* If TYPE is a real or complex floating-point type and the target
- does not directly support arithmetic on TYPE then return the wider
- type to be used for arithmetic on TYPE. Otherwise, return
- NULL_TREE. */
-
-tree
-excess_precision_type (tree type)
-{
- /* 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;
-}
-\f
-/* Return OP, stripped of any conversions to wider types as much as is safe.
- Converting the value back to OP's type makes a value equivalent to OP.
-
- If FOR_TYPE is nonzero, we return a value which, if converted to
- type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
-
- OP must have integer, real or enumeral type. Pointers are not allowed!
-
- There are some cases where the obvious value we could return
- would regenerate to OP if converted to OP's type,
- but would not extend like OP to wider types.
- If FOR_TYPE indicates such extension is contemplated, we eschew such values.
- For example, if OP is (unsigned short)(signed char)-1,
- we avoid returning (signed char)-1 if FOR_TYPE is int,
- even though extending that to an unsigned short would regenerate OP,
- since the result of extending (signed char)-1 to (int)
- is different from (int) OP. */
-
-tree
-get_unwidened (tree op, tree for_type)
-{
- /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */
- tree type = TREE_TYPE (op);
- unsigned final_prec
- = TYPE_PRECISION (for_type != 0 ? for_type : type);
- int uns
- = (for_type != 0 && for_type != type
- && final_prec > TYPE_PRECISION (type)
- && TYPE_UNSIGNED (type));
- tree win = op;
-
- while (CONVERT_EXPR_P (op))
- {
- int bitschange;
-
- /* TYPE_PRECISION on vector types has different meaning
- (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
- so avoid them here. */
- if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
- break;
-
- bitschange = TYPE_PRECISION (TREE_TYPE (op))
- - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
-
- /* Truncations are many-one so cannot be removed.
- Unless we are later going to truncate down even farther. */
- if (bitschange < 0
- && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
- break;
-
- /* See what's inside this conversion. If we decide to strip it,
- we will set WIN. */
- op = TREE_OPERAND (op, 0);
-
- /* If we have not stripped any zero-extensions (uns is 0),
- we can strip any kind of extension.
- If we have previously stripped a zero-extension,
- only zero-extensions can safely be stripped.
- Any extension can be stripped if the bits it would produce
- are all going to be discarded later by truncating to FOR_TYPE. */
-
- if (bitschange > 0)
- {
- if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
- win = op;
- /* TYPE_UNSIGNED says whether this is a zero-extension.
- Let's avoid computing it if it does not affect WIN
- and if UNS will not be needed again. */
- if ((uns
- || CONVERT_EXPR_P (op))
- && TYPE_UNSIGNED (TREE_TYPE (op)))
- {
- uns = 1;
- win = op;
- }
- }
- }
-
- /* If we finally reach a constant see if it fits in sth smaller and
- in that case convert it. */
- 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;
-}
-\f
-/* Return OP or a simpler expression for a narrower value
- which can be sign-extended or zero-extended to give back OP.
- Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
- or 0 if the value should be sign-extended. */
-
-tree
-get_narrower (tree op, int *unsignedp_ptr)
-{
- int uns = 0;
- int first = 1;
- tree win = op;
- bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
-
- if (TREE_CODE (op) == COMPOUND_EXPR)
- {
- do
- op = TREE_OPERAND (op, 1);
- while (TREE_CODE (op) == COMPOUND_EXPR);
- tree ret = get_narrower (op, unsignedp_ptr);
- if (ret == op)
- return win;
- auto_vec <tree, 16> v;
- unsigned int i;
- for (op = win; TREE_CODE (op) == COMPOUND_EXPR;
- op = TREE_OPERAND (op, 1))
- v.safe_push (op);
- FOR_EACH_VEC_ELT_REVERSE (v, i, op)
- ret = build2_loc (EXPR_LOCATION (op), COMPOUND_EXPR,
- TREE_TYPE (ret), TREE_OPERAND (op, 0),
- ret);
- return ret;
- }
- while (TREE_CODE (op) == NOP_EXPR)
- {
- int bitschange
- = (TYPE_PRECISION (TREE_TYPE (op))
- - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
-
- /* Truncations are many-one so cannot be removed. */
- if (bitschange < 0)
- break;
-
- /* See what's inside this conversion. If we decide to strip it,
- we will set WIN. */
-
- if (bitschange > 0)
- {
- op = TREE_OPERAND (op, 0);
- /* An extension: the outermost one can be stripped,
- but remember whether it is zero or sign extension. */
- if (first)
- uns = TYPE_UNSIGNED (TREE_TYPE (op));
- /* Otherwise, if a sign extension has been stripped,
- only sign extensions can now be stripped;
- if a zero extension has been stripped, only zero-extensions. */
- else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
- break;
- first = 0;
- }
- else /* bitschange == 0 */
- {
- /* A change in nominal type can always be stripped, but we must
- preserve the unsignedness. */
- if (first)
- uns = TYPE_UNSIGNED (TREE_TYPE (op));
- first = 0;
- op = TREE_OPERAND (op, 0);
- /* Keep trying to narrow, but don't assign op to win if it
- would turn an integral type into something else. */
- if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
- continue;
- }
-
- win = op;
- }
-
- if (TREE_CODE (op) == COMPONENT_REF
- /* Since type_for_size always gives an integer type. */
- && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
- && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
- /* Ensure field is laid out already. */
- && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
- && tree_fits_uhwi_p (DECL_SIZE (TREE_OPERAND (op, 1))))
- {
- unsigned HOST_WIDE_INT innerprec
- = 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);
-
- /* We can get this structure field in a narrower type that fits it,
- but the resulting extension to its nominal type (a fullword type)
- must satisfy the same conditions as for other extensions.
-
- Do this only for fields that are aligned (not bit-fields),
- because when bit-field insns will be used there is no
- advantage in doing this. */
-
- if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
- && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
- && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
- && type != 0)
- {
- if (first)
- uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
- win = fold_convert (type, op);
- }
- }
-
- *unsignedp_ptr = uns;
- return win;
-}
-\f
-/* 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;
- 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);
- type_high_bound = TYPE_MAX_VALUE (type);
-
- /* 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
- 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
- for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
- for "constant known to fit". */
-
- /* Check if c >= type_low_bound. */
- if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
- {
- if (tree_int_cst_lt (c, type_low_bound))
- return false;
- ok_for_low_bound = true;
- }
- else
- ok_for_low_bound = false;
-
- /* Check if c <= type_high_bound. */
- if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
- {
- if (tree_int_cst_lt (type_high_bound, c))
- return false;
- ok_for_high_bound = true;
- }
- else
- ok_for_high_bound = false;
-
- /* If the constant fits both bounds, the result is known. */
- if (ok_for_low_bound && ok_for_high_bound)
- return true;
-
- /* 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) && sgn_c == SIGNED && wi::neg_p (wi::to_wide (c)))
- return false;
-
- /* Second, narrower types always fit in wider ones. */
- if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
- return true;
-
- /* Third, unsigned integers with top bit set never fit signed types. */
- 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 (wi::neg_p (wi::to_wide (c)))
- return false;
- }
-
- /* If we haven't been able to decide at this point, there nothing more we
- can check ourselves here. Look at the base type if we have one and it
- has the same precision. */
- if (TREE_CODE (type) == INTEGER_TYPE
- && TREE_TYPE (type) != 0
- && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
- {
- type = TREE_TYPE (type);
- goto retry;
- }
-
- /* 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
- bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
- represented (assuming two's-complement arithmetic) within the bit
- precision of the type are returned instead. */
-
-void
-get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
-{
- if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
- && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
- 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
- {
- 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)
- wi::to_mpz (wi::to_wide (TYPE_MAX_VALUE (type)), max, TYPE_SIGN (type));
- else
- {
- wide_int mn = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
- wi::to_mpz (mn, max, TYPE_SIGN (type));
- }
-}
-
-/* Return true if VAR is an automatic variable. */
-
-bool
-auto_var_p (const_tree var)
-{
- return ((((VAR_P (var) && ! DECL_EXTERNAL (var))
- || TREE_CODE (var) == PARM_DECL)
- && ! TREE_STATIC (var))
- || TREE_CODE (var) == RESULT_DECL);
-}
-
-/* Return true if VAR is an automatic variable defined in function FN. */
-
-bool
-auto_var_in_fn_p (const_tree var, const_tree fn)
-{
- return (DECL_P (var) && DECL_CONTEXT (var) == fn
- && (auto_var_p (var)
- || TREE_CODE (var) == LABEL_DECL));
-}
-
-/* Subprogram of following function. Called by walk_tree.
-
- Return *TP if it is an automatic variable or parameter of the
- function passed in as DATA. */
-
-static tree
-find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
-{
- tree fn = (tree) data;
-
- if (TYPE_P (*tp))
- *walk_subtrees = 0;
-
- else if (DECL_P (*tp)
- && auto_var_in_fn_p (*tp, fn))
- return *tp;
-
- return NULL_TREE;
-}
-
-/* Returns true if T is, contains, or refers to a type with variable
- size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
- arguments, but not the return type. If FN is nonzero, only return
- true if a modifier of the type or position of FN is a variable or
- parameter inside FN.
-
- This concept is more general than that of C99 'variably modified types':
- in C99, a struct type is never variably modified because a VLA may not
- appear as a structure member. However, in GNU C code like:
-
- struct S { int i[f()]; };
-
- is valid, and other languages may define similar constructs. */
-
-bool
-variably_modified_type_p (tree type, tree fn)
-{
- tree t;
-
-/* Test if T is either variable (if FN is zero) or an expression containing
- 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 != NULL_TREE \
- && _t != error_mark_node \
- && !CONSTANT_CLASS_P (_t) \
- && TREE_CODE (_t) != PLACEHOLDER_EXPR \
- && (!fn \
- || (!TYPE_SIZES_GIMPLIFIED (type) \
- && (TREE_CODE (_t) != VAR_DECL \
- && !CONTAINS_PLACEHOLDER_P (_t))) \
- || walk_tree (&_t, find_var_from_fn, fn, NULL))) \
- return true; } while (0)
-
- if (type == error_mark_node)
- return false;
-
- /* If TYPE itself has variable size, it is variably modified. */
- RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
- RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
-
- switch (TREE_CODE (type))
- {
- 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))
- {
- TREE_VISITED (type) = false;
- return true;
- }
- TREE_VISITED (type) = false;
- break;
-
- case FUNCTION_TYPE:
- case METHOD_TYPE:
- /* If TYPE is a function type, it is variably modified if the
- return type is variably modified. */
- if (variably_modified_type_p (TREE_TYPE (type), fn))
- return true;
- break;
-
- case INTEGER_TYPE:
- case REAL_TYPE:
- case FIXED_POINT_TYPE:
- case ENUMERAL_TYPE:
- case BOOLEAN_TYPE:
- /* Scalar types are variably modified if their end points
- aren't constant. */
- RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
- RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
- break;
-
- case RECORD_TYPE:
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- /* We can't see if any of the fields are variably-modified by the
- definition we normally use, since that would produce infinite
- recursion via pointers. */
- /* This is variably modified if some field's type is. */
- for (t = TYPE_FIELDS (type); t; t = DECL_CHAIN (t))
- if (TREE_CODE (t) == FIELD_DECL)
- {
- RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
- RETURN_TRUE_IF_VAR (DECL_SIZE (t));
- RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
-
- /* If the type is a qualified union, then the DECL_QUALIFIER
- of fields can also be an expression containing a variable. */
- if (TREE_CODE (type) == QUAL_UNION_TYPE)
- RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
-
- /* If the field is a qualified union, then it's only a container
- for what's inside so we look into it. That's necessary in LTO
- mode because the sizes of the field tested above have been set
- to PLACEHOLDER_EXPRs by free_lang_data. */
- if (TREE_CODE (TREE_TYPE (t)) == QUAL_UNION_TYPE
- && variably_modified_type_p (TREE_TYPE (t), fn))
- return true;
- }
- break;
-
- case ARRAY_TYPE:
- /* Do not call ourselves to avoid infinite recursion. This is
- variably modified if the element type is. */
- RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
- RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
- break;
-
- default:
- break;
- }
-
- /* The current language may have other cases to check, but in general,
- all other types are not variably modified. */
- return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
-
-#undef RETURN_TRUE_IF_VAR
-}
-
-/* Given a DECL or TYPE, return the scope in which it was declared, or
- NULL_TREE if there is no containing scope. */
-
-tree
-get_containing_scope (const_tree t)
-{
- return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
-}
-
-/* Returns the ultimate TRANSLATION_UNIT_DECL context of DECL or NULL. */
-
-const_tree
-get_ultimate_context (const_tree decl)
-{
- while (decl && TREE_CODE (decl) != TRANSLATION_UNIT_DECL)
- {
- if (TREE_CODE (decl) == BLOCK)
- decl = BLOCK_SUPERCONTEXT (decl);
- else
- decl = get_containing_scope (decl);
- }
- return decl;
-}
-
-/* Return the innermost context enclosing DECL that is
- a FUNCTION_DECL, or zero if none. */
-
-tree
-decl_function_context (const_tree decl)
-{
- tree context;
-
- if (TREE_CODE (decl) == ERROR_MARK)
- return 0;
-
- /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
- where we look up the function at runtime. Such functions always take
- a first argument of type 'pointer to real context'.
-
- C++ should really be fixed to use DECL_CONTEXT for the real context,
- and use something else for the "virtual context". */
- else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VIRTUAL_P (decl))
- context
- = TYPE_MAIN_VARIANT
- (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
- else
- context = DECL_CONTEXT (decl);
-
- while (context && TREE_CODE (context) != FUNCTION_DECL)
- {
- if (TREE_CODE (context) == BLOCK)
- context = BLOCK_SUPERCONTEXT (context);
- else
- context = get_containing_scope (context);
- }
-
- return context;
-}
-
-/* Return the innermost context enclosing DECL that is
- a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
- TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */
-
-tree
-decl_type_context (const_tree decl)
-{
- tree context = DECL_CONTEXT (decl);
-
- while (context)
- switch (TREE_CODE (context))
- {
- case NAMESPACE_DECL:
- case TRANSLATION_UNIT_DECL:
- return NULL_TREE;
-
- case RECORD_TYPE:
- case UNION_TYPE:
- case QUAL_UNION_TYPE:
- return context;
-
- case TYPE_DECL:
- case FUNCTION_DECL:
- context = DECL_CONTEXT (context);
- break;
-
- case BLOCK:
- context = BLOCK_SUPERCONTEXT (context);
- break;
-
- default:
- gcc_unreachable ();
- }
-
- return NULL_TREE;
-}
-
-/* CALL is a CALL_EXPR. Return the declaration for the function
- called, or NULL_TREE if the called function cannot be
- determined. */
-
-tree
-get_callee_fndecl (const_tree call)
-{
- tree addr;
-
- if (call == error_mark_node)
- return error_mark_node;
-
- /* It's invalid to call this function with anything but a
- CALL_EXPR. */
- gcc_assert (TREE_CODE (call) == CALL_EXPR);
-
- /* The first operand to the CALL is the address of the function
- 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. */
- if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
- && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
- && DECL_INITIAL (addr))
- addr = DECL_INITIAL (addr);
-
- /* If the address is just `&f' for some function `f', then we know
- that `f' is being called. */
- if (TREE_CODE (addr) == ADDR_EXPR
- && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
- return TREE_OPERAND (addr, 0);
-
- /* We couldn't figure out what was being called. */
- 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 && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
- return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
-
- return CFN_LAST;
-}
-
-/* Comparator of indices based on tree_node_counts. */
-
-static int
-tree_nodes_cmp (const void *p1, const void *p2)
-{
- const unsigned *n1 = (const unsigned *)p1;
- const unsigned *n2 = (const unsigned *)p2;
-
- return tree_node_counts[*n1] - tree_node_counts[*n2];
-}
-
-/* Comparator of indices based on tree_code_counts. */
-
-static int
-tree_codes_cmp (const void *p1, const void *p2)
-{
- const unsigned *n1 = (const unsigned *)p1;
- const unsigned *n2 = (const unsigned *)p2;
-
- return tree_code_counts[*n1] - tree_code_counts[*n2];
-}
-
-#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)
-{
- if (GATHER_STATISTICS)
- {
- uint64_t total_nodes, total_bytes;
- fprintf (stderr, "\nKind Nodes Bytes\n");
- mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
- total_nodes = total_bytes = 0;
-
- {
- auto_vec<unsigned> indices (all_kinds);
- for (unsigned i = 0; i < all_kinds; i++)
- indices.quick_push (i);
- indices.qsort (tree_nodes_cmp);
-
- for (unsigned i = 0; i < (int) all_kinds; i++)
- {
- unsigned j = indices[i];
- fprintf (stderr, "%-20s %6" PRIu64 "%c %9" PRIu64 "%c\n",
- tree_node_kind_names[j], SIZE_AMOUNT (tree_node_counts[j]),
- SIZE_AMOUNT (tree_node_sizes[j]));
- total_nodes += tree_node_counts[j];
- total_bytes += tree_node_sizes[j];
- }
- mem_usage::print_dash_line (TREE_MEM_USAGE_SPACES);
- fprintf (stderr, "%-20s %6" PRIu64 "%c %9" PRIu64 "%c\n", "Total",
- SIZE_AMOUNT (total_nodes), SIZE_AMOUNT (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);
-
- auto_vec<unsigned> indices (MAX_TREE_CODES);
- for (unsigned i = 0; i < MAX_TREE_CODES; i++)
- indices.quick_push (i);
- indices.qsort (tree_codes_cmp);
-
- for (unsigned i = 0; i < MAX_TREE_CODES; i++)
- {
- unsigned j = indices[i];
- fprintf (stderr, "%-32s %6" PRIu64 "%c\n",
- get_tree_code_name ((enum tree_code) j),
- SIZE_AMOUNT (tree_code_counts[j]));
- }
- 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 ();
- lang_hooks.print_statistics ();
-}
-\f
-#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
- chksum = crc32_byte (chksum, *string);
- while (*string++);
- return chksum;
-}
-
-/* P is a string that will be used in a symbol. Mask out any characters
- that are not valid in that context. */
-
-void
-clean_symbol_name (char *p)
-{
- for (; *p; p++)
- if (! (ISALNUM (*p)
-#ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */
- || *p == '$'
-#endif
-#ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */
- || *p == '.'
-#endif
- ))
- *p = '_';
-}
-
-static GTY(()) unsigned anon_cnt = 0; /* Saved for PCH. */
-
-/* Create a unique anonymous identifier. The identifier is still a
- valid assembly label. */
-
-tree
-make_anon_name ()
-{
- const char *fmt =
-#if !defined (NO_DOT_IN_LABEL)
- "."
-#elif !defined (NO_DOLLAR_IN_LABEL)
- "$"
-#else
- "_"
-#endif
- "_anon_%d";
-
- char buf[24];
- int len = snprintf (buf, sizeof (buf), fmt, anon_cnt++);
- gcc_checking_assert (len < int (sizeof (buf)));
-
- tree id = get_identifier_with_length (buf, len);
- IDENTIFIER_ANON_P (id) = true;
-
- return id;
-}
-
-/* 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:
- I - for constructors
- D - for destructors
- N - for C++ anonymous namespaces
- F - for DWARF unwind frame information. */
-
-tree
-get_file_function_name (const char *type)
-{
- char *buf;
- const char *p;
- char *q;
-
- /* If we already have a name we know to be unique, just use that. */
- if (first_global_object_name)
- p = q = ASTRDUP (first_global_object_name);
- /* If the target is handling the constructors/destructors, they
- will be local to this file and the name is only necessary for
- debugging purposes.
- We also assign sub_I and sub_D sufixes to constructors called from
- the global static constructors. These are always local. */
- else if (((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
- || (startswith (type, "sub_")
- && (type[4] == 'I' || type[4] == 'D')))
- {
- const char *file = main_input_filename;
- if (! file)
- file = LOCATION_FILE (input_location);
- /* Just use the file's basename, because the full pathname
- might be quite long. */
- p = q = ASTRDUP (lbasename (file));
- }
- else
- {
- /* Otherwise, the name must be unique across the entire link.
- We don't have anything that we know to be unique to this translation
- unit, so use what we do have and throw in some randomness. */
- unsigned len;
- const char *name = weak_global_object_name;
- const char *file = main_input_filename;
-
- if (! name)
- name = "";
- if (! file)
- file = LOCATION_FILE (input_location);
-
- len = strlen (file);
- q = (char *) alloca (9 + 19 + len + 1);
- memcpy (q, file, len + 1);
-
- snprintf (q + len, 9 + 19 + 1, "_%08X_" HOST_WIDE_INT_PRINT_HEX,
- crc32_string (0, name), get_random_seed (false));
-
- p = q;
- }
-
- clean_symbol_name (q);
- buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
- + strlen (type));
-
- /* Set up the name of the file-level functions we may need.
- Use a global object (which is already required to be unique over
- the program) rather than the file name (which imposes extra
- constraints). */
- sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
-
- return get_identifier (buf);
-}
-\f
-#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-
-/* Complain that the tree code of NODE does not match the expected 0
- terminated list of trailing codes. The trailing code list can be
- empty, for a more vague error message. FILE, LINE, and FUNCTION
- are of the caller. */
-
-void
-tree_check_failed (const_tree node, const char *file,
- int line, const char *function, ...)
-{
- va_list args;
- const char *buffer;
- unsigned length = 0;
- enum tree_code code;
-
- va_start (args, function);
- while ((code = (enum tree_code) va_arg (args, int)))
- length += 4 + strlen (get_tree_code_name (code));
- va_end (args);
- if (length)
- {
- char *tmp;
- va_start (args, function);
- length += strlen ("expected ");
- buffer = tmp = (char *) alloca (length);
- length = 0;
- 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, get_tree_code_name (code));
- length += strlen (get_tree_code_name (code));
- }
- va_end (args);
- }
- else
- buffer = "unexpected node";
-
- internal_error ("tree check: %s, have %s in %s, at %s:%d",
- buffer, get_tree_code_name (TREE_CODE (node)),
- function, trim_filename (file), line);
-}
-
-/* Complain that the tree code of NODE does match the expected 0
- terminated list of trailing codes. FILE, LINE, and FUNCTION are of
- the caller. */
-
-void
-tree_not_check_failed (const_tree node, const char *file,
- int line, const char *function, ...)
-{
- va_list args;
- char *buffer;
- unsigned length = 0;
- enum tree_code code;
-
- va_start (args, function);
- 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 = (enum tree_code) va_arg (args, int)))
- {
- if (length)
- {
- strcpy (buffer + length, " or ");
- length += 4;
- }
- 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, get_tree_code_name (TREE_CODE (node)),
- function, trim_filename (file), line);
-}
-
-/* Similar to tree_check_failed, except that we check for a class of tree
- code, given in CL. */
-
-void
-tree_class_check_failed (const_tree node, const enum tree_code_class cl,
- const char *file, int line, const char *function)
-{
- internal_error
- ("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))),
- get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
-}
-
-/* Similar to tree_check_failed, except that instead of specifying a
- dozen codes, use the knowledge that they're all sequential. */
-
-void
-tree_range_check_failed (const_tree node, const char *file, int line,
- const char *function, enum tree_code c1,
- enum tree_code c2)
-{
- char *buffer;
- unsigned length = 0;
- unsigned int c;
-
- for (c = c1; c <= c2; ++c)
- length += 4 + strlen (get_tree_code_name ((enum tree_code) c));
-
- length += strlen ("expected ");
- buffer = (char *) alloca (length);
- length = 0;
-
- for (c = c1; c <= c2; ++c)
- {
- const char *prefix = length ? " or " : "expected ";
-
- strcpy (buffer + length, prefix);
- length += strlen (prefix);
- 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, get_tree_code_name (TREE_CODE (node)),
- function, trim_filename (file), line);
-}
-
-
-/* Similar to tree_check_failed, except that we check that a tree does
- not have the specified code, given in CL. */
-
-void
-tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
- const char *file, int line, const char *function)
-{
- internal_error
- ("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))),
- get_tree_code_name (TREE_CODE (node)), function, trim_filename (file), line);
-}
-
-
-/* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */
-
-void
-omp_clause_check_failed (const_tree node, const char *file, int line,
- const char *function, enum omp_clause_code code)
-{
- internal_error ("tree check: expected %<omp_clause %s%>, have %qs "
- "in %s, at %s:%d",
- omp_clause_code_name[code],
- get_tree_code_name (TREE_CODE (node)),
- function, trim_filename (file), line);
-}
-
-
-/* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */
-
-void
-omp_clause_range_check_failed (const_tree node, const char *file, int line,
- const char *function, enum omp_clause_code c1,
- enum omp_clause_code c2)
-{
- char *buffer;
- unsigned length = 0;
- unsigned int c;
-
- for (c = c1; c <= c2; ++c)
- length += 4 + strlen (omp_clause_code_name[c]);
-
- length += strlen ("expected ");
- buffer = (char *) alloca (length);
- length = 0;
-
- for (c = c1; c <= c2; ++c)
- {
- const char *prefix = length ? " or " : "expected ";
-
- strcpy (buffer + length, prefix);
- length += strlen (prefix);
- strcpy (buffer + length, omp_clause_code_name[c]);
- length += strlen (omp_clause_code_name[c]);
- }
-
- internal_error ("tree check: %s, have %s in %s, at %s:%d",
- buffer, omp_clause_code_name[TREE_CODE (node)],
- function, trim_filename (file), line);
-}
-
-
-#undef DEFTREESTRUCT
-#define DEFTREESTRUCT(VAL, NAME) NAME,
-
-static const char *ts_enum_names[] = {
-#include "treestruct.def"
-};
-#undef DEFTREESTRUCT
-
-#define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
-
-/* Similar to tree_class_check_failed, except that we check for
- whether CODE contains the tree structure identified by EN. */
-
-void
-tree_contains_struct_check_failed (const_tree node,
- const enum tree_node_structure_enum en,
- const char *file, int line,
- const char *function)
-{
- internal_error
- ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
- 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. */
-
-void
-tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
- const char *function)
-{
- internal_error
- ("tree check: accessed elt %d of %<tree_vec%> 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 the operand
- vector of an expression node EXP. */
-
-void
-tree_operand_check_failed (int idx, const_tree exp, const char *file,
- int line, const char *function)
-{
- 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, get_tree_code_name (code), TREE_OPERAND_LENGTH (exp),
- function, trim_filename (file), line);
-}
-
-/* Similar to above, except that the check is for the number of
- operands of an OMP_CLAUSE node. */
-
-void
-omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
- int line, const char *function)
-{
- internal_error
- ("tree check: accessed operand %d of %<omp_clause %s%> with %d operands "
- "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
- omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
- trim_filename (file), line);
-}
-#endif /* ENABLE_TREE_CHECKING */
-\f
-/* Create a new vector type node holding NUNITS units of type INNERTYPE,
- and mapped to the machine mode MODE. Initialize its fields and build
- the information necessary for debugging output. */
-
-static tree
-make_vector_type (tree innertype, poly_int64 nunits, machine_mode mode)
-{
- tree t;
- tree mv_innertype = TYPE_MAIN_VARIANT (innertype);
-
- t = make_node (VECTOR_TYPE);
- TREE_TYPE (t) = mv_innertype;
- SET_TYPE_VECTOR_SUBPARTS (t, nunits);
- SET_TYPE_MODE (t, mode);
-
- if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p)
- SET_TYPE_STRUCTURAL_EQUALITY (t);
- else if ((TYPE_CANONICAL (mv_innertype) != innertype
- || mode != VOIDmode)
- && !VECTOR_BOOLEAN_TYPE_P (t))
- TYPE_CANONICAL (t)
- = make_vector_type (TYPE_CANONICAL (mv_innertype), nunits, VOIDmode);
-
- layout_type (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. */
- if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
- && TREE_TYPE (t) != innertype)
- return build_type_attribute_qual_variant (t,
- TYPE_ATTRIBUTES (innertype),
- TYPE_QUALS (innertype));
-
- return t;
-}
-
-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)
- return unsignedp ? unsigned_char_type_node : signed_char_type_node;
- if (size == SHORT_TYPE_SIZE)
- return unsignedp ? short_unsigned_type_node : short_integer_type_node;
- if (size == LONG_TYPE_SIZE)
- return unsignedp ? long_unsigned_type_node : long_integer_type_node;
- if (size == LONG_LONG_TYPE_SIZE)
- return (unsignedp ? long_long_unsigned_type_node
- : long_long_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);
- else
- return make_signed_type (size);
-}
-
-/* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP. */
-
-static tree
-make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
-{
- if (satp)
- {
- if (size == SHORT_FRACT_TYPE_SIZE)
- return unsignedp ? sat_unsigned_short_fract_type_node
- : sat_short_fract_type_node;
- if (size == FRACT_TYPE_SIZE)
- return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
- if (size == LONG_FRACT_TYPE_SIZE)
- return unsignedp ? sat_unsigned_long_fract_type_node
- : sat_long_fract_type_node;
- if (size == LONG_LONG_FRACT_TYPE_SIZE)
- return unsignedp ? sat_unsigned_long_long_fract_type_node
- : sat_long_long_fract_type_node;
- }
- else
- {
- if (size == SHORT_FRACT_TYPE_SIZE)
- return unsignedp ? unsigned_short_fract_type_node
- : short_fract_type_node;
- if (size == FRACT_TYPE_SIZE)
- return unsignedp ? unsigned_fract_type_node : fract_type_node;
- if (size == LONG_FRACT_TYPE_SIZE)
- return unsignedp ? unsigned_long_fract_type_node
- : long_fract_type_node;
- if (size == LONG_LONG_FRACT_TYPE_SIZE)
- return unsignedp ? unsigned_long_long_fract_type_node
- : long_long_fract_type_node;
- }
-
- return make_fract_type (size, unsignedp, satp);
-}
-
-/* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP. */
-
-static tree
-make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
-{
- if (satp)
- {
- if (size == SHORT_ACCUM_TYPE_SIZE)
- return unsignedp ? sat_unsigned_short_accum_type_node
- : sat_short_accum_type_node;
- if (size == ACCUM_TYPE_SIZE)
- return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
- if (size == LONG_ACCUM_TYPE_SIZE)
- return unsignedp ? sat_unsigned_long_accum_type_node
- : sat_long_accum_type_node;
- if (size == LONG_LONG_ACCUM_TYPE_SIZE)
- return unsignedp ? sat_unsigned_long_long_accum_type_node
- : sat_long_long_accum_type_node;
- }
- else
- {
- if (size == SHORT_ACCUM_TYPE_SIZE)
- return unsignedp ? unsigned_short_accum_type_node
- : short_accum_type_node;
- if (size == ACCUM_TYPE_SIZE)
- return unsignedp ? unsigned_accum_type_node : accum_type_node;
- if (size == LONG_ACCUM_TYPE_SIZE)
- return unsignedp ? unsigned_long_accum_type_node
- : long_accum_type_node;
- if (size == LONG_LONG_ACCUM_TYPE_SIZE)
- return unsignedp ? unsigned_long_long_accum_type_node
- : long_long_accum_type_node;
- }
-
- 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. 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;
-
- initialize_sizetypes ();
-
- /* Define both `signed char' and `unsigned char'. */
- signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
- TYPE_STRING_FLAG (signed_char_type_node) = 1;
- unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
- TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
-
- /* Define `char', which is like either `signed char' or `unsigned char'
- but not the same as either. */
- char_type_node
- = (signed_char
- ? make_signed_type (CHAR_TYPE_SIZE)
- : make_unsigned_type (CHAR_TYPE_SIZE));
- TYPE_STRING_FLAG (char_type_node) = 1;
-
- short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
- short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
- integer_type_node = make_signed_type (INT_TYPE_SIZE);
- unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
- long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
- long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
- long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
- long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
-
- 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);
-
- if (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. */
- 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);
-
- /* 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], altname[50];
- sprintf (name, "__int%d unsigned", int_n_data[i].bitsize);
- sprintf (altname, "__int%d__ unsigned", int_n_data[i].bitsize);
-
- if (strcmp (name, SIZE_TYPE) == 0
- || strcmp (altname, 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], altname[50];
- sprintf (name, "__int%d", int_n_data[i].bitsize);
- sprintf (altname, "__int%d__", int_n_data[i].bitsize);
-
- if (strcmp (name, PTRDIFF_TYPE) == 0
- || strcmp (altname, 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. */
- intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
- intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
- intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
- intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
- intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
-
- unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
- unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
- unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
- unsigned_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");
-
- /* 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);
- integer_three_node = build_int_cst (integer_type_node, 3);
- integer_minus_one_node = build_int_cst (integer_type_node, -1);
-
- size_zero_node = size_int (0);
- size_one_node = size_int (1);
- bitsize_zero_node = bitsize_int (0);
- bitsize_one_node = bitsize_int (1);
- bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
-
- boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
- boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
-
- void_type_node = make_node (VOID_TYPE);
- layout_type (void_type_node);
-
- /* 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. */
- 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));
- 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);
- 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. */
- 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);
- if (targetm.scalar_mode_supported_p (TImode))
- uint128_type_node = make_or_reuse_type (128, 1);
-
- /* Decimal float types. */
- if (targetm.decimal_float_supported_p ())
- {
- 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);
-
- 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);
-
- 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);
- }
-
- 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) \
- sat_ ## KIND ## _type_node = \
- make_sat_signed_ ## KIND ## _type (SIZE); \
- sat_unsigned_ ## KIND ## _type_node = \
- make_sat_unsigned_ ## KIND ## _type (SIZE); \
- KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
- unsigned_ ## KIND ## _type_node = \
- make_unsigned_ ## KIND ## _type (SIZE);
-
-#define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
- sat_ ## WIDTH ## KIND ## _type_node = \
- make_sat_signed_ ## KIND ## _type (SIZE); \
- sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
- make_sat_unsigned_ ## KIND ## _type (SIZE); \
- WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
- unsigned_ ## WIDTH ## KIND ## _type_node = \
- make_unsigned_ ## KIND ## _type (SIZE);
-
-/* Make fixed-point type nodes based on four different widths. */
-#define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
- MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
- MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
- MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
- MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
-
-/* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned. */
-#define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
- NAME ## _type_node = \
- make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
- u ## NAME ## _type_node = \
- make_or_reuse_unsigned_ ## KIND ## _type \
- (GET_MODE_BITSIZE (U ## MODE ## mode)); \
- sat_ ## NAME ## _type_node = \
- make_or_reuse_sat_signed_ ## KIND ## _type \
- (GET_MODE_BITSIZE (MODE ## mode)); \
- sat_u ## NAME ## _type_node = \
- make_or_reuse_sat_unsigned_ ## KIND ## _type \
- (GET_MODE_BITSIZE (U ## MODE ## mode));
-
- /* Fixed-point type and mode nodes. */
- MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
- MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
- MAKE_FIXED_MODE_NODE (fract, qq, QQ)
- MAKE_FIXED_MODE_NODE (fract, hq, HQ)
- MAKE_FIXED_MODE_NODE (fract, sq, SQ)
- MAKE_FIXED_MODE_NODE (fract, dq, DQ)
- MAKE_FIXED_MODE_NODE (fract, tq, TQ)
- MAKE_FIXED_MODE_NODE (accum, ha, HA)
- MAKE_FIXED_MODE_NODE (accum, sa, SA)
- MAKE_FIXED_MODE_NODE (accum, da, DA)
- MAKE_FIXED_MODE_NODE (accum, ta, TA)
-
- {
- tree t = targetm.build_builtin_va_list ();
-
- /* Many back-ends define record types without setting TYPE_NAME.
- If we copied the record type here, we'd keep the original
- record type without a name. This breaks name mangling. So,
- don't copy record types and let c_common_nodes_and_builtins()
- declare the type to be __builtin_va_list. */
- if (TREE_CODE (t) != RECORD_TYPE)
- t = build_variant_type_copy (t);
-
- va_list_type_node = t;
- }
-
- /* SCEV analyzer global shared trees. */
- chrec_dont_know = make_node (SCEV_NOT_KNOWN);
- TREE_TYPE (chrec_dont_know) = void_type_node;
- chrec_known = make_node (SCEV_KNOWN);
- TREE_TYPE (chrec_known) = void_type_node;
-}
-
-/* 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 (2, "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
-local_define_builtin (const char *name, tree type, enum built_in_function code,
- const char *library_name, int ecf_flags)
-{
- tree decl;
-
- decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
- library_name, NULL_TREE);
- 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
- and internal functions that are relied upon by the tree optimizers and
- the middle-end. */
-
-void
-build_common_builtin_nodes (void)
-{
- tree tmp, ftype;
- 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 (!builtin_decl_explicit_p (BUILT_IN_MEMCPY))
- local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
- "memcpy", ECF_NOTHROW | ECF_LEAF);
- if (!builtin_decl_explicit_p (BUILT_IN_MEMMOVE))
- local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
- "memmove", ECF_NOTHROW | ECF_LEAF);
- }
-
- 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,
- NULL_TREE);
- local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
- "memcmp", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
- }
-
- 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 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", 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,
- ptr_type_node, NULL_TREE);
- 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);
- if (!builtin_decl_explicit_p (BUILT_IN_CLEAR_CACHE))
- local_define_builtin ("__builtin___clear_cache", ftype,
- BUILT_IN_CLEAR_CACHE,
- "__clear_cache",
- ECF_NOTHROW);
-
- local_define_builtin ("__builtin_nonlocal_goto", ftype,
- BUILT_IN_NONLOCAL_GOTO,
- "__builtin_nonlocal_goto",
- ECF_NORETURN | ECF_NOTHROW);
-
- ftype = build_function_type_list (void_type_node,
- ptr_type_node, ptr_type_node, NULL_TREE);
- local_define_builtin ("__builtin_setjmp_setup", ftype,
- BUILT_IN_SETJMP_SETUP,
- "__builtin_setjmp_setup", 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 | ECF_LEAF);
-
- ftype = build_function_type_list (ptr_type_node, NULL_TREE);
- local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
- "__builtin_stack_save", ECF_NOTHROW | ECF_LEAF);
-
- ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
- local_define_builtin ("__builtin_stack_restore", ftype,
- 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);
-
- local_define_builtin ("__builtin_strncmp_eq", ftype, BUILT_IN_STRNCMP_EQ,
- "__builtin_strncmp_eq",
- ECF_PURE | ECF_NOTHROW | ECF_LEAF);
-
- local_define_builtin ("__builtin_strcmp_eq", ftype, BUILT_IN_STRCMP_EQ,
- "__builtin_strcmp_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++. */
- if (targetm.arm_eabi_unwinder)
- {
- ftype = build_function_type_list (void_type_node, NULL_TREE);
- local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
- BUILT_IN_CXA_END_CLEANUP,
- "__cxa_end_cleanup", ECF_NORETURN | ECF_LEAF);
- }
-
- 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_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
- landing pad. These functions are PURE instead of CONST to prevent
- them from being hoisted past the exception edge that will initialize
- 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_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);
- local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
- "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW | ECF_LEAF);
-
- ftype = build_function_type_list (void_type_node,
- integer_type_node, integer_type_node,
- NULL_TREE);
- local_define_builtin ("__builtin_eh_copy_values", ftype,
- BUILT_IN_EH_COPY_VALUES,
- "__builtin_eh_copy_values", ECF_NOTHROW);
-
- /* Complex multiplication and division. These are handled as builtins
- rather than optabs because emit_library_call_value doesn't support
- complex. Further, we can do slightly better with folding these
- beasties if the real and complex parts of the arguments are separate. */
- {
- int mode;
-
- for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
- {
- char mode_name_buf[4], *q;
- const char *p;
- enum built_in_function mcode, dcode;
- tree type, inner_type;
- 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);
-
- ftype = build_function_type_list (type, inner_type, inner_type,
- inner_type, inner_type, NULL_TREE);
-
- mcode = ((enum built_in_function)
- (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
- dcode = ((enum built_in_function)
- (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
-
- for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
- *q = TOLOWER (*p);
- *q = '\0';
-
- /* For -ftrapping-math these should throw from a former
- -fnon-call-exception stmt. */
- 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_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_LEAF);
- }
- }
-
- init_internal_fns ();
-}
-
-/* HACK. GROSS. This is absolutely disgusting. I wish there was a
- better way.
-
- If we requested a pointer to a vector, build up the pointers that
- we stripped off while looking for the inner type. Similarly for
- return values from functions.
-
- The argument TYPE is the top of the chain, and BOTTOM is the
- new type which we will point to. */
-
-tree
-reconstruct_complex_type (tree type, tree bottom)
-{
- tree inner, outer;
-
- if (TREE_CODE (type) == POINTER_TYPE)
- {
- inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
- outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
- TYPE_REF_CAN_ALIAS_ALL (type));
- }
- else if (TREE_CODE (type) == REFERENCE_TYPE)
- {
- inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
- outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
- TYPE_REF_CAN_ALIAS_ALL (type));
- }
- else if (TREE_CODE (type) == ARRAY_TYPE)
- {
- inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
- outer = build_array_type (inner, TYPE_DOMAIN (type));
- }
- else if (TREE_CODE (type) == FUNCTION_TYPE)
- {
- inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
- outer = build_function_type (inner, TYPE_ARG_TYPES (type));
- }
- else if (TREE_CODE (type) == METHOD_TYPE)
- {
- inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
- /* The build_method_type_directly() routine prepends 'this' to argument list,
- so we must compensate by getting rid of it. */
- outer
- = build_method_type_directly
- (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
- inner,
- TREE_CHAIN (TYPE_ARG_TYPES (type)));
- }
- else if (TREE_CODE (type) == OFFSET_TYPE)
- {
- inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
- outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
- }
- else
- return bottom;
-
- return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
- TYPE_QUALS (type));
-}
-
-/* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
- the inner type. */
-tree
-build_vector_type_for_mode (tree innertype, machine_mode mode)
-{
- poly_int64 nunits;
- unsigned int bitsize;
-
- switch (GET_MODE_CLASS (mode))
- {
- case MODE_VECTOR_BOOL:
- case MODE_VECTOR_INT:
- case MODE_VECTOR_FLOAT:
- case MODE_VECTOR_FRACT:
- case MODE_VECTOR_UFRACT:
- case MODE_VECTOR_ACCUM:
- case MODE_VECTOR_UACCUM:
- nunits = GET_MODE_NUNITS (mode);
- break;
-
- case MODE_INT:
- /* Check that there are no leftover bits. */
- 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:
- gcc_unreachable ();
- }
-
- return make_vector_type (innertype, nunits, mode);
-}
-
-/* Similarly, but takes the inner type and number of units, which must be
- a power of two. */
-
-tree
-build_vector_type (tree innertype, poly_int64 nunits)
-{
- return make_vector_type (innertype, nunits, VOIDmode);
-}
-
-/* Build a truth vector with NUNITS units, giving it mode MASK_MODE. */
-
-tree
-build_truth_vector_type_for_mode (poly_uint64 nunits, machine_mode mask_mode)
-{
- gcc_assert (mask_mode != BLKmode);
-
- unsigned HOST_WIDE_INT esize;
- if (VECTOR_MODE_P (mask_mode))
- {
- poly_uint64 vsize = GET_MODE_BITSIZE (mask_mode);
- esize = vector_element_size (vsize, nunits);
- }
- else
- esize = 1;
-
- tree bool_type = build_nonstandard_boolean_type (esize);
-
- return make_vector_type (bool_type, nunits, mask_mode);
-}
-
-/* Build a vector type that holds one boolean result for each element of
- vector type VECTYPE. The public interface for this operation is
- truth_type_for. */
-
-static tree
-build_truth_vector_type_for (tree vectype)
-{
- machine_mode vector_mode = TYPE_MODE (vectype);
- poly_uint64 nunits = TYPE_VECTOR_SUBPARTS (vectype);
-
- machine_mode mask_mode;
- if (VECTOR_MODE_P (vector_mode)
- && targetm.vectorize.get_mask_mode (vector_mode).exists (&mask_mode))
- return build_truth_vector_type_for_mode (nunits, mask_mode);
-
- poly_uint64 vsize = tree_to_poly_uint64 (TYPE_SIZE (vectype));
- unsigned HOST_WIDE_INT esize = vector_element_size (vsize, nunits);
- tree bool_type = build_nonstandard_boolean_type (esize);
-
- return make_vector_type (bool_type, nunits, VOIDmode);
-}
-
-/* Like build_vector_type, but builds a variant type with TYPE_VECTOR_OPAQUE
- set. */
-
-tree
-build_opaque_vector_type (tree innertype, poly_int64 nunits)
-{
- 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;
-}
-
-/* Return the value of element I of VECTOR_CST T as a wide_int. */
-
-static poly_wide_int
-vector_cst_int_elt (const_tree t, unsigned int i)
-{
- /* First handle elements that are directly encoded. */
- unsigned int encoded_nelts = vector_cst_encoded_nelts (t);
- if (i < encoded_nelts)
- return wi::to_poly_wide (VECTOR_CST_ENCODED_ELT (t, i));
-
- /* Identify the pattern that contains element I and work out the index of
- the last encoded element for that pattern. */
- unsigned int npatterns = VECTOR_CST_NPATTERNS (t);
- unsigned int pattern = i % npatterns;
- unsigned int count = i / npatterns;
- unsigned int final_i = encoded_nelts - npatterns + pattern;
-
- /* If there are no steps, the final encoded value is the right one. */
- if (!VECTOR_CST_STEPPED_P (t))
- return wi::to_poly_wide (VECTOR_CST_ENCODED_ELT (t, final_i));
-
- /* Otherwise work out the value from the last two encoded elements. */
- tree v1 = VECTOR_CST_ENCODED_ELT (t, final_i - npatterns);
- tree v2 = VECTOR_CST_ENCODED_ELT (t, final_i);
- poly_wide_int diff = wi::to_poly_wide (v2) - wi::to_poly_wide (v1);
- return wi::to_poly_wide (v2) + (count - 2) * diff;
-}
-
-/* Return the value of element I of VECTOR_CST T. */
-
-tree
-vector_cst_elt (const_tree t, unsigned int i)
-{
- /* First handle elements that are directly encoded. */
- unsigned int encoded_nelts = vector_cst_encoded_nelts (t);
- if (i < encoded_nelts)
- return VECTOR_CST_ENCODED_ELT (t, i);
-
- /* If there are no steps, the final encoded value is the right one. */
- if (!VECTOR_CST_STEPPED_P (t))
- {
- /* Identify the pattern that contains element I and work out the index of
- the last encoded element for that pattern. */
- unsigned int npatterns = VECTOR_CST_NPATTERNS (t);
- unsigned int pattern = i % npatterns;
- unsigned int final_i = encoded_nelts - npatterns + pattern;
- return VECTOR_CST_ENCODED_ELT (t, final_i);
- }
-
- /* Otherwise work out the value from the last two encoded elements. */
- return wide_int_to_tree (TREE_TYPE (TREE_TYPE (t)),
- vector_cst_int_elt (t, i));
-}
-
-/* Given an initializer INIT, return TRUE if INIT is zero or some
- aggregate of zeros. Otherwise return FALSE. If NONZERO is not
- null, set *NONZERO if and only if INIT is known not to be all
- zeros. The combination of return value of false and *NONZERO
- false implies that INIT may but need not be all zeros. Other
- combinations indicate definitive answers. */
-
-bool
-initializer_zerop (const_tree init, bool *nonzero /* = NULL */)
-{
- bool dummy;
- if (!nonzero)
- nonzero = &dummy;
-
- /* Conservatively clear NONZERO and set it only if INIT is definitely
- not all zero. */
- *nonzero = false;
-
- STRIP_NOPS (init);
-
- unsigned HOST_WIDE_INT off = 0;
-
- switch (TREE_CODE (init))
- {
- case INTEGER_CST:
- if (integer_zerop (init))
- return true;
-
- *nonzero = true;
- return false;
-
- case REAL_CST:
- /* ??? Note that this is not correct for C4X float formats. There,
- a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
- negative exponent. */
- if (real_zerop (init)
- && !REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init)))
- return true;
-
- *nonzero = true;
- return false;
-
- case FIXED_CST:
- if (fixed_zerop (init))
- return true;
-
- *nonzero = true;
- return false;
-
- case COMPLEX_CST:
- if (integer_zerop (init)
- || (real_zerop (init)
- && !REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
- && !REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init)))))
- return true;
-
- *nonzero = true;
- return false;
-
- case VECTOR_CST:
- if (VECTOR_CST_NPATTERNS (init) == 1
- && VECTOR_CST_DUPLICATE_P (init)
- && initializer_zerop (VECTOR_CST_ENCODED_ELT (init, 0)))
- return true;
-
- *nonzero = true;
- return false;
-
- case CONSTRUCTOR:
- {
- if (TREE_CLOBBER_P (init))
- return false;
-
- unsigned HOST_WIDE_INT idx;
- tree elt;
-
- FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
- if (!initializer_zerop (elt, nonzero))
- return false;
-
- return true;
- }
-
- case MEM_REF:
- {
- tree arg = TREE_OPERAND (init, 0);
- if (TREE_CODE (arg) != ADDR_EXPR)
- return false;
- tree offset = TREE_OPERAND (init, 1);
- if (TREE_CODE (offset) != INTEGER_CST
- || !tree_fits_uhwi_p (offset))
- return false;
- off = tree_to_uhwi (offset);
- if (INT_MAX < off)
- return false;
- arg = TREE_OPERAND (arg, 0);
- if (TREE_CODE (arg) != STRING_CST)
- return false;
- init = arg;
- }
- /* Fall through. */
-
- case STRING_CST:
- {
- gcc_assert (off <= INT_MAX);
-
- int i = off;
- int n = TREE_STRING_LENGTH (init);
- if (n <= i)
- return false;
-
- /* We need to loop through all elements to handle cases like
- "\0" and "\0foobar". */
- for (i = 0; i < n; ++i)
- if (TREE_STRING_POINTER (init)[i] != '\0')
- {
- *nonzero = true;
- return false;
- }
-
- return true;
- }
-
- default:
- return false;
- }
-}
-
-/* Return true if EXPR is an initializer expression in which every element
- is a constant that is numerically equal to 0 or 1. The elements do not
- need to be equal to each other. */
-
-bool
-initializer_each_zero_or_onep (const_tree expr)
-{
- STRIP_ANY_LOCATION_WRAPPER (expr);
-
- switch (TREE_CODE (expr))
- {
- case INTEGER_CST:
- return integer_zerop (expr) || integer_onep (expr);
-
- case REAL_CST:
- return real_zerop (expr) || real_onep (expr);
-
- case VECTOR_CST:
- {
- unsigned HOST_WIDE_INT nelts = vector_cst_encoded_nelts (expr);
- if (VECTOR_CST_STEPPED_P (expr)
- && !TYPE_VECTOR_SUBPARTS (TREE_TYPE (expr)).is_constant (&nelts))
- return false;
-
- for (unsigned int i = 0; i < nelts; ++i)
- {
- tree elt = vector_cst_elt (expr, i);
- if (!initializer_each_zero_or_onep (elt))
- return false;
- }
-
- return true;
- }
-
- default:
- return false;
- }
-}
-
-/* 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 HOST_WIDE_INT i, nelts;
-
- if (vec == NULL_TREE)
- return NULL_TREE;
-
- gcc_assert (VECTOR_TYPE_P (TREE_TYPE (vec)));
-
- if (TREE_CODE (vec) == VEC_DUPLICATE_EXPR)
- return TREE_OPERAND (vec, 0);
-
- else if (TREE_CODE (vec) == VECTOR_CST)
- {
- if (VECTOR_CST_NPATTERNS (vec) == 1 && VECTOR_CST_DUPLICATE_P (vec))
- return VECTOR_CST_ENCODED_ELT (vec, 0);
- return NULL_TREE;
- }
-
- else if (TREE_CODE (vec) == CONSTRUCTOR
- && TYPE_VECTOR_SUBPARTS (TREE_TYPE (vec)).is_constant (&nelts))
- {
- 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 != nelts)
- return NULL_TREE;
-
- return first;
- }
-
- return NULL_TREE;
-}
-
-/* If the argument is INTEGER_CST, return it. If the argument is vector
- with all elements the same INTEGER_CST, return that INTEGER_CST. Otherwise
- return NULL_TREE.
- Look through location wrappers. */
-
-tree
-uniform_integer_cst_p (tree t)
-{
- STRIP_ANY_LOCATION_WRAPPER (t);
-
- if (TREE_CODE (t) == INTEGER_CST)
- return t;
-
- if (VECTOR_TYPE_P (TREE_TYPE (t)))
- {
- t = uniform_vector_p (t);
- if (t && TREE_CODE (t) == INTEGER_CST)
- return t;
- }
-
- return NULL_TREE;
-}
-
-/* If VECTOR_CST T has a single nonzero element, return the index of that
- element, otherwise return -1. */
-
-int
-single_nonzero_element (const_tree t)
-{
- unsigned HOST_WIDE_INT nelts;
- unsigned int repeat_nelts;
- if (VECTOR_CST_NELTS (t).is_constant (&nelts))
- repeat_nelts = nelts;
- else if (VECTOR_CST_NELTS_PER_PATTERN (t) == 2)
- {
- nelts = vector_cst_encoded_nelts (t);
- repeat_nelts = VECTOR_CST_NPATTERNS (t);
- }
- else
- return -1;
-
- int res = -1;
- for (unsigned int i = 0; i < nelts; ++i)
- {
- tree elt = vector_cst_elt (t, i);
- if (!integer_zerop (elt) && !real_zerop (elt))
- {
- if (res >= 0 || i >= repeat_nelts)
- return -1;
- res = i;
- }
- }
- return res;
-}
-
-/* Build an empty statement at location LOC. */
-
-tree
-build_empty_stmt (location_t loc)
-{
- tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
- SET_EXPR_LOCATION (t, loc);
- return t;
-}
-
-
-/* Build an OpenMP clause with code CODE. LOC is the location of the
- clause. */
-
-tree
-build_omp_clause (location_t loc, enum omp_clause_code code)
-{
- tree t;
- int size, length;
-
- length = omp_clause_num_ops[code];
- size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
-
- 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;
-
- return t;
-}
-
-/* Build a tcc_vl_exp object with code CODE and room for LEN operands. LEN
- includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
- Except for the CODE and operand count field, other storage for the
- object is initialized to zeros. */
-
-tree
-build_vl_exp (enum tree_code code, int len MEM_STAT_DECL)
-{
- tree t;
- int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
-
- gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
- gcc_assert (len >= 1);
-
- record_node_allocation_statistics (code, length);
-
- t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT);
-
- TREE_SET_CODE (t, code);
-
- /* Can't use TREE_OPERAND to store the length because if checking is
- enabled, it will try to check the length before we store it. :-P */
- t->exp.operands[0] = build_int_cst (sizetype, len);
-
- 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. */
-
-tree
-build_call_nary (tree return_type, tree fn, int nargs, ...)
-{
- tree ret;
- va_list args;
- va_start (args, nargs);
- ret = build_call_valist (return_type, fn, nargs, args);
- va_end (args);
- return ret;
-}
-
-/* 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 a va_list ARGS. */
-
-tree
-build_call_valist (tree return_type, tree fn, int nargs, va_list args)
-{
- tree t;
- int i;
-
- 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);
- 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 a tree array ARGS. */
-
-tree
-build_call_array_loc (location_t loc, tree return_type, tree fn,
- int nargs, const tree *args)
-{
- tree t;
- int i;
-
- 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);
- SET_EXPR_LOCATION (t, loc);
- return t;
-}
-
-/* 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_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;
-}
-
-/* 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;
- process_call_operands (t);
- 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 of type ELTYPE[SIZE] (or LEN
- if SIZE == -1) and return a tree node representing char* pointer to
- it as an ADDR_EXPR (ARRAY_REF (ELTYPE, ...)). When STR is nonnull
- the STRING_CST value is the LEN bytes at STR (the representation
- of the string, which may be wide). Otherwise it's all zeros. */
-
-tree
-build_string_literal (unsigned len, const char *str /* = NULL */,
- tree eltype /* = char_type_node */,
- unsigned HOST_WIDE_INT size /* = -1 */)
-{
- tree t = build_string (len, str);
- /* Set the maximum valid index based on the string length or SIZE. */
- unsigned HOST_WIDE_INT maxidx
- = (size == HOST_WIDE_INT_M1U ? len : size) - 1;
-
- tree index = build_index_type (size_int (maxidx));
- eltype = build_type_variant (eltype, 1, 0);
- tree type = build_array_type (eltype, index);
- TREE_TYPE (t) = type;
- TREE_CONSTANT (t) = 1;
- TREE_READONLY (t) = 1;
- TREE_STATIC (t) = 1;
-
- type = build_pointer_type (eltype);
- t = build1 (ADDR_EXPR, type,
- build4 (ARRAY_REF, eltype,
- 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. */
-
-bool
-needs_to_live_in_memory (const_tree t)
-{
- return (TREE_ADDRESSABLE (t)
- || is_global_var (t)
- || (TREE_CODE (t) == RESULT_DECL
- && !DECL_BY_REFERENCE (t)
- && aggregate_value_p (t, current_function_decl)));
-}
-
-/* Return value of a constant X and sign-extend it. */
-
-HOST_WIDE_INT
-int_cst_value (const_tree x)
-{
- unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
- 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 (cst_and_fits_in_hwi (x));
-
- if (bits < HOST_BITS_PER_WIDE_INT)
- {
- bool negative = ((val >> (bits - 1)) & 1) != 0;
- if (negative)
- val |= HOST_WIDE_INT_M1U << (bits - 1) << 1;
- else
- val &= ~(HOST_WIDE_INT_M1U << (bits - 1) << 1);
- }
-
- return val;
-}
-
-/* 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.
- If TYPE is a floating-point type, return an integer type with the same
- bitsize and with the signedness given by UNSIGNEDP; this is useful
- when doing bit-level operations on a floating-point value. */
-
-tree
-signed_or_unsigned_type_for (int unsignedp, tree type)
-{
- if (ANY_INTEGRAL_TYPE_P (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 (TREE_CODE (type) == COMPLEX_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_complex_type (inner2);
- }
-
- unsigned int bits;
- if (INTEGRAL_TYPE_P (type)
- || POINTER_TYPE_P (type)
- || TREE_CODE (type) == OFFSET_TYPE)
- bits = TYPE_PRECISION (type);
- else if (TREE_CODE (type) == REAL_TYPE)
- bits = GET_MODE_BITSIZE (SCALAR_TYPE_MODE (type));
- else
- return NULL_TREE;
-
- return build_nonstandard_integer_type (bits, 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. If TYPE is a floating-point type, return an
- unsigned integer type with the same bitsize as TYPE. */
-
-tree
-unsigned_type_for (tree type)
-{
- return signed_or_unsigned_type_for (1, 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. If TYPE is a floating-point type, return a
- signed integer type with the same bitsize as TYPE. */
-
-tree
-signed_type_for (tree type)
-{
- 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_for (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 int det = 0;
- unsigned oprec = TYPE_PRECISION (outer);
- unsigned iprec = TYPE_PRECISION (inner);
- unsigned prec;
-
- /* Compute a unique number for every combination. */
- det |= (oprec > iprec) ? 4 : 0;
- det |= TYPE_UNSIGNED (outer) ? 2 : 0;
- det |= TYPE_UNSIGNED (inner) ? 1 : 0;
-
- /* Determine the exponent to use. */
- switch (det)
- {
- case 0:
- case 1:
- /* oprec <= iprec, outer: signed, inner: don't care. */
- prec = oprec - 1;
- break;
- case 2:
- case 3:
- /* oprec <= iprec, outer: unsigned, inner: don't care. */
- prec = oprec;
- break;
- case 4:
- /* oprec > iprec, outer: signed, inner: signed. */
- prec = iprec - 1;
- break;
- case 5:
- /* oprec > iprec, outer: signed, inner: unsigned. */
- prec = iprec;
- break;
- case 6:
- /* oprec > iprec, outer: unsigned, inner: signed. */
- prec = oprec;
- break;
- case 7:
- /* oprec > iprec, outer: unsigned, inner: unsigned. */
- prec = iprec;
- break;
- default:
- gcc_unreachable ();
- }
-
- 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
- OUTER type. */
-
-tree
-lower_bound_in_type (tree outer, tree inner)
-{
- unsigned oprec = TYPE_PRECISION (outer);
- unsigned iprec = TYPE_PRECISION (inner);
-
- /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
- and obtain 0. */
- if (TYPE_UNSIGNED (outer)
- /* If we are widening something of an unsigned type, OUTER type
- contains all values of INNER type. In particular, both INNER
- and OUTER types have zero in common. */
- || (oprec > iprec && TYPE_UNSIGNED (inner)))
- return build_int_cst (outer, 0);
- else
- {
- /* If we are widening a signed type to another signed type, we
- want to obtain -2^^(iprec-1). If we are keeping the
- precision or narrowing to a signed type, we want to obtain
- -2^(oprec-1). */
- unsigned prec = oprec > iprec ? iprec : oprec;
- 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
- necessarily equal. Specifically, both ARG0 and ARG1 must be either
- SSA_NAME or invariant. Note that this is strictly an optimization.
- That is, callers of this function can directly call operand_equal_p
- and get the same result, only slower. */
-
-int
-operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
-{
- if (arg0 == arg1)
- return 1;
- if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
- return 0;
- return operand_equal_p (arg0, arg1, 0);
-}
-
-/* Returns number of zeros at the end of binary representation of X. */
-
-tree
-num_ending_zeros (const_tree x)
-{
- return build_int_cst (TREE_TYPE (x), wi::ctz (wi::to_wide (x)));
-}
-
-
-#define WALK_SUBTREE(NODE) \
- do \
- { \
- result = walk_tree_1 (&(NODE), func, data, pset, lh); \
- if (result) \
- return result; \
- } \
- while (0)
-
-/* This is a subroutine of walk_tree that walks field of TYPE that are to
- be walked whenever a type is seen in the tree. Rest of operands and return
- value are as for walk_tree. */
-
-static tree
-walk_type_fields (tree type, walk_tree_fn func, void *data,
- hash_set<tree> *pset, walk_tree_lh lh)
-{
- tree result = NULL_TREE;
-
- switch (TREE_CODE (type))
- {
- 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
- by checking if we're pointing to another pointer, that one
- points to another pointer, that one does too, and we have no htab.
- If so, get a hash table. We check three levels deep to avoid
- the cost of the hash table if we don't need one. */
- if (POINTER_TYPE_P (TREE_TYPE (type))
- && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
- && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
- && !pset)
- {
- result = walk_tree_without_duplicates (&TREE_TYPE (type),
- func, data);
- if (result)
- return result;
-
- break;
- }
-
- /* fall through */
-
- case COMPLEX_TYPE:
- WALK_SUBTREE (TREE_TYPE (type));
- break;
-
- case METHOD_TYPE:
- WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
-
- /* Fall through. */
-
- case FUNCTION_TYPE:
- WALK_SUBTREE (TREE_TYPE (type));
- {
- tree arg;
-
- /* We never want to walk into default arguments. */
- for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
- WALK_SUBTREE (TREE_VALUE (arg));
- }
- break;
-
- case ARRAY_TYPE:
- /* Don't follow this nodes's type if a pointer for fear that
- we'll have infinite recursion. If we have a PSET, then we
- need not fear. */
- if (pset
- || (!POINTER_TYPE_P (TREE_TYPE (type))
- && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
- WALK_SUBTREE (TREE_TYPE (type));
- WALK_SUBTREE (TYPE_DOMAIN (type));
- break;
-
- case OFFSET_TYPE:
- WALK_SUBTREE (TREE_TYPE (type));
- WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
- break;
-
- default:
- break;
- }
-
- return NULL_TREE;
-}
-
-/* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is
- called with the DATA and the address of each sub-tree. If FUNC returns a
- non-NULL value, the traversal is stopped, and the value returned by FUNC
- is returned. If PSET is non-NULL it is used to record the nodes visited,
- and to avoid visiting a node more than once. */
-
-tree
-walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
- hash_set<tree> *pset, walk_tree_lh lh)
-{
- enum tree_code code;
- int walk_subtrees;
- tree result;
-
-#define WALK_SUBTREE_TAIL(NODE) \
- do \
- { \
- tp = & (NODE); \
- goto tail_recurse; \
- } \
- while (0)
-
- tail_recurse:
- /* Skip empty subtrees. */
- if (!*tp)
- return NULL_TREE;
-
- /* Don't walk the same tree twice, if the user has requested
- that we avoid doing so. */
- if (pset && pset->add (*tp))
- return NULL_TREE;
-
- /* Call the function. */
- walk_subtrees = 1;
- result = (*func) (tp, &walk_subtrees, data);
-
- /* If we found something, return it. */
- if (result)
- return result;
-
- code = TREE_CODE (*tp);
-
- /* Even if we didn't, FUNC may have decided that there was nothing
- interesting below this point in the tree. */
- if (!walk_subtrees)
- {
- /* But we still need to check our siblings. */
- if (code == TREE_LIST)
- WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
- else if (code == OMP_CLAUSE)
- WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
- else
- return NULL_TREE;
- }
-
- if (lh)
- {
- result = (*lh) (tp, &walk_subtrees, func, data, pset);
- if (result || !walk_subtrees)
- return result;
- }
-
- switch (code)
- {
- case ERROR_MARK:
- case IDENTIFIER_NODE:
- case INTEGER_CST:
- case REAL_CST:
- case FIXED_CST:
- case STRING_CST:
- case BLOCK:
- case PLACEHOLDER_EXPR:
- case SSA_NAME:
- case FIELD_DECL:
- case RESULT_DECL:
- /* None of these have subtrees other than those already walked
- above. */
- break;
-
- case TREE_LIST:
- WALK_SUBTREE (TREE_VALUE (*tp));
- WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
- break;
-
- case TREE_VEC:
- {
- int len = TREE_VEC_LENGTH (*tp);
-
- if (len == 0)
- break;
-
- /* Walk all elements but the first. */
- while (--len)
- WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
-
- /* Now walk the first one as a tail call. */
- WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
- }
-
- case VECTOR_CST:
- {
- unsigned len = vector_cst_encoded_nelts (*tp);
- if (len == 0)
- break;
- /* Walk all elements but the first. */
- while (--len)
- WALK_SUBTREE (VECTOR_CST_ENCODED_ELT (*tp, len));
- /* Now walk the first one as a tail call. */
- WALK_SUBTREE_TAIL (VECTOR_CST_ENCODED_ELT (*tp, 0));
- }
-
- case COMPLEX_CST:
- WALK_SUBTREE (TREE_REALPART (*tp));
- WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
-
- case CONSTRUCTOR:
- {
- unsigned HOST_WIDE_INT idx;
- constructor_elt *ce;
-
- for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
- idx++)
- WALK_SUBTREE (ce->value);
- }
- break;
-
- case SAVE_EXPR:
- WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
-
- case BIND_EXPR:
- {
- tree decl;
- for (decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
- {
- /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk
- into declarations that are just mentioned, rather than
- declared; they don't really belong to this part of the tree.
- And, we can see cycles: the initializer for a declaration
- can refer to the declaration itself. */
- WALK_SUBTREE (DECL_INITIAL (decl));
- WALK_SUBTREE (DECL_SIZE (decl));
- WALK_SUBTREE (DECL_SIZE_UNIT (decl));
- }
- WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
- }
-
- case STATEMENT_LIST:
- {
- tree_stmt_iterator i;
- for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
- WALK_SUBTREE (*tsi_stmt_ptr (i));
- }
- break;
-
- case OMP_CLAUSE:
- switch (OMP_CLAUSE_CODE (*tp))
- {
- case OMP_CLAUSE_GANG:
- WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 1));
- /* FALLTHRU */
-
- case OMP_CLAUSE_AFFINITY:
- 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_NONTEMPORAL:
- 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_FILTER:
- case OMP_CLAUSE_TO_DECLARE:
- case OMP_CLAUSE_LINK:
- case OMP_CLAUSE_DETACH:
- case OMP_CLAUSE_USE_DEVICE_PTR:
- case OMP_CLAUSE_USE_DEVICE_ADDR:
- case OMP_CLAUSE_IS_DEVICE_PTR:
- case OMP_CLAUSE_INCLUSIVE:
- case OMP_CLAUSE_EXCLUSIVE:
- case OMP_CLAUSE__LOOPTEMP_:
- case OMP_CLAUSE__REDUCTEMP_:
- case OMP_CLAUSE__CONDTEMP_:
- case OMP_CLAUSE__SCANTEMP_:
- case OMP_CLAUSE__SIMDUID_:
- WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
- /* FALLTHRU */
-
- case OMP_CLAUSE_INDEPENDENT:
- case OMP_CLAUSE_NOWAIT:
- case OMP_CLAUSE_DEFAULT:
- case OMP_CLAUSE_UNTIED:
- case OMP_CLAUSE_MERGEABLE:
- case OMP_CLAUSE_PROC_BIND:
- case OMP_CLAUSE_DEVICE_TYPE:
- 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_ORDER:
- case OMP_CLAUSE_BIND:
- case OMP_CLAUSE_AUTO:
- case OMP_CLAUSE_SEQ:
- case OMP_CLAUSE_TILE:
- case OMP_CLAUSE__SIMT_:
- case OMP_CLAUSE_IF_PRESENT:
- case OMP_CLAUSE_FINALIZE:
- case OMP_CLAUSE_NOHOST:
- WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
-
- case OMP_CLAUSE_LASTPRIVATE:
- WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
- WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
- WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
-
- case OMP_CLAUSE_COLLAPSE:
- {
- int i;
- for (i = 0; i < 3; i++)
- WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
- 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_ALLOCATE:
- 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:
- case OMP_CLAUSE_TASK_REDUCTION:
- case OMP_CLAUSE_IN_REDUCTION:
- {
- int i;
- for (i = 0; i < 5; i++)
- WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
- WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
- }
-
- default:
- gcc_unreachable ();
- }
- break;
-
- case TARGET_EXPR:
- {
- int i, len;
-
- /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
- But, we only want to walk once. */
- len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
- for (i = 0; i < len; ++i)
- WALK_SUBTREE (TREE_OPERAND (*tp, i));
- WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
- }
-
- case DECL_EXPR:
- /* If this is a TYPE_DECL, walk into the fields of the type that it's
- defining. We only want to walk into these fields of a type in this
- case and not in the general case of a mere reference to the type.
-
- The criterion is as follows: if the field can be an expression, it
- must be walked only here. This should be in keeping with the fields
- that are directly gimplified in gimplify_type_sizes in order for the
- mark/copy-if-shared/unmark machinery of the gimplifier to work with
- variable-sized types.
-
- Note that DECLs get walked as part of processing the BIND_EXPR. */
- if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
- {
- /* Call the function for the decl so e.g. copy_tree_body_r can
- replace it with the remapped one. */
- result = (*func) (&DECL_EXPR_DECL (*tp), &walk_subtrees, data);
- if (result || !walk_subtrees)
- return result;
-
- tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
- if (TREE_CODE (*type_p) == ERROR_MARK)
- return NULL_TREE;
-
- /* Call the function for the type. See if it returns anything or
- doesn't want us to continue. If we are to continue, walk both
- the normal fields and those for the declaration case. */
- result = (*func) (type_p, &walk_subtrees, data);
- if (result || !walk_subtrees)
- 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))
- {
- tree field;
-
- for (field = TYPE_FIELDS (*type_p); field;
- field = DECL_CHAIN (field))
- {
- /* We'd like to look at the type of the field, but we can
- easily get infinite recursion. So assume it's pointed
- to elsewhere in the tree. Also, ignore things that
- aren't fields. */
- if (TREE_CODE (field) != FIELD_DECL)
- continue;
-
- WALK_SUBTREE (DECL_FIELD_OFFSET (field));
- WALK_SUBTREE (DECL_SIZE (field));
- WALK_SUBTREE (DECL_SIZE_UNIT (field));
- if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
- WALK_SUBTREE (DECL_QUALIFIER (field));
- }
- }
-
- /* Same for scalar types. */
- else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
- || TREE_CODE (*type_p) == ENUMERAL_TYPE
- || TREE_CODE (*type_p) == INTEGER_TYPE
- || TREE_CODE (*type_p) == FIXED_POINT_TYPE
- || TREE_CODE (*type_p) == REAL_TYPE)
- {
- WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
- WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
- }
-
- WALK_SUBTREE (TYPE_SIZE (*type_p));
- WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
- }
- /* FALLTHRU */
-
- default:
- if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
- {
- int i, len;
-
- /* Walk over all the sub-trees of this operand. */
- len = TREE_OPERAND_LENGTH (*tp);
-
- /* Go through the subtrees. We need to do this in forward order so
- that the scope of a FOR_EXPR is handled properly. */
- if (len)
- {
- for (i = 0; i < len - 1; ++i)
- WALK_SUBTREE (TREE_OPERAND (*tp, i));
- WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
- }
- }
- /* If this is a type, walk the needed fields in the type. */
- else if (TYPE_P (*tp))
- return walk_type_fields (*tp, func, data, pset, lh);
- break;
- }
-
- /* We didn't find what we were looking for. */
- return NULL_TREE;
-
-#undef WALK_SUBTREE_TAIL
-}
-#undef WALK_SUBTREE
-
-/* Like walk_tree, but does not walk duplicate nodes more than once. */
-
-tree
-walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
- walk_tree_lh lh)
-{
- tree result;
-
- hash_set<tree> pset;
- result = walk_tree_1 (tp, func, data, &pset, lh);
- return result;
-}
-
-
-tree
-tree_block (tree t)
-{
- const enum tree_code_class c = TREE_CODE_CLASS (TREE_CODE (t));
-
- if (IS_EXPR_CODE_CLASS (c))
- 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. */
-
-tree
-create_artificial_label (location_t loc)
-{
- tree lab = build_decl (loc,
- LABEL_DECL, NULL_TREE, void_type_node);
-
- DECL_ARTIFICIAL (lab) = 1;
- DECL_IGNORED_P (lab) = 1;
- DECL_CONTEXT (lab) = current_function_decl;
- return lab;
-}
-
-/* Given a tree, try to return a useful variable name that we can use
- to prefix a temporary that is being assigned the value of the tree.
- I.E. given <temp> = &A, return A. */
-
-const char *
-get_name (tree t)
-{
- tree stripped_decl;
-
- stripped_decl = t;
- 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))
- {
- case ADDR_EXPR:
- return get_name (TREE_OPERAND (stripped_decl, 0));
- default:
- return NULL;
- }
- }
-}
-
-/* Return true if TYPE has a variable argument list. */
-
-bool
-stdarg_p (const_tree fntype)
-{
- function_args_iterator args_iter;
- tree n = NULL_TREE, t;
-
- if (!fntype)
- return false;
-
- FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
- {
- n = t;
- }
-
- return n != NULL_TREE && n != void_type_node;
-}
-
-/* Return true if TYPE has a prototype. */
-
-bool
-prototype_p (const_tree fntype)
-{
- tree t;
-
- gcc_assert (fntype != NULL_TREE);
-
- t = TYPE_ARG_TYPES (fntype);
- return (t != NULL_TREE);
-}
-
-/* If BLOCK is inlined from an __attribute__((__artificial__))
- routine, return pointer to location from where it has been
- called. */
-location_t *
-block_nonartificial_location (tree block)
-{
- location_t *ret = NULL;
-
- while (block && TREE_CODE (block) == BLOCK
- && BLOCK_ABSTRACT_ORIGIN (block))
- {
- tree ao = BLOCK_ABSTRACT_ORIGIN (block);
- if (TREE_CODE (ao) == FUNCTION_DECL)
- {
- /* If AO is an artificial inline, point RET to the
- call site locus at which it has been inlined and continue
- the loop, in case AO's caller is also an artificial
- inline. */
- if (DECL_DECLARED_INLINE_P (ao)
- && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
- ret = &BLOCK_SOURCE_LOCATION (block);
- else
- break;
- }
- else if (TREE_CODE (ao) != BLOCK)
- break;
-
- block = BLOCK_SUPERCONTEXT (block);
- }
- return ret;
-}
-
-
-/* If EXP is inlined from an __attribute__((__artificial__))
- function, return the location of the original call expression. */
-
-location_t
-tree_nonartificial_location (tree exp)
-{
- location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
-
- if (loc)
- return *loc;
- else
- return EXPR_LOCATION (exp);
-}
-
-/* Return the location into which EXP has been inlined. Analogous
- to tree_nonartificial_location() above but not limited to artificial
- functions declared inline. If SYSTEM_HEADER is true, return
- the macro expansion point of the location if it's in a system header */
-
-location_t
-tree_inlined_location (tree exp, bool system_header /* = true */)
-{
- location_t loc = UNKNOWN_LOCATION;
-
- tree block = TREE_BLOCK (exp);
-
- while (block && TREE_CODE (block) == BLOCK
- && BLOCK_ABSTRACT_ORIGIN (block))
- {
- tree ao = BLOCK_ABSTRACT_ORIGIN (block);
- if (TREE_CODE (ao) == FUNCTION_DECL)
- loc = BLOCK_SOURCE_LOCATION (block);
- else if (TREE_CODE (ao) != BLOCK)
- break;
-
- block = BLOCK_SUPERCONTEXT (block);
- }
-
- if (loc == UNKNOWN_LOCATION)
- {
- loc = EXPR_LOCATION (exp);
- if (system_header)
- /* Only consider macro expansion when the block traversal failed
- to find a location. Otherwise it's not relevant. */
- return expansion_point_location_if_in_system_header (loc);
- }
-
- return loc;
-}
-
-/* These are the hash table functions for the hash table of OPTIMIZATION_NODE
- nodes. */
-
-/* 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;
- hashval_t hash = 0;
-
- if (TREE_CODE (t) == OPTIMIZATION_NODE)
- {
- p = (const char *)TREE_OPTIMIZATION (t);
- len = sizeof (struct cl_optimization);
- }
-
- else if (TREE_CODE (t) == TARGET_OPTION_NODE)
- return cl_target_option_hash (TREE_TARGET_OPTION (t));
-
- else
- gcc_unreachable ();
-
- /* assume most opt flags are just 0/1, some are 2-3, and a few might be
- something else. */
- for (i = 0; i < len; i++)
- if (p[i])
- hash = (hash << 4) ^ ((i << 2) | p[i]);
-
- return hash;
-}
-
-/* Return nonzero if the value represented by *X (an OPTIMIZATION or
- TARGET_OPTION tree node) is the same as that given by *Y, which is the
- same. */
-
-bool
-cl_option_hasher::equal (tree x, tree y)
-{
- const_tree const xt = x;
- const_tree const yt = y;
-
- if (TREE_CODE (xt) != TREE_CODE (yt))
- return 0;
-
- if (TREE_CODE (xt) == OPTIMIZATION_NODE)
- return cl_optimization_option_eq (TREE_OPTIMIZATION (xt),
- TREE_OPTIMIZATION (yt));
- else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
- return cl_target_option_eq (TREE_TARGET_OPTION (xt),
- TREE_TARGET_OPTION (yt));
- else
- gcc_unreachable ();
-}
-
-/* Build an OPTIMIZATION_NODE based on the options in OPTS and OPTS_SET. */
-
-tree
-build_optimization_node (struct gcc_options *opts,
- struct gcc_options *opts_set)
-{
- tree t;
-
- /* Use the cache of optimization nodes. */
-
- cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node),
- opts, opts_set);
-
- tree *slot = cl_option_hash_table->find_slot (cl_optimization_node, INSERT);
- t = *slot;
- if (!t)
- {
- /* Insert this one into the hash table. */
- t = cl_optimization_node;
- *slot = t;
-
- /* Make a new node for next time round. */
- cl_optimization_node = make_node (OPTIMIZATION_NODE);
- }
-
- return t;
-}
-
-/* Build a TARGET_OPTION_NODE based on the options in OPTS and OPTS_SET. */
-
-tree
-build_target_option_node (struct gcc_options *opts,
- struct gcc_options *opts_set)
-{
- tree t;
-
- /* Use the cache of optimization nodes. */
-
- cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node),
- opts, opts_set);
-
- tree *slot = cl_option_hash_table->find_slot (cl_target_option_node, INSERT);
- t = *slot;
- if (!t)
- {
- /* Insert this one into the hash table. */
- t = cl_target_option_node;
- *slot = t;
-
- /* Make a new node for next time round. */
- cl_target_option_node = make_node (TARGET_OPTION_NODE);
- }
-
- 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. */
-
-tree
-block_ultimate_origin (const_tree block)
-{
- tree origin = BLOCK_ABSTRACT_ORIGIN (block);
-
- if (origin == NULL_TREE)
- return NULL_TREE;
- else
- {
- gcc_checking_assert ((DECL_P (origin)
- && DECL_ORIGIN (origin) == origin)
- || BLOCK_ORIGIN (origin) == origin);
- return origin;
- }
-}
-
-/* Return true iff conversion from INNER_TYPE to OUTER_TYPE generates
- no instruction. */
-
-bool
-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;
- }
-
- /* 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
- it inline so that we fully inline into the stripping functions even
- though we have two uses of this function. */
-
-static inline bool
-tree_nop_conversion (const_tree exp)
-{
- tree outer_type, inner_type;
-
- if (location_wrapper_p (exp))
- return true;
- if (!CONVERT_EXPR_P (exp)
- && TREE_CODE (exp) != NON_LVALUE_EXPR)
- return false;
-
- outer_type = TREE_TYPE (exp);
- inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
- if (!inner_type || inner_type == error_mark_node)
- return false;
-
- return tree_nop_conversion_p (outer_type, inner_type);
-}
-
-/* Return true iff conversion in EXP generates no instruction. Don't
- consider conversions changing the signedness. */
-
-static bool
-tree_sign_nop_conversion (const_tree exp)
-{
- tree outer_type, inner_type;
-
- if (!tree_nop_conversion (exp))
- return false;
-
- outer_type = TREE_TYPE (exp);
- inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
-
- return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
- && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
-}
-
-/* Strip conversions from EXP according to tree_nop_conversion and
- return the resulting expression. */
-
-tree
-tree_strip_nop_conversions (tree exp)
-{
- while (tree_nop_conversion (exp))
- exp = TREE_OPERAND (exp, 0);
- return exp;
-}
-
-/* Strip conversions from EXP according to tree_sign_nop_conversion
- and return the resulting expression. */
-
-tree
-tree_strip_sign_nop_conversions (tree exp)
-{
- while (tree_sign_nop_conversion (exp))
- exp = TREE_OPERAND (exp, 0);
- 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. */
-
-tree
-lhd_gcc_personality (void)
-{
- if (!gcc_eh_personality_decl)
- gcc_eh_personality_decl = build_personality_function ("gcc");
- 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.) FOR_DUMP_P is true when being called from
- the dump routines. */
-
-bool
-virtual_method_call_p (const_tree target, bool for_dump_p)
-{
- 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, for_dump_p)))
- return false;
- return true;
-}
-
-/* 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. */
-
-tree
-get_binfo_at_offset (tree binfo, poly_int64 offset, tree expected_type)
-{
- tree type = BINFO_TYPE (binfo);
-
- while (true)
- {
- HOST_WIDE_INT pos, size;
- tree fld;
- int i;
-
- if (types_same_for_odr (type, expected_type))
- return binfo;
- if (maybe_lt (offset, 0))
- return NULL_TREE;
-
- for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
- {
- if (TREE_CODE (fld) != FIELD_DECL || !DECL_ARTIFICIAL (fld))
- continue;
-
- pos = int_bit_position (fld);
- size = tree_to_uhwi (DECL_SIZE (fld));
- if (known_in_range_p (offset, pos, size))
- break;
- }
- if (!fld || TREE_CODE (TREE_TYPE (fld)) != RECORD_TYPE)
- return NULL_TREE;
-
- /* Offset 0 indicates the primary base, whose vtable contents are
- represented in the binfo for the derived class. */
- else if (maybe_ne (offset, 0))
- {
- 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_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)
- binfo = found_binfo;
- else
- binfo = lookup_binfo_at_offset (binfo, TREE_TYPE (fld),
- binfo_offset);
- }
-
- type = TREE_TYPE (fld);
- offset -= pos;
- }
-}
-
-/* Returns true if X is a typedef decl. */
-
-bool
-is_typedef_decl (const_tree x)
-{
- return (x && TREE_CODE (x) == TYPE_DECL
- && DECL_ORIGINAL_TYPE (x) != NULL_TREE);
-}
-
-/* Returns true iff TYPE is a type variant created for a typedef. */
-
-bool
-typedef_variant_p (const_tree type)
-{
- return is_typedef_decl (TYPE_NAME (type));
-}
-
-/* PR 84195: Replace control characters in "unescaped" with their
- escaped equivalents. Allow newlines if -fmessage-length has
- been set to a non-zero value. This is done here, rather than
- where the attribute is recorded as the message length can
- change between these two locations. */
-
-void
-escaped_string::escape (const char *unescaped)
-{
- char *escaped;
- size_t i, new_i, len;
-
- if (m_owned)
- free (m_str);
-
- m_str = const_cast<char *> (unescaped);
- m_owned = false;
-
- if (unescaped == NULL || *unescaped == 0)
- return;
-
- len = strlen (unescaped);
- escaped = NULL;
- new_i = 0;
-
- for (i = 0; i < len; i++)
- {
- char c = unescaped[i];
-
- if (!ISCNTRL (c))
- {
- if (escaped)
- escaped[new_i++] = c;
- continue;
- }
-
- if (c != '\n' || !pp_is_wrapping_line (global_dc->printer))
- {
- if (escaped == NULL)
- {
- /* We only allocate space for a new string if we
- actually encounter a control character that
- needs replacing. */
- escaped = (char *) xmalloc (len * 2 + 1);
- strncpy (escaped, unescaped, i);
- new_i = i;
- }
-
- escaped[new_i++] = '\\';
-
- switch (c)
- {
- case '\a': escaped[new_i++] = 'a'; break;
- case '\b': escaped[new_i++] = 'b'; break;
- case '\f': escaped[new_i++] = 'f'; break;
- case '\n': escaped[new_i++] = 'n'; break;
- case '\r': escaped[new_i++] = 'r'; break;
- case '\t': escaped[new_i++] = 't'; break;
- case '\v': escaped[new_i++] = 'v'; break;
- default: escaped[new_i++] = '?'; break;
- }
- }
- else if (escaped)
- escaped[new_i++] = c;
- }
-
- if (escaped)
- {
- escaped[new_i] = 0;
- m_str = escaped;
- m_owned = true;
- }
-}
-
-/* Warn about a use of an identifier which was marked deprecated. Returns
- whether a warning was given. */
-
-bool
-warn_deprecated_use (tree node, tree attr)
-{
- escaped_string msg;
-
- if (node == 0 || !warn_deprecated_decl)
- return false;
-
- if (!attr)
- {
- if (DECL_P (node))
- attr = DECL_ATTRIBUTES (node);
- else if (TYPE_P (node))
- {
- tree decl = TYPE_STUB_DECL (node);
- if (decl)
- attr = lookup_attribute ("deprecated",
- TYPE_ATTRIBUTES (TREE_TYPE (decl)));
- }
- }
-
- if (attr)
- attr = lookup_attribute ("deprecated", attr);
-
- if (attr)
- msg.escape (TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr))));
-
- bool w = false;
- if (DECL_P (node))
- {
- auto_diagnostic_group d;
- if (msg)
- w = warning (OPT_Wdeprecated_declarations,
- "%qD is deprecated: %s", node, (const char *) msg);
- else
- w = warning (OPT_Wdeprecated_declarations,
- "%qD is deprecated", node);
- if (w)
- inform (DECL_SOURCE_LOCATION (node), "declared here");
- }
- else if (TYPE_P (node))
- {
- tree what = NULL_TREE;
- tree decl = TYPE_STUB_DECL (node);
-
- if (TYPE_NAME (node))
- {
- if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
- what = TYPE_NAME (node);
- else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
- && DECL_NAME (TYPE_NAME (node)))
- what = DECL_NAME (TYPE_NAME (node));
- }
-
- auto_diagnostic_group d;
- if (what)
- {
- if (msg)
- w = warning (OPT_Wdeprecated_declarations,
- "%qE is deprecated: %s", what, (const char *) msg);
- else
- w = warning (OPT_Wdeprecated_declarations,
- "%qE is deprecated", what);
- }
- else
- {
- if (msg)
- w = warning (OPT_Wdeprecated_declarations,
- "type is deprecated: %s", (const char *) msg);
- else
- w = warning (OPT_Wdeprecated_declarations,
- "type is deprecated");
- }
-
- if (w && decl)
- inform (DECL_SOURCE_LOCATION (decl), "declared here");
- }
-
- return w;
-}
-
-/* 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 there is a default: label or case labels cover all possible
- SWITCH_COND values, then the SWITCH_EXPR will transfer control
- to some case label in all cases and all we care is whether the
- SWITCH_BODY falls through. */
- if (SWITCH_ALL_CASES_P (stmt))
- return block_may_fallthru (SWITCH_BODY (stmt));
- return true;
-
- 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 EH_ELSE_EXPR:
- return block_may_fallthru (TREE_OPERAND (stmt, 0));
-
- 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>";
-
- /* The tree_code enum promotes to signed, but we could be getting
- invalid values, so force an unsigned comparison. */
- if (unsigned (code) >= MAX_TREE_CODES)
- {
- if ((unsigned)code == 0xa5a5)
- return "ggc_freed";
- 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 (poly_int_tree_p (t))
- return wide_int_to_tree (TREE_TYPE (t), wi::to_poly_wide (t));
-
- /* For VECTOR_CST, remove the overflow bits from the encoded elements
- and canonicalize the result. */
- if (TREE_CODE (t) == VECTOR_CST)
- {
- tree_vector_builder builder;
- builder.new_unary_operation (TREE_TYPE (t), t, true);
- unsigned int count = builder.encoded_nelts ();
- for (unsigned int i = 0; i < count; ++i)
- {
- tree elt = VECTOR_CST_ELT (t, i);
- if (TREE_OVERFLOW (elt))
- elt = drop_tree_overflow (elt);
- builder.quick_push (elt);
- }
- return builder.build ();
- }
-
- /* 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));
- }
-
- 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)
-{
- if (TREE_CODE (t) == WITH_SIZE_EXPR)
- t = TREE_OPERAND (t, 0);
- 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);
-
- 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. */
- tree idxtype = TREE_TYPE (TREE_OPERAND (exp, 1));
- return (idxtype == error_mark_node
- ? integer_zero_node : build_int_cst (idxtype, 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, component reference,
- or memory 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 if (TREE_CODE (ref) == MEM_REF)
- {
- tree arg = TREE_OPERAND (ref, 0);
- if (TREE_CODE (arg) == ADDR_EXPR)
- arg = TREE_OPERAND (arg, 0);
- tree argtype = TREE_TYPE (arg);
- if (TREE_CODE (argtype) == RECORD_TYPE)
- {
- if (tree fld = last_field (argtype))
- {
- atype = TREE_TYPE (fld);
- if (TREE_CODE (atype) != ARRAY_TYPE)
- return false;
- if (VAR_P (arg) && DECL_SIZE (fld))
- return false;
- }
- else
- return false;
- }
- else
- return false;
- }
- else
- return false;
-
- if (TREE_CODE (ref) == STRING_CST)
- return false;
-
- tree ref_to_array = ref;
- 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)
- || ! TYPE_DOMAIN (atype)
- || ! TYPE_MAX_VALUE (TYPE_DOMAIN (atype)))
- return true;
-
- /* 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). */
- ref = get_base_address (ref);
- if (ref
- && DECL_P (ref)
- && !(flag_unconstrained_commons
- && VAR_P (ref) && DECL_COMMON (ref))
- && DECL_SIZE_UNIT (ref)
- && TREE_CODE (DECL_SIZE_UNIT (ref)) == INTEGER_CST)
- {
- /* Check whether the array domain covers all of the available
- padding. */
- poly_int64 offset;
- if (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (atype))) != INTEGER_CST
- || TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (atype))) != INTEGER_CST
- || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (atype))) != INTEGER_CST)
- return true;
- if (! get_addr_base_and_unit_offset (ref_to_array, &offset))
- return true;
-
- /* If at least one extra element fits it is a flexarray. */
- if (known_le ((wi::to_offset (TYPE_MAX_VALUE (TYPE_DOMAIN (atype)))
- - wi::to_offset (TYPE_MIN_VALUE (TYPE_DOMAIN (atype)))
- + 2)
- * wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (atype))),
- wi::to_offset (DECL_SIZE_UNIT (ref)) - offset))
- return true;
-
- 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);
-}
-
-/* Given the initializer INIT, return the initializer for the field
- DECL if it exists, otherwise null. Used to obtain the initializer
- for a flexible array member and determine its size. */
-
-static tree
-get_initializer_for (tree init, tree decl)
-{
- STRIP_NOPS (init);
-
- tree fld, fld_init;
- unsigned HOST_WIDE_INT i;
- FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (init), i, fld, fld_init)
- {
- if (decl == fld)
- return fld_init;
-
- if (TREE_CODE (fld) == CONSTRUCTOR)
- {
- fld_init = get_initializer_for (fld_init, decl);
- if (fld_init)
- return fld_init;
- }
- }
-
- return NULL_TREE;
-}
-
-/* Determines the size of the member referenced by the COMPONENT_REF
- REF, using its initializer expression if necessary in order to
- determine the size of an initialized flexible array member.
- If non-null, set *ARK when REF refers to an interior zero-length
- array or a trailing one-element array.
- Returns the size as sizetype (which might be zero for an object
- with an uninitialized flexible array member) or null if the size
- cannot be determined. */
-
-tree
-component_ref_size (tree ref, special_array_member *sam /* = NULL */)
-{
- gcc_assert (TREE_CODE (ref) == COMPONENT_REF);
-
- special_array_member sambuf;
- if (!sam)
- sam = &sambuf;
- *sam = special_array_member::none;
-
- /* The object/argument referenced by the COMPONENT_REF and its type. */
- tree arg = TREE_OPERAND (ref, 0);
- tree argtype = TREE_TYPE (arg);
- /* The referenced member. */
- tree member = TREE_OPERAND (ref, 1);
-
- tree memsize = DECL_SIZE_UNIT (member);
- if (memsize)
- {
- tree memtype = TREE_TYPE (member);
- if (TREE_CODE (memtype) != ARRAY_TYPE)
- /* DECL_SIZE may be less than TYPE_SIZE in C++ when referring
- to the type of a class with a virtual base which doesn't
- reflect the size of the virtual's members (see pr97595).
- If that's the case fail for now and implement something
- more robust in the future. */
- return (tree_int_cst_equal (memsize, TYPE_SIZE_UNIT (memtype))
- ? memsize : NULL_TREE);
-
- bool trailing = array_at_struct_end_p (ref);
- bool zero_length = integer_zerop (memsize);
- if (!trailing && !zero_length)
- /* MEMBER is either an interior array or is an array with
- more than one element. */
- return memsize;
-
- if (zero_length)
- {
- if (trailing)
- *sam = special_array_member::trail_0;
- else
- {
- *sam = special_array_member::int_0;
- memsize = NULL_TREE;
- }
- }
-
- if (!zero_length)
- if (tree dom = TYPE_DOMAIN (memtype))
- if (tree min = TYPE_MIN_VALUE (dom))
- if (tree max = TYPE_MAX_VALUE (dom))
- if (TREE_CODE (min) == INTEGER_CST
- && TREE_CODE (max) == INTEGER_CST)
- {
- offset_int minidx = wi::to_offset (min);
- offset_int maxidx = wi::to_offset (max);
- offset_int neltsm1 = maxidx - minidx;
- if (neltsm1 > 0)
- /* MEMBER is an array with more than one element. */
- return memsize;
-
- if (neltsm1 == 0)
- *sam = special_array_member::trail_1;
- }
-
- /* For a reference to a zero- or one-element array member of a union
- use the size of the union instead of the size of the member. */
- if (TREE_CODE (argtype) == UNION_TYPE)
- memsize = TYPE_SIZE_UNIT (argtype);
- }
-
- /* MEMBER is either a bona fide flexible array member, or a zero-length
- array member, or an array of length one treated as such. */
-
- /* If the reference is to a declared object and the member a true
- flexible array, try to determine its size from its initializer. */
- poly_int64 baseoff = 0;
- tree base = get_addr_base_and_unit_offset (ref, &baseoff);
- if (!base || !VAR_P (base))
- {
- if (*sam != special_array_member::int_0)
- return NULL_TREE;
-
- if (TREE_CODE (arg) != COMPONENT_REF)
- return NULL_TREE;
-
- base = arg;
- while (TREE_CODE (base) == COMPONENT_REF)
- base = TREE_OPERAND (base, 0);
- baseoff = tree_to_poly_int64 (byte_position (TREE_OPERAND (ref, 1)));
- }
-
- /* BASE is the declared object of which MEMBER is either a member
- or that is cast to ARGTYPE (e.g., a char buffer used to store
- an ARGTYPE object). */
- tree basetype = TREE_TYPE (base);
-
- /* Determine the base type of the referenced object. If it's
- the same as ARGTYPE and MEMBER has a known size, return it. */
- tree bt = basetype;
- if (*sam != special_array_member::int_0)
- while (TREE_CODE (bt) == ARRAY_TYPE)
- bt = TREE_TYPE (bt);
- bool typematch = useless_type_conversion_p (argtype, bt);
- if (memsize && typematch)
- return memsize;
-
- memsize = NULL_TREE;
-
- if (typematch)
- /* MEMBER is a true flexible array member. Compute its size from
- the initializer of the BASE object if it has one. */
- if (tree init = DECL_P (base) ? DECL_INITIAL (base) : NULL_TREE)
- if (init != error_mark_node)
- {
- init = get_initializer_for (init, member);
- if (init)
- {
- memsize = TYPE_SIZE_UNIT (TREE_TYPE (init));
- if (tree refsize = TYPE_SIZE_UNIT (argtype))
- {
- /* Use the larger of the initializer size and the tail
- padding in the enclosing struct. */
- poly_int64 rsz = tree_to_poly_int64 (refsize);
- rsz -= baseoff;
- if (known_lt (tree_to_poly_int64 (memsize), rsz))
- memsize = wide_int_to_tree (TREE_TYPE (memsize), rsz);
- }
-
- baseoff = 0;
- }
- }
-
- if (!memsize)
- {
- if (typematch)
- {
- if (DECL_P (base)
- && DECL_EXTERNAL (base)
- && bt == basetype
- && *sam != special_array_member::int_0)
- /* The size of a flexible array member of an extern struct
- with no initializer cannot be determined (it's defined
- in another translation unit and can have an initializer
- with an arbitrary number of elements). */
- return NULL_TREE;
-
- /* Use the size of the base struct or, for interior zero-length
- arrays, the size of the enclosing type. */
- memsize = TYPE_SIZE_UNIT (bt);
- }
- else if (DECL_P (base))
- /* Use the size of the BASE object (possibly an array of some
- other type such as char used to store the struct). */
- memsize = DECL_SIZE_UNIT (base);
- else
- return NULL_TREE;
- }
-
- /* If the flexible array member has a known size use the greater
- of it and the tail padding in the enclosing struct.
- Otherwise, when the size of the flexible array member is unknown
- and the referenced object is not a struct, use the size of its
- type when known. This detects sizes of array buffers when cast
- to struct types with flexible array members. */
- if (memsize)
- {
- poly_int64 memsz64 = memsize ? tree_to_poly_int64 (memsize) : 0;
- if (known_lt (baseoff, memsz64))
- {
- memsz64 -= baseoff;
- return wide_int_to_tree (TREE_TYPE (memsize), memsz64);
- }
- return size_zero_node;
- }
-
- /* Return "don't know" for an external non-array object since its
- flexible array member can be initialized to have any number of
- elements. Otherwise, return zero because the flexible array
- member has no elements. */
- return (DECL_P (base)
- && DECL_EXTERNAL (base)
- && (!typematch
- || TREE_CODE (basetype) != ARRAY_TYPE)
- ? NULL_TREE : size_zero_node);
-}
-
-/* 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))
- {
- poly_int64 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;
-}
-
-/* Return the size in bits of each element of vector type TYPE. */
-
-unsigned int
-vector_element_bits (const_tree type)
-{
- gcc_checking_assert (VECTOR_TYPE_P (type));
- if (VECTOR_BOOLEAN_TYPE_P (type))
- return TYPE_PRECISION (TREE_TYPE (type));
- return tree_to_uhwi (TYPE_SIZE (TREE_TYPE (type)));
-}
-
-/* Calculate the size in bits of each element of vector type TYPE
- and return the result as a tree of type bitsizetype. */
-
-tree
-vector_element_bits_tree (const_tree type)
-{
- gcc_checking_assert (VECTOR_TYPE_P (type));
- if (VECTOR_BOOLEAN_TYPE_P (type))
- return bitsize_int (vector_element_bits (type));
- return TYPE_SIZE (TREE_TYPE (type));
-}
-
-/* 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 %s", #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 0
- if (TYPE_ARTIFICIAL (tv))
- verify_variant_match (TYPE_ARTIFICIAL);
-#endif
- 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 0
- if (RECORD_OR_UNION_TYPE_P (t) && COMPLETE_TYPE_P (t))
- verify_variant_match (TYPE_FINAL_P);
-#endif
-
- /* 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_NEEDS_CONSTRUCTING);
- }
- verify_variant_match (TYPE_PRECISION);
- 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 0
- if (!in_lto_p || !TYPE_FILE_SCOPE_P (t))
- verify_variant_match (TYPE_CONTEXT);
-#endif
- if (TREE_CODE (t) == ARRAY_TYPE || TREE_CODE (t) == INTEGER_TYPE)
- verify_variant_match (TYPE_STRING_FLAG);
- if (TREE_CODE (t) == RECORD_TYPE || TREE_CODE (t) == UNION_TYPE)
- verify_variant_match (TYPE_CXX_ODR_P);
- 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
- && TYPE_VALUES (t))
- 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);
- }
-
- /* For types where we do ODR based TBAA the canonical type is always
- set correctly, so we know that types are different if their
- canonical types does not match. */
- if (trust_type_canonical
- && (odr_type_p (t1) && odr_based_tbaa_p (t1))
- != (odr_type_p (t2) && odr_based_tbaa_p (t2)))
- return false;
-
- /* 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 cannot 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 cannot 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)
- && COMPLETE_TYPE_P (t))
- {
- 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 be");
- 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 ("%qs failed", __func__);
- }
-}
-
-
-/* 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;
- value_range r;
- while (!get_global_range_query ()->range_of_expr (r, arg) || r.kind () != 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 (r.upper_bound (), prec), SIGNED))
- return 1;
- if (wi::neg_p (wi::sext (r.lower_bound (), prec), SIGNED))
- return 2;
- }
- else
- {
- if (!wi::neg_p (wi::sext (r.lower_bound (), prec), SIGNED))
- return 1;
- if (wi::neg_p (wi::sext (r.upper_bound (), 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 EXPR, potentially wrapped with a node expression LOC,
- if !CAN_HAVE_LOCATION_P (expr).
-
- NON_LVALUE_EXPR is used for wrapping constants, apart from STRING_CST.
- VIEW_CONVERT_EXPR is used for wrapping non-constants and STRING_CST.
-
- Wrapper nodes can be identified using location_wrapper_p. */
-
-tree
-maybe_wrap_with_location (tree expr, location_t loc)
-{
- if (expr == NULL)
- return NULL;
- if (loc == UNKNOWN_LOCATION)
- return expr;
- if (CAN_HAVE_LOCATION_P (expr))
- return expr;
- /* We should only be adding wrappers for constants and for decls,
- or for some exceptional tree nodes (e.g. BASELINK in the C++ FE). */
- gcc_assert (CONSTANT_CLASS_P (expr)
- || DECL_P (expr)
- || EXCEPTIONAL_CLASS_P (expr));
-
- /* For now, don't add wrappers to exceptional tree nodes, to minimize
- any impact of the wrapper nodes. */
- if (EXCEPTIONAL_CLASS_P (expr))
- return expr;
-
- /* Compiler-generated temporary variables don't need a wrapper. */
- if (DECL_P (expr) && DECL_ARTIFICIAL (expr) && DECL_IGNORED_P (expr))
- return expr;
-
- /* If any auto_suppress_location_wrappers are active, don't create
- wrappers. */
- if (suppress_location_wrappers > 0)
- return expr;
-
- tree_code code
- = (((CONSTANT_CLASS_P (expr) && TREE_CODE (expr) != STRING_CST)
- || (TREE_CODE (expr) == CONST_DECL && !TREE_STATIC (expr)))
- ? NON_LVALUE_EXPR : VIEW_CONVERT_EXPR);
- tree wrapper = build1_loc (loc, code, TREE_TYPE (expr), expr);
- /* Mark this node as being a wrapper. */
- EXPR_LOCATION_WRAPPER_P (wrapper) = 1;
- return wrapper;
-}
-
-int suppress_location_wrappers;
-
-/* 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;
-
- bitmap argmap = NULL;
- if (TREE_CODE (fntype) == METHOD_TYPE)
- {
- /* The this pointer in C++ non-static member functions is
- implicitly nonnull whether or not it's declared as such. */
- argmap = BITMAP_ALLOC (NULL);
- bitmap_set_bit (argmap, 0);
- }
-
- tree attrs = TYPE_ATTRIBUTES (fntype);
- if (!attrs)
- return argmap;
-
- /* 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;
-}
-
-/* Returns true if TYPE is a type where it and all of its subobjects
- (recursively) are of structure, union, or array type. */
-
-bool
-is_empty_type (const_tree type)
-{
- if (RECORD_OR_UNION_TYPE_P (type))
- {
- for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
- if (TREE_CODE (field) == FIELD_DECL
- && !DECL_PADDING_P (field)
- && !is_empty_type (TREE_TYPE (field)))
- return false;
- return true;
- }
- else if (TREE_CODE (type) == ARRAY_TYPE)
- return (integer_minus_onep (array_type_nelts (type))
- || TYPE_DOMAIN (type) == NULL_TREE
- || is_empty_type (TREE_TYPE (type)));
- return false;
-}
-
-/* Implement TARGET_EMPTY_RECORD_P. Return true if TYPE is an empty type
- that shouldn't be passed via stack. */
-
-bool
-default_is_empty_record (const_tree type)
-{
- if (!abi_version_at_least (12))
- return false;
-
- if (type == error_mark_node)
- return false;
-
- if (TREE_ADDRESSABLE (type))
- return false;
-
- return is_empty_type (TYPE_MAIN_VARIANT (type));
-}
-
-/* Determine whether TYPE is a structure with a flexible array member,
- or a union containing such a structure (possibly recursively). */
-
-bool
-flexible_array_type_p (const_tree type)
-{
- tree x, last;
- switch (TREE_CODE (type))
- {
- case RECORD_TYPE:
- last = NULL_TREE;
- for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
- if (TREE_CODE (x) == FIELD_DECL)
- last = x;
- if (last == NULL_TREE)
- return false;
- if (TREE_CODE (TREE_TYPE (last)) == ARRAY_TYPE
- && TYPE_SIZE (TREE_TYPE (last)) == NULL_TREE
- && TYPE_DOMAIN (TREE_TYPE (last)) != NULL_TREE
- && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (last))) == NULL_TREE)
- return true;
- return false;
- case UNION_TYPE:
- for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
- {
- if (TREE_CODE (x) == FIELD_DECL
- && flexible_array_type_p (TREE_TYPE (x)))
- return true;
- }
- return false;
- default:
- return false;
- }
-}
-
-/* Like int_size_in_bytes, but handle empty records specially. */
-
-HOST_WIDE_INT
-arg_int_size_in_bytes (const_tree type)
-{
- return TYPE_EMPTY_P (type) ? 0 : int_size_in_bytes (type);
-}
-
-/* Like size_in_bytes, but handle empty records specially. */
-
-tree
-arg_size_in_bytes (const_tree type)
-{
- return TYPE_EMPTY_P (type) ? size_zero_node : size_in_bytes (type);
-}
-
-/* Return true if an expression with CODE has to have the same result type as
- its first operand. */
-
-bool
-expr_type_first_operand_type_p (tree_code code)
-{
- switch (code)
- {
- case NEGATE_EXPR:
- case ABS_EXPR:
- case BIT_NOT_EXPR:
- case PAREN_EXPR:
- case CONJ_EXPR:
-
- case PLUS_EXPR:
- case MINUS_EXPR:
- case MULT_EXPR:
- case TRUNC_DIV_EXPR:
- case CEIL_DIV_EXPR:
- case FLOOR_DIV_EXPR:
- case ROUND_DIV_EXPR:
- case TRUNC_MOD_EXPR:
- case CEIL_MOD_EXPR:
- case FLOOR_MOD_EXPR:
- case ROUND_MOD_EXPR:
- case RDIV_EXPR:
- case EXACT_DIV_EXPR:
- case MIN_EXPR:
- case MAX_EXPR:
- case BIT_IOR_EXPR:
- case BIT_XOR_EXPR:
- case BIT_AND_EXPR:
-
- case LSHIFT_EXPR:
- case RSHIFT_EXPR:
- case LROTATE_EXPR:
- case RROTATE_EXPR:
- return true;
-
- default:
- return false;
- }
-}
-
-/* Return a typenode for the "standard" C type with a given name. */
-tree
-get_typenode_from_name (const char *name)
-{
- if (name == NULL || *name == '\0')
- return NULL_TREE;
-
- if (strcmp (name, "char") == 0)
- return char_type_node;
- if (strcmp (name, "unsigned char") == 0)
- return unsigned_char_type_node;
- if (strcmp (name, "signed char") == 0)
- return signed_char_type_node;
-
- if (strcmp (name, "short int") == 0)
- return short_integer_type_node;
- if (strcmp (name, "short unsigned int") == 0)
- return short_unsigned_type_node;
-
- if (strcmp (name, "int") == 0)
- return integer_type_node;
- if (strcmp (name, "unsigned int") == 0)
- return unsigned_type_node;
-
- if (strcmp (name, "long int") == 0)
- return long_integer_type_node;
- if (strcmp (name, "long unsigned int") == 0)
- return long_unsigned_type_node;
-
- if (strcmp (name, "long long int") == 0)
- return long_long_integer_type_node;
- if (strcmp (name, "long long unsigned int") == 0)
- return long_long_unsigned_type_node;
-
- gcc_unreachable ();
-}
-
-/* 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" }
-};
-
-/* Return the maximum object size. */
-
-tree
-max_object_size (void)
-{
- /* To do: Make this a configurable parameter. */
- return TYPE_MAX_VALUE (ptrdiff_type_node);
-}
-
-/* A wrapper around TARGET_VERIFY_TYPE_CONTEXT that makes the silent_p
- parameter default to false and that weeds out error_mark_node. */
-
-bool
-verify_type_context (location_t loc, type_context_kind context,
- const_tree type, bool silent_p)
-{
- if (type == error_mark_node)
- return true;
-
- gcc_assert (TYPE_P (type));
- return (!targetm.verify_type_context
- || targetm.verify_type_context (loc, context, type, silent_p));
-}
-
-/* Return true if NEW_ASM and DELETE_ASM name a valid pair of new and
- delete operators. Return false if they may or may not name such
- a pair and, when nonnull, set *PCERTAIN to true if they certainly
- do not. */
-
-bool
-valid_new_delete_pair_p (tree new_asm, tree delete_asm,
- bool *pcertain /* = NULL */)
-{
- bool certain;
- if (!pcertain)
- pcertain = &certain;
-
- const char *new_name = IDENTIFIER_POINTER (new_asm);
- const char *delete_name = IDENTIFIER_POINTER (delete_asm);
- unsigned int new_len = IDENTIFIER_LENGTH (new_asm);
- unsigned int delete_len = IDENTIFIER_LENGTH (delete_asm);
-
- /* The following failures are due to invalid names so they're not
- considered certain mismatches. */
- *pcertain = false;
-
- if (new_len < 5 || delete_len < 6)
- return false;
- if (new_name[0] == '_')
- ++new_name, --new_len;
- if (new_name[0] == '_')
- ++new_name, --new_len;
- if (delete_name[0] == '_')
- ++delete_name, --delete_len;
- if (delete_name[0] == '_')
- ++delete_name, --delete_len;
- if (new_len < 4 || delete_len < 5)
- return false;
-
- /* The following failures are due to names of user-defined operators
- so they're also not considered certain mismatches. */
-
- /* *_len is now just the length after initial underscores. */
- if (new_name[0] != 'Z' || new_name[1] != 'n')
- return false;
- if (delete_name[0] != 'Z' || delete_name[1] != 'd')
- return false;
-
- /* The following failures are certain mismatches. */
- *pcertain = true;
-
- /* _Znw must match _Zdl, _Zna must match _Zda. */
- if ((new_name[2] != 'w' || delete_name[2] != 'l')
- && (new_name[2] != 'a' || delete_name[2] != 'a'))
- return false;
- /* 'j', 'm' and 'y' correspond to size_t. */
- if (new_name[3] != 'j' && new_name[3] != 'm' && new_name[3] != 'y')
- return false;
- if (delete_name[3] != 'P' || delete_name[4] != 'v')
- return false;
- if (new_len == 4
- || (new_len == 18 && !memcmp (new_name + 4, "RKSt9nothrow_t", 14)))
- {
- /* _ZnXY or _ZnXYRKSt9nothrow_t matches
- _ZdXPv, _ZdXPvY and _ZdXPvRKSt9nothrow_t. */
- if (delete_len == 5)
- return true;
- if (delete_len == 6 && delete_name[5] == new_name[3])
- return true;
- if (delete_len == 19 && !memcmp (delete_name + 5, "RKSt9nothrow_t", 14))
- return true;
- }
- else if ((new_len == 19 && !memcmp (new_name + 4, "St11align_val_t", 15))
- || (new_len == 33
- && !memcmp (new_name + 4, "St11align_val_tRKSt9nothrow_t", 29)))
- {
- /* _ZnXYSt11align_val_t or _ZnXYSt11align_val_tRKSt9nothrow_t matches
- _ZdXPvSt11align_val_t or _ZdXPvYSt11align_val_t or or
- _ZdXPvSt11align_val_tRKSt9nothrow_t. */
- if (delete_len == 20 && !memcmp (delete_name + 5, "St11align_val_t", 15))
- return true;
- if (delete_len == 21
- && delete_name[5] == new_name[3]
- && !memcmp (delete_name + 6, "St11align_val_t", 15))
- return true;
- if (delete_len == 34
- && !memcmp (delete_name + 5, "St11align_val_tRKSt9nothrow_t", 29))
- return true;
- }
-
- /* The negative result is conservative. */
- *pcertain = false;
- return false;
-}
-
-/* Return the zero-based number corresponding to the argument being
- deallocated if FNDECL is a deallocation function or an out-of-bounds
- value if it isn't. */
-
-unsigned
-fndecl_dealloc_argno (tree fndecl)
-{
- /* A call to operator delete isn't recognized as one to a built-in. */
- if (DECL_IS_OPERATOR_DELETE_P (fndecl))
- {
- if (DECL_IS_REPLACEABLE_OPERATOR (fndecl))
- return 0;
-
- /* Avoid placement delete that's not been inlined. */
- tree fname = DECL_ASSEMBLER_NAME (fndecl);
- if (id_equal (fname, "_ZdlPvS_") // ordinary form
- || id_equal (fname, "_ZdaPvS_")) // array form
- return UINT_MAX;
- return 0;
- }
-
- /* TODO: Handle user-defined functions with attribute malloc? Handle
- known non-built-ins like fopen? */
- if (fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
- {
- switch (DECL_FUNCTION_CODE (fndecl))
- {
- case BUILT_IN_FREE:
- case BUILT_IN_REALLOC:
- return 0;
- default:
- break;
- }
- return UINT_MAX;
- }
-
- tree attrs = DECL_ATTRIBUTES (fndecl);
- if (!attrs)
- return UINT_MAX;
-
- for (tree atfree = attrs;
- (atfree = lookup_attribute ("*dealloc", atfree));
- atfree = TREE_CHAIN (atfree))
- {
- tree alloc = TREE_VALUE (atfree);
- if (!alloc)
- continue;
-
- tree pos = TREE_CHAIN (alloc);
- if (!pos)
- return 0;
-
- pos = TREE_VALUE (pos);
- return TREE_INT_CST_LOW (pos) - 1;
- }
-
- return UINT_MAX;
-}
-
-/* If EXPR refers to a character array or pointer declared attribute
- nonstring, return a decl for that array or pointer and set *REF
- to the referenced enclosing object or pointer. Otherwise return
- null. */
-
-tree
-get_attr_nonstring_decl (tree expr, tree *ref)
-{
- tree decl = expr;
- tree var = NULL_TREE;
- if (TREE_CODE (decl) == SSA_NAME)
- {
- gimple *def = SSA_NAME_DEF_STMT (decl);
-
- if (is_gimple_assign (def))
- {
- tree_code code = gimple_assign_rhs_code (def);
- if (code == ADDR_EXPR
- || code == COMPONENT_REF
- || code == VAR_DECL)
- decl = gimple_assign_rhs1 (def);
- }
- else
- var = SSA_NAME_VAR (decl);
- }
-
- if (TREE_CODE (decl) == ADDR_EXPR)
- decl = TREE_OPERAND (decl, 0);
-
- /* To simplify calling code, store the referenced DECL regardless of
- the attribute determined below, but avoid storing the SSA_NAME_VAR
- obtained above (it's not useful for dataflow purposes). */
- if (ref)
- *ref = decl;
-
- /* Use the SSA_NAME_VAR that was determined above to see if it's
- declared nonstring. Otherwise drill down into the referenced
- DECL. */
- if (var)
- decl = var;
- else if (TREE_CODE (decl) == ARRAY_REF)
- decl = TREE_OPERAND (decl, 0);
- else if (TREE_CODE (decl) == COMPONENT_REF)
- decl = TREE_OPERAND (decl, 1);
- else if (TREE_CODE (decl) == MEM_REF)
- return get_attr_nonstring_decl (TREE_OPERAND (decl, 0), ref);
-
- if (DECL_P (decl)
- && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl)))
- return decl;
-
- return NULL_TREE;
-}
-
-#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));
-}
-
-/* Return a new VECTOR_CST node whose type is TYPE and whose values
- are given by VALS. */
-
-static tree
-build_vector (tree type, const vec<tree> &vals MEM_STAT_DECL)
-{
- gcc_assert (known_eq (vals.length (), TYPE_VECTOR_SUBPARTS (type)));
- tree_vector_builder builder (type, vals.length (), 1);
- builder.splice (vals);
- return builder.build ();
-}
-
-/* Check that VECTOR_CST ACTUAL contains the elements in EXPECTED. */
-
-static void
-check_vector_cst (const vec<tree> &expected, tree actual)
-{
- ASSERT_KNOWN_EQ (expected.length (),
- TYPE_VECTOR_SUBPARTS (TREE_TYPE (actual)));
- for (unsigned int i = 0; i < expected.length (); ++i)
- ASSERT_EQ (wi::to_wide (expected[i]),
- wi::to_wide (vector_cst_elt (actual, i)));
-}
-
-/* Check that VECTOR_CST ACTUAL contains NPATTERNS duplicated elements,
- and that its elements match EXPECTED. */
-
-static void
-check_vector_cst_duplicate (const vec<tree> &expected, tree actual,
- unsigned int npatterns)
-{
- ASSERT_EQ (npatterns, VECTOR_CST_NPATTERNS (actual));
- ASSERT_EQ (1, VECTOR_CST_NELTS_PER_PATTERN (actual));
- ASSERT_EQ (npatterns, vector_cst_encoded_nelts (actual));
- ASSERT_TRUE (VECTOR_CST_DUPLICATE_P (actual));
- ASSERT_FALSE (VECTOR_CST_STEPPED_P (actual));
- check_vector_cst (expected, actual);
-}
-
-/* Check that VECTOR_CST ACTUAL contains NPATTERNS foreground elements
- and NPATTERNS background elements, and that its elements match
- EXPECTED. */
-
-static void
-check_vector_cst_fill (const vec<tree> &expected, tree actual,
- unsigned int npatterns)
-{
- ASSERT_EQ (npatterns, VECTOR_CST_NPATTERNS (actual));
- ASSERT_EQ (2, VECTOR_CST_NELTS_PER_PATTERN (actual));
- ASSERT_EQ (2 * npatterns, vector_cst_encoded_nelts (actual));
- ASSERT_FALSE (VECTOR_CST_DUPLICATE_P (actual));
- ASSERT_FALSE (VECTOR_CST_STEPPED_P (actual));
- check_vector_cst (expected, actual);
-}
-
-/* Check that VECTOR_CST ACTUAL contains NPATTERNS stepped patterns,
- and that its elements match EXPECTED. */
-
-static void
-check_vector_cst_stepped (const vec<tree> &expected, tree actual,
- unsigned int npatterns)
-{
- ASSERT_EQ (npatterns, VECTOR_CST_NPATTERNS (actual));
- ASSERT_EQ (3, VECTOR_CST_NELTS_PER_PATTERN (actual));
- ASSERT_EQ (3 * npatterns, vector_cst_encoded_nelts (actual));
- ASSERT_FALSE (VECTOR_CST_DUPLICATE_P (actual));
- ASSERT_TRUE (VECTOR_CST_STEPPED_P (actual));
- check_vector_cst (expected, actual);
-}
-
-/* Test the creation of VECTOR_CSTs. */
-
-static void
-test_vector_cst_patterns (ALONE_CXX_MEM_STAT_INFO)
-{
- auto_vec<tree, 8> elements (8);
- elements.quick_grow (8);
- tree element_type = build_nonstandard_integer_type (16, true);
- tree vector_type = build_vector_type (element_type, 8);
-
- /* Test a simple linear series with a base of 0 and a step of 1:
- { 0, 1, 2, 3, 4, 5, 6, 7 }. */
- for (unsigned int i = 0; i < 8; ++i)
- elements[i] = build_int_cst (element_type, i);
- tree vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_stepped (elements, vector, 1);
-
- /* Try the same with the first element replaced by 100:
- { 100, 1, 2, 3, 4, 5, 6, 7 }. */
- elements[0] = build_int_cst (element_type, 100);
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_stepped (elements, vector, 1);
-
- /* Try a series that wraps around.
- { 100, 65531, 65532, 65533, 65534, 65535, 0, 1 }. */
- for (unsigned int i = 1; i < 8; ++i)
- elements[i] = build_int_cst (element_type, (65530 + i) & 0xffff);
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_stepped (elements, vector, 1);
-
- /* Try a downward series:
- { 100, 79, 78, 77, 76, 75, 75, 73 }. */
- for (unsigned int i = 1; i < 8; ++i)
- elements[i] = build_int_cst (element_type, 80 - i);
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_stepped (elements, vector, 1);
-
- /* Try two interleaved series with different bases and steps:
- { 100, 53, 66, 206, 62, 212, 58, 218 }. */
- elements[1] = build_int_cst (element_type, 53);
- for (unsigned int i = 2; i < 8; i += 2)
- {
- elements[i] = build_int_cst (element_type, 70 - i * 2);
- elements[i + 1] = build_int_cst (element_type, 200 + i * 3);
- }
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_stepped (elements, vector, 2);
-
- /* Try a duplicated value:
- { 100, 100, 100, 100, 100, 100, 100, 100 }. */
- for (unsigned int i = 1; i < 8; ++i)
- elements[i] = elements[0];
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_duplicate (elements, vector, 1);
-
- /* Try an interleaved duplicated value:
- { 100, 55, 100, 55, 100, 55, 100, 55 }. */
- elements[1] = build_int_cst (element_type, 55);
- for (unsigned int i = 2; i < 8; ++i)
- elements[i] = elements[i - 2];
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_duplicate (elements, vector, 2);
-
- /* Try a duplicated value with 2 exceptions
- { 41, 97, 100, 55, 100, 55, 100, 55 }. */
- elements[0] = build_int_cst (element_type, 41);
- elements[1] = build_int_cst (element_type, 97);
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_fill (elements, vector, 2);
-
- /* Try with and without a step
- { 41, 97, 100, 21, 100, 35, 100, 49 }. */
- for (unsigned int i = 3; i < 8; i += 2)
- elements[i] = build_int_cst (element_type, i * 7);
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_stepped (elements, vector, 2);
-
- /* Try a fully-general constant:
- { 41, 97, 100, 21, 100, 9990, 100, 49 }. */
- elements[5] = build_int_cst (element_type, 9990);
- vector = build_vector (vector_type, elements PASS_MEM_STAT);
- check_vector_cst_fill (elements, vector, 4);
-}
-
-/* Verify that STRIP_NOPS (NODE) is EXPECTED.
- Helper function for test_location_wrappers, to deal with STRIP_NOPS
- modifying its argument in-place. */
-
-static void
-check_strip_nops (tree node, tree expected)
-{
- STRIP_NOPS (node);
- ASSERT_EQ (expected, node);
-}
-
-/* Verify location wrappers. */
-
-static void
-test_location_wrappers ()
-{
- location_t loc = BUILTINS_LOCATION;
-
- ASSERT_EQ (NULL_TREE, maybe_wrap_with_location (NULL_TREE, loc));
-
- /* Wrapping a constant. */
- tree int_cst = build_int_cst (integer_type_node, 42);
- ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_cst));
- ASSERT_FALSE (location_wrapper_p (int_cst));
-
- tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc);
- ASSERT_TRUE (location_wrapper_p (wrapped_int_cst));
- ASSERT_EQ (loc, EXPR_LOCATION (wrapped_int_cst));
- ASSERT_EQ (int_cst, tree_strip_any_location_wrapper (wrapped_int_cst));
-
- /* We shouldn't add wrapper nodes for UNKNOWN_LOCATION. */
- ASSERT_EQ (int_cst, maybe_wrap_with_location (int_cst, UNKNOWN_LOCATION));
-
- /* We shouldn't add wrapper nodes for nodes that CAN_HAVE_LOCATION_P. */
- tree cast = build1 (NOP_EXPR, char_type_node, int_cst);
- ASSERT_TRUE (CAN_HAVE_LOCATION_P (cast));
- ASSERT_EQ (cast, maybe_wrap_with_location (cast, loc));
-
- /* Wrapping a STRING_CST. */
- tree string_cst = build_string (4, "foo");
- ASSERT_FALSE (CAN_HAVE_LOCATION_P (string_cst));
- ASSERT_FALSE (location_wrapper_p (string_cst));
-
- tree wrapped_string_cst = maybe_wrap_with_location (string_cst, loc);
- ASSERT_TRUE (location_wrapper_p (wrapped_string_cst));
- ASSERT_EQ (VIEW_CONVERT_EXPR, TREE_CODE (wrapped_string_cst));
- ASSERT_EQ (loc, EXPR_LOCATION (wrapped_string_cst));
- ASSERT_EQ (string_cst, tree_strip_any_location_wrapper (wrapped_string_cst));
-
-
- /* Wrapping a variable. */
- tree int_var = build_decl (UNKNOWN_LOCATION, VAR_DECL,
- get_identifier ("some_int_var"),
- integer_type_node);
- ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_var));
- ASSERT_FALSE (location_wrapper_p (int_var));
-
- tree wrapped_int_var = maybe_wrap_with_location (int_var, loc);
- ASSERT_TRUE (location_wrapper_p (wrapped_int_var));
- ASSERT_EQ (loc, EXPR_LOCATION (wrapped_int_var));
- ASSERT_EQ (int_var, tree_strip_any_location_wrapper (wrapped_int_var));
-
- /* Verify that "reinterpret_cast<int>(some_int_var)" is not a location
- wrapper. */
- tree r_cast = build1 (NON_LVALUE_EXPR, integer_type_node, int_var);
- ASSERT_FALSE (location_wrapper_p (r_cast));
- ASSERT_EQ (r_cast, tree_strip_any_location_wrapper (r_cast));
-
- /* Verify that STRIP_NOPS removes wrappers. */
- check_strip_nops (wrapped_int_cst, int_cst);
- check_strip_nops (wrapped_string_cst, string_cst);
- check_strip_nops (wrapped_int_var, int_var);
-}
-
-/* Test various tree predicates. Verify that location wrappers don't
- affect the results. */
-
-static void
-test_predicates ()
-{
- /* Build various constants and wrappers around them. */
-
- location_t loc = BUILTINS_LOCATION;
-
- tree i_0 = build_int_cst (integer_type_node, 0);
- tree wr_i_0 = maybe_wrap_with_location (i_0, loc);
-
- tree i_1 = build_int_cst (integer_type_node, 1);
- tree wr_i_1 = maybe_wrap_with_location (i_1, loc);
-
- tree i_m1 = build_int_cst (integer_type_node, -1);
- tree wr_i_m1 = maybe_wrap_with_location (i_m1, loc);
-
- tree f_0 = build_real_from_int_cst (float_type_node, i_0);
- tree wr_f_0 = maybe_wrap_with_location (f_0, loc);
- tree f_1 = build_real_from_int_cst (float_type_node, i_1);
- tree wr_f_1 = maybe_wrap_with_location (f_1, loc);
- tree f_m1 = build_real_from_int_cst (float_type_node, i_m1);
- tree wr_f_m1 = maybe_wrap_with_location (f_m1, loc);
-
- tree c_i_0 = build_complex (NULL_TREE, i_0, i_0);
- tree c_i_1 = build_complex (NULL_TREE, i_1, i_0);
- tree c_i_m1 = build_complex (NULL_TREE, i_m1, i_0);
-
- tree c_f_0 = build_complex (NULL_TREE, f_0, f_0);
- tree c_f_1 = build_complex (NULL_TREE, f_1, f_0);
- tree c_f_m1 = build_complex (NULL_TREE, f_m1, f_0);
-
- /* TODO: vector constants. */
-
- /* Test integer_onep. */
- ASSERT_FALSE (integer_onep (i_0));
- ASSERT_FALSE (integer_onep (wr_i_0));
- ASSERT_TRUE (integer_onep (i_1));
- ASSERT_TRUE (integer_onep (wr_i_1));
- ASSERT_FALSE (integer_onep (i_m1));
- ASSERT_FALSE (integer_onep (wr_i_m1));
- ASSERT_FALSE (integer_onep (f_0));
- ASSERT_FALSE (integer_onep (wr_f_0));
- ASSERT_FALSE (integer_onep (f_1));
- ASSERT_FALSE (integer_onep (wr_f_1));
- ASSERT_FALSE (integer_onep (f_m1));
- ASSERT_FALSE (integer_onep (wr_f_m1));
- ASSERT_FALSE (integer_onep (c_i_0));
- ASSERT_TRUE (integer_onep (c_i_1));
- ASSERT_FALSE (integer_onep (c_i_m1));
- ASSERT_FALSE (integer_onep (c_f_0));
- ASSERT_FALSE (integer_onep (c_f_1));
- ASSERT_FALSE (integer_onep (c_f_m1));
-
- /* Test integer_zerop. */
- ASSERT_TRUE (integer_zerop (i_0));
- ASSERT_TRUE (integer_zerop (wr_i_0));
- ASSERT_FALSE (integer_zerop (i_1));
- ASSERT_FALSE (integer_zerop (wr_i_1));
- ASSERT_FALSE (integer_zerop (i_m1));
- ASSERT_FALSE (integer_zerop (wr_i_m1));
- ASSERT_FALSE (integer_zerop (f_0));
- ASSERT_FALSE (integer_zerop (wr_f_0));
- ASSERT_FALSE (integer_zerop (f_1));
- ASSERT_FALSE (integer_zerop (wr_f_1));
- ASSERT_FALSE (integer_zerop (f_m1));
- ASSERT_FALSE (integer_zerop (wr_f_m1));
- ASSERT_TRUE (integer_zerop (c_i_0));
- ASSERT_FALSE (integer_zerop (c_i_1));
- ASSERT_FALSE (integer_zerop (c_i_m1));
- ASSERT_FALSE (integer_zerop (c_f_0));
- ASSERT_FALSE (integer_zerop (c_f_1));
- ASSERT_FALSE (integer_zerop (c_f_m1));
-
- /* Test integer_all_onesp. */
- ASSERT_FALSE (integer_all_onesp (i_0));
- ASSERT_FALSE (integer_all_onesp (wr_i_0));
- ASSERT_FALSE (integer_all_onesp (i_1));
- ASSERT_FALSE (integer_all_onesp (wr_i_1));
- ASSERT_TRUE (integer_all_onesp (i_m1));
- ASSERT_TRUE (integer_all_onesp (wr_i_m1));
- ASSERT_FALSE (integer_all_onesp (f_0));
- ASSERT_FALSE (integer_all_onesp (wr_f_0));
- ASSERT_FALSE (integer_all_onesp (f_1));
- ASSERT_FALSE (integer_all_onesp (wr_f_1));
- ASSERT_FALSE (integer_all_onesp (f_m1));
- ASSERT_FALSE (integer_all_onesp (wr_f_m1));
- ASSERT_FALSE (integer_all_onesp (c_i_0));
- ASSERT_FALSE (integer_all_onesp (c_i_1));
- ASSERT_FALSE (integer_all_onesp (c_i_m1));
- ASSERT_FALSE (integer_all_onesp (c_f_0));
- ASSERT_FALSE (integer_all_onesp (c_f_1));
- ASSERT_FALSE (integer_all_onesp (c_f_m1));
-
- /* Test integer_minus_onep. */
- ASSERT_FALSE (integer_minus_onep (i_0));
- ASSERT_FALSE (integer_minus_onep (wr_i_0));
- ASSERT_FALSE (integer_minus_onep (i_1));
- ASSERT_FALSE (integer_minus_onep (wr_i_1));
- ASSERT_TRUE (integer_minus_onep (i_m1));
- ASSERT_TRUE (integer_minus_onep (wr_i_m1));
- ASSERT_FALSE (integer_minus_onep (f_0));
- ASSERT_FALSE (integer_minus_onep (wr_f_0));
- ASSERT_FALSE (integer_minus_onep (f_1));
- ASSERT_FALSE (integer_minus_onep (wr_f_1));
- ASSERT_FALSE (integer_minus_onep (f_m1));
- ASSERT_FALSE (integer_minus_onep (wr_f_m1));
- ASSERT_FALSE (integer_minus_onep (c_i_0));
- ASSERT_FALSE (integer_minus_onep (c_i_1));
- ASSERT_TRUE (integer_minus_onep (c_i_m1));
- ASSERT_FALSE (integer_minus_onep (c_f_0));
- ASSERT_FALSE (integer_minus_onep (c_f_1));
- ASSERT_FALSE (integer_minus_onep (c_f_m1));
-
- /* Test integer_each_onep. */
- ASSERT_FALSE (integer_each_onep (i_0));
- ASSERT_FALSE (integer_each_onep (wr_i_0));
- ASSERT_TRUE (integer_each_onep (i_1));
- ASSERT_TRUE (integer_each_onep (wr_i_1));
- ASSERT_FALSE (integer_each_onep (i_m1));
- ASSERT_FALSE (integer_each_onep (wr_i_m1));
- ASSERT_FALSE (integer_each_onep (f_0));
- ASSERT_FALSE (integer_each_onep (wr_f_0));
- ASSERT_FALSE (integer_each_onep (f_1));
- ASSERT_FALSE (integer_each_onep (wr_f_1));
- ASSERT_FALSE (integer_each_onep (f_m1));
- ASSERT_FALSE (integer_each_onep (wr_f_m1));
- ASSERT_FALSE (integer_each_onep (c_i_0));
- ASSERT_FALSE (integer_each_onep (c_i_1));
- ASSERT_FALSE (integer_each_onep (c_i_m1));
- ASSERT_FALSE (integer_each_onep (c_f_0));
- ASSERT_FALSE (integer_each_onep (c_f_1));
- ASSERT_FALSE (integer_each_onep (c_f_m1));
-
- /* Test integer_truep. */
- ASSERT_FALSE (integer_truep (i_0));
- ASSERT_FALSE (integer_truep (wr_i_0));
- ASSERT_TRUE (integer_truep (i_1));
- ASSERT_TRUE (integer_truep (wr_i_1));
- ASSERT_FALSE (integer_truep (i_m1));
- ASSERT_FALSE (integer_truep (wr_i_m1));
- ASSERT_FALSE (integer_truep (f_0));
- ASSERT_FALSE (integer_truep (wr_f_0));
- ASSERT_FALSE (integer_truep (f_1));
- ASSERT_FALSE (integer_truep (wr_f_1));
- ASSERT_FALSE (integer_truep (f_m1));
- ASSERT_FALSE (integer_truep (wr_f_m1));
- ASSERT_FALSE (integer_truep (c_i_0));
- ASSERT_TRUE (integer_truep (c_i_1));
- ASSERT_FALSE (integer_truep (c_i_m1));
- ASSERT_FALSE (integer_truep (c_f_0));
- ASSERT_FALSE (integer_truep (c_f_1));
- ASSERT_FALSE (integer_truep (c_f_m1));
-
- /* Test integer_nonzerop. */
- ASSERT_FALSE (integer_nonzerop (i_0));
- ASSERT_FALSE (integer_nonzerop (wr_i_0));
- ASSERT_TRUE (integer_nonzerop (i_1));
- ASSERT_TRUE (integer_nonzerop (wr_i_1));
- ASSERT_TRUE (integer_nonzerop (i_m1));
- ASSERT_TRUE (integer_nonzerop (wr_i_m1));
- ASSERT_FALSE (integer_nonzerop (f_0));
- ASSERT_FALSE (integer_nonzerop (wr_f_0));
- ASSERT_FALSE (integer_nonzerop (f_1));
- ASSERT_FALSE (integer_nonzerop (wr_f_1));
- ASSERT_FALSE (integer_nonzerop (f_m1));
- ASSERT_FALSE (integer_nonzerop (wr_f_m1));
- ASSERT_FALSE (integer_nonzerop (c_i_0));
- ASSERT_TRUE (integer_nonzerop (c_i_1));
- ASSERT_TRUE (integer_nonzerop (c_i_m1));
- ASSERT_FALSE (integer_nonzerop (c_f_0));
- ASSERT_FALSE (integer_nonzerop (c_f_1));
- ASSERT_FALSE (integer_nonzerop (c_f_m1));
-
- /* Test real_zerop. */
- ASSERT_FALSE (real_zerop (i_0));
- ASSERT_FALSE (real_zerop (wr_i_0));
- ASSERT_FALSE (real_zerop (i_1));
- ASSERT_FALSE (real_zerop (wr_i_1));
- ASSERT_FALSE (real_zerop (i_m1));
- ASSERT_FALSE (real_zerop (wr_i_m1));
- ASSERT_TRUE (real_zerop (f_0));
- ASSERT_TRUE (real_zerop (wr_f_0));
- ASSERT_FALSE (real_zerop (f_1));
- ASSERT_FALSE (real_zerop (wr_f_1));
- ASSERT_FALSE (real_zerop (f_m1));
- ASSERT_FALSE (real_zerop (wr_f_m1));
- ASSERT_FALSE (real_zerop (c_i_0));
- ASSERT_FALSE (real_zerop (c_i_1));
- ASSERT_FALSE (real_zerop (c_i_m1));
- ASSERT_TRUE (real_zerop (c_f_0));
- ASSERT_FALSE (real_zerop (c_f_1));
- ASSERT_FALSE (real_zerop (c_f_m1));
-
- /* Test real_onep. */
- ASSERT_FALSE (real_onep (i_0));
- ASSERT_FALSE (real_onep (wr_i_0));
- ASSERT_FALSE (real_onep (i_1));
- ASSERT_FALSE (real_onep (wr_i_1));
- ASSERT_FALSE (real_onep (i_m1));
- ASSERT_FALSE (real_onep (wr_i_m1));
- ASSERT_FALSE (real_onep (f_0));
- ASSERT_FALSE (real_onep (wr_f_0));
- ASSERT_TRUE (real_onep (f_1));
- ASSERT_TRUE (real_onep (wr_f_1));
- ASSERT_FALSE (real_onep (f_m1));
- ASSERT_FALSE (real_onep (wr_f_m1));
- ASSERT_FALSE (real_onep (c_i_0));
- ASSERT_FALSE (real_onep (c_i_1));
- ASSERT_FALSE (real_onep (c_i_m1));
- ASSERT_FALSE (real_onep (c_f_0));
- ASSERT_TRUE (real_onep (c_f_1));
- ASSERT_FALSE (real_onep (c_f_m1));
-
- /* Test real_minus_onep. */
- ASSERT_FALSE (real_minus_onep (i_0));
- ASSERT_FALSE (real_minus_onep (wr_i_0));
- ASSERT_FALSE (real_minus_onep (i_1));
- ASSERT_FALSE (real_minus_onep (wr_i_1));
- ASSERT_FALSE (real_minus_onep (i_m1));
- ASSERT_FALSE (real_minus_onep (wr_i_m1));
- ASSERT_FALSE (real_minus_onep (f_0));
- ASSERT_FALSE (real_minus_onep (wr_f_0));
- ASSERT_FALSE (real_minus_onep (f_1));
- ASSERT_FALSE (real_minus_onep (wr_f_1));
- ASSERT_TRUE (real_minus_onep (f_m1));
- ASSERT_TRUE (real_minus_onep (wr_f_m1));
- ASSERT_FALSE (real_minus_onep (c_i_0));
- ASSERT_FALSE (real_minus_onep (c_i_1));
- ASSERT_FALSE (real_minus_onep (c_i_m1));
- ASSERT_FALSE (real_minus_onep (c_f_0));
- ASSERT_FALSE (real_minus_onep (c_f_1));
- ASSERT_TRUE (real_minus_onep (c_f_m1));
-
- /* Test zerop. */
- ASSERT_TRUE (zerop (i_0));
- ASSERT_TRUE (zerop (wr_i_0));
- ASSERT_FALSE (zerop (i_1));
- ASSERT_FALSE (zerop (wr_i_1));
- ASSERT_FALSE (zerop (i_m1));
- ASSERT_FALSE (zerop (wr_i_m1));
- ASSERT_TRUE (zerop (f_0));
- ASSERT_TRUE (zerop (wr_f_0));
- ASSERT_FALSE (zerop (f_1));
- ASSERT_FALSE (zerop (wr_f_1));
- ASSERT_FALSE (zerop (f_m1));
- ASSERT_FALSE (zerop (wr_f_m1));
- ASSERT_TRUE (zerop (c_i_0));
- ASSERT_FALSE (zerop (c_i_1));
- ASSERT_FALSE (zerop (c_i_m1));
- ASSERT_TRUE (zerop (c_f_0));
- ASSERT_FALSE (zerop (c_f_1));
- ASSERT_FALSE (zerop (c_f_m1));
-
- /* Test tree_expr_nonnegative_p. */
- ASSERT_TRUE (tree_expr_nonnegative_p (i_0));
- ASSERT_TRUE (tree_expr_nonnegative_p (wr_i_0));
- ASSERT_TRUE (tree_expr_nonnegative_p (i_1));
- ASSERT_TRUE (tree_expr_nonnegative_p (wr_i_1));
- ASSERT_FALSE (tree_expr_nonnegative_p (i_m1));
- ASSERT_FALSE (tree_expr_nonnegative_p (wr_i_m1));
- ASSERT_TRUE (tree_expr_nonnegative_p (f_0));
- ASSERT_TRUE (tree_expr_nonnegative_p (wr_f_0));
- ASSERT_TRUE (tree_expr_nonnegative_p (f_1));
- ASSERT_TRUE (tree_expr_nonnegative_p (wr_f_1));
- ASSERT_FALSE (tree_expr_nonnegative_p (f_m1));
- ASSERT_FALSE (tree_expr_nonnegative_p (wr_f_m1));
- ASSERT_FALSE (tree_expr_nonnegative_p (c_i_0));
- ASSERT_FALSE (tree_expr_nonnegative_p (c_i_1));
- ASSERT_FALSE (tree_expr_nonnegative_p (c_i_m1));
- ASSERT_FALSE (tree_expr_nonnegative_p (c_f_0));
- ASSERT_FALSE (tree_expr_nonnegative_p (c_f_1));
- ASSERT_FALSE (tree_expr_nonnegative_p (c_f_m1));
-
- /* Test tree_expr_nonzero_p. */
- ASSERT_FALSE (tree_expr_nonzero_p (i_0));
- ASSERT_FALSE (tree_expr_nonzero_p (wr_i_0));
- ASSERT_TRUE (tree_expr_nonzero_p (i_1));
- ASSERT_TRUE (tree_expr_nonzero_p (wr_i_1));
- ASSERT_TRUE (tree_expr_nonzero_p (i_m1));
- ASSERT_TRUE (tree_expr_nonzero_p (wr_i_m1));
-
- /* Test integer_valued_real_p. */
- ASSERT_FALSE (integer_valued_real_p (i_0));
- ASSERT_TRUE (integer_valued_real_p (f_0));
- ASSERT_TRUE (integer_valued_real_p (wr_f_0));
- ASSERT_TRUE (integer_valued_real_p (f_1));
- ASSERT_TRUE (integer_valued_real_p (wr_f_1));
-
- /* Test integer_pow2p. */
- ASSERT_FALSE (integer_pow2p (i_0));
- ASSERT_TRUE (integer_pow2p (i_1));
- ASSERT_TRUE (integer_pow2p (wr_i_1));
-
- /* Test uniform_integer_cst_p. */
- ASSERT_TRUE (uniform_integer_cst_p (i_0));
- ASSERT_TRUE (uniform_integer_cst_p (wr_i_0));
- ASSERT_TRUE (uniform_integer_cst_p (i_1));
- ASSERT_TRUE (uniform_integer_cst_p (wr_i_1));
- ASSERT_TRUE (uniform_integer_cst_p (i_m1));
- ASSERT_TRUE (uniform_integer_cst_p (wr_i_m1));
- ASSERT_FALSE (uniform_integer_cst_p (f_0));
- ASSERT_FALSE (uniform_integer_cst_p (wr_f_0));
- ASSERT_FALSE (uniform_integer_cst_p (f_1));
- ASSERT_FALSE (uniform_integer_cst_p (wr_f_1));
- ASSERT_FALSE (uniform_integer_cst_p (f_m1));
- ASSERT_FALSE (uniform_integer_cst_p (wr_f_m1));
- ASSERT_FALSE (uniform_integer_cst_p (c_i_0));
- ASSERT_FALSE (uniform_integer_cst_p (c_i_1));
- ASSERT_FALSE (uniform_integer_cst_p (c_i_m1));
- ASSERT_FALSE (uniform_integer_cst_p (c_f_0));
- ASSERT_FALSE (uniform_integer_cst_p (c_f_1));
- ASSERT_FALSE (uniform_integer_cst_p (c_f_m1));
-}
-
-/* Check that string escaping works correctly. */
-
-static void
-test_escaped_strings (void)
-{
- int saved_cutoff;
- escaped_string msg;
-
- msg.escape (NULL);
- /* ASSERT_STREQ does not accept NULL as a valid test
- result, so we have to use ASSERT_EQ instead. */
- ASSERT_EQ (NULL, (const char *) msg);
-
- msg.escape ("");
- ASSERT_STREQ ("", (const char *) msg);
-
- msg.escape ("foobar");
- ASSERT_STREQ ("foobar", (const char *) msg);
-
- /* Ensure that we have -fmessage-length set to 0. */
- saved_cutoff = pp_line_cutoff (global_dc->printer);
- pp_line_cutoff (global_dc->printer) = 0;
-
- msg.escape ("foo\nbar");
- ASSERT_STREQ ("foo\\nbar", (const char *) msg);
-
- msg.escape ("\a\b\f\n\r\t\v");
- ASSERT_STREQ ("\\a\\b\\f\\n\\r\\t\\v", (const char *) msg);
-
- /* Now repeat the tests with -fmessage-length set to 5. */
- pp_line_cutoff (global_dc->printer) = 5;
-
- /* Note that the newline is not translated into an escape. */
- msg.escape ("foo\nbar");
- ASSERT_STREQ ("foo\nbar", (const char *) msg);
-
- msg.escape ("\a\b\f\n\r\t\v");
- ASSERT_STREQ ("\\a\\b\\f\n\\r\\t\\v", (const char *) msg);
-
- /* Restore the original message length setting. */
- pp_line_cutoff (global_dc->printer) = saved_cutoff;
-}
-
-/* Run all of the selftests within this file. */
-
-void
-tree_c_tests ()
-{
- test_integer_constants ();
- test_identifiers ();
- test_labels ();
- test_vector_cst_patterns ();
- test_location_wrappers ();
- test_predicates ();
- test_escaped_strings ();
-}
-
-} // namespace selftest
-
-#endif /* CHECKING_P */
-
-#include "gt-tree.h"
projects / thirdparty / gcc.git / blobdiff