118334Speter/* Language-independent node constructors for parse phase of GNU compiler. 290075Sobrien Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4169689Skan Free Software Foundation, Inc. 518334Speter 690075SobrienThis file is part of GCC. 718334Speter 890075SobrienGCC is free software; you can redistribute it and/or modify it under 990075Sobrienthe terms of the GNU General Public License as published by the Free 1090075SobrienSoftware Foundation; either version 2, or (at your option) any later 1190075Sobrienversion. 1218334Speter 1390075SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1490075SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1590075SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1690075Sobrienfor more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 1990075Sobrienalong with GCC; see the file COPYING. If not, write to the Free 20169689SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 21169689Skan02110-1301, USA. */ 2218334Speter 2318334Speter/* This file contains the low level primitives for operating on tree nodes, 2418334Speter including allocation, list operations, interning of identifiers, 2518334Speter construction of data type nodes and statement nodes, 2618334Speter and construction of type conversion nodes. It also contains 2718334Speter tables index by tree code that describe how to take apart 2818334Speter nodes of that code. 2918334Speter 3018334Speter It is intended to be language-independent, but occasionally 31117395Skan calls language-dependent routines defined (for C) in typecheck.c. */ 3218334Speter 3318334Speter#include "config.h" 3450397Sobrien#include "system.h" 35132718Skan#include "coretypes.h" 36132718Skan#include "tm.h" 3750397Sobrien#include "flags.h" 3850397Sobrien#include "tree.h" 39117395Skan#include "real.h" 4090075Sobrien#include "tm_p.h" 4150397Sobrien#include "function.h" 4250397Sobrien#include "obstack.h" 4350397Sobrien#include "toplev.h" 4490075Sobrien#include "ggc.h" 4590075Sobrien#include "hashtab.h" 4690075Sobrien#include "output.h" 4790075Sobrien#include "target.h" 4890075Sobrien#include "langhooks.h" 49169689Skan#include "tree-iterator.h" 50169689Skan#include "basic-block.h" 51169689Skan#include "tree-flow.h" 52169689Skan#include "params.h" 53169689Skan#include "pointer-set.h" 5418334Speter 55169689Skan/* Each tree code class has an associated string representation. 56169689Skan These must correspond to the tree_code_class entries. */ 57169689Skan 58169689Skanconst char *const tree_code_class_strings[] = 59169689Skan{ 60169689Skan "exceptional", 61169689Skan "constant", 62169689Skan "type", 63169689Skan "declaration", 64169689Skan "reference", 65169689Skan "comparison", 66169689Skan "unary", 67169689Skan "binary", 68169689Skan "statement", 69169689Skan "expression", 70169689Skan}; 71169689Skan 72261188Spfg/* APPLE LOCAL begin 6353006 */ 73261188Spfgtree generic_block_literal_struct_type; 74261188Spfg/* APPLE LOCAL end 6353006 */ 75261188Spfg 7690075Sobrien/* obstack.[ch] explicitly declined to prototype this. */ 77132718Skanextern int _obstack_allocated_p (struct obstack *h, void *obj); 7818334Speter 79117395Skan#ifdef GATHER_STATISTICS 8018334Speter/* Statistics-gathering stuff. */ 8118334Speter 8290075Sobrienint tree_node_counts[(int) all_kinds]; 8390075Sobrienint tree_node_sizes[(int) all_kinds]; 8418334Speter 85132718Skan/* Keep in sync with tree.h:enum tree_node_kind. */ 8690075Sobrienstatic const char * const tree_node_kind_names[] = { 8718334Speter "decls", 8818334Speter "types", 8918334Speter "blocks", 9018334Speter "stmts", 9118334Speter "refs", 9218334Speter "exprs", 9318334Speter "constants", 9418334Speter "identifiers", 9518334Speter "perm_tree_lists", 9618334Speter "temp_tree_lists", 9718334Speter "vecs", 98169689Skan "binfos", 99169689Skan "phi_nodes", 100169689Skan "ssa names", 101169689Skan "constructors", 10218334Speter "random kinds", 10318334Speter "lang_decl kinds", 104169689Skan "lang_type kinds", 105169689Skan "omp clauses" 10618334Speter}; 107117395Skan#endif /* GATHER_STATISTICS */ 10818334Speter 10918334Speter/* Unique id for next decl created. */ 110132718Skanstatic GTY(()) int next_decl_uid; 11118334Speter/* Unique id for next type created. */ 112132718Skanstatic GTY(()) int next_type_uid = 1; 11318334Speter 11490075Sobrien/* Since we cannot rehash a type after it is in the table, we have to 11590075Sobrien keep the hash code. */ 11650397Sobrien 117117395Skanstruct type_hash GTY(()) 11818334Speter{ 11990075Sobrien unsigned long hash; 12090075Sobrien tree type; 12190075Sobrien}; 12218334Speter 12390075Sobrien/* Initial size of the hash table (rounded to next prime). */ 12490075Sobrien#define TYPE_HASH_INITIAL_SIZE 1000 12518334Speter 12690075Sobrien/* Now here is the hash table. When recording a type, it is added to 12790075Sobrien the slot whose index is the hash code. Note that the hash table is 12890075Sobrien used for several kinds of types (function types, array types and 12990075Sobrien array index range types, for now). While all these live in the 13090075Sobrien same table, they are completely independent, and the hash code is 13190075Sobrien computed differently for each of these. */ 13218334Speter 133117395Skanstatic GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash))) 134117395Skan htab_t type_hash_table; 13518334Speter 136169689Skan/* Hash table and temporary node for larger integer const values. */ 137169689Skanstatic GTY (()) tree int_cst_node; 138169689Skanstatic GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node))) 139169689Skan htab_t int_cst_hash_table; 140169689Skan 141169689Skan/* General tree->tree mapping structure for use in hash tables. */ 142169689Skan 143169689Skan 144169689Skanstatic GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map))) 145169689Skan htab_t debug_expr_for_decl; 146169689Skan 147169689Skanstatic GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map))) 148169689Skan htab_t value_expr_for_decl; 149169689Skan 150169689Skanstatic GTY ((if_marked ("tree_int_map_marked_p"), param_is (struct tree_int_map))) 151169689Skan htab_t init_priority_for_decl; 152169689Skan 153169689Skanstatic GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map))) 154169689Skan htab_t restrict_base_for_decl; 155169689Skan 156169689Skanstruct tree_int_map GTY(()) 157169689Skan{ 158169689Skan tree from; 159169689Skan unsigned short to; 160169689Skan}; 161169689Skanstatic unsigned int tree_int_map_hash (const void *); 162169689Skanstatic int tree_int_map_eq (const void *, const void *); 163169689Skanstatic int tree_int_map_marked_p (const void *); 164132718Skanstatic void set_type_quals (tree, int); 165132718Skanstatic int type_hash_eq (const void *, const void *); 166132718Skanstatic hashval_t type_hash_hash (const void *); 167169689Skanstatic hashval_t int_cst_hash_hash (const void *); 168169689Skanstatic int int_cst_hash_eq (const void *, const void *); 169132718Skanstatic void print_type_hash_statistics (void); 170169689Skanstatic void print_debug_expr_statistics (void); 171169689Skanstatic void print_value_expr_statistics (void); 172132718Skanstatic int type_hash_marked_p (const void *); 173169689Skanstatic unsigned int type_hash_list (tree, hashval_t); 174169689Skanstatic unsigned int attribute_hash_list (tree, hashval_t); 17518334Speter 17690075Sobrientree global_trees[TI_MAX]; 17790075Sobrientree integer_types[itk_none]; 178169689Skan 179169689Skanunsigned char tree_contains_struct[256][64]; 180169689Skan 181169689Skan/* Number of operands for each OpenMP clause. */ 182169689Skanunsigned const char omp_clause_num_ops[] = 183169689Skan{ 184169689Skan 0, /* OMP_CLAUSE_ERROR */ 185169689Skan 1, /* OMP_CLAUSE_PRIVATE */ 186169689Skan 1, /* OMP_CLAUSE_SHARED */ 187169689Skan 1, /* OMP_CLAUSE_FIRSTPRIVATE */ 188169689Skan 1, /* OMP_CLAUSE_LASTPRIVATE */ 189169689Skan 4, /* OMP_CLAUSE_REDUCTION */ 190169689Skan 1, /* OMP_CLAUSE_COPYIN */ 191169689Skan 1, /* OMP_CLAUSE_COPYPRIVATE */ 192169689Skan 1, /* OMP_CLAUSE_IF */ 193169689Skan 1, /* OMP_CLAUSE_NUM_THREADS */ 194169689Skan 1, /* OMP_CLAUSE_SCHEDULE */ 195169689Skan 0, /* OMP_CLAUSE_NOWAIT */ 196169689Skan 0, /* OMP_CLAUSE_ORDERED */ 197169689Skan 0 /* OMP_CLAUSE_DEFAULT */ 198169689Skan}; 199169689Skan 200169689Skanconst char * const omp_clause_code_name[] = 201169689Skan{ 202169689Skan "error_clause", 203169689Skan "private", 204169689Skan "shared", 205169689Skan "firstprivate", 206169689Skan "lastprivate", 207169689Skan "reduction", 208169689Skan "copyin", 209169689Skan "copyprivate", 210169689Skan "if", 211169689Skan "num_threads", 212169689Skan "schedule", 213169689Skan "nowait", 214169689Skan "ordered", 215169689Skan "default" 216169689Skan}; 21790075Sobrien 218117395Skan/* Init tree.c. */ 21918334Speter 22018334Spetervoid 221132718Skaninit_ttree (void) 22218334Speter{ 22390075Sobrien /* Initialize the hash table of types. */ 224132718Skan type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash, 225132718Skan type_hash_eq, 0); 226169689Skan 227169689Skan debug_expr_for_decl = htab_create_ggc (512, tree_map_hash, 228169689Skan tree_map_eq, 0); 229169689Skan 230169689Skan value_expr_for_decl = htab_create_ggc (512, tree_map_hash, 231169689Skan tree_map_eq, 0); 232169689Skan init_priority_for_decl = htab_create_ggc (512, tree_int_map_hash, 233169689Skan tree_int_map_eq, 0); 234169689Skan restrict_base_for_decl = htab_create_ggc (256, tree_map_hash, 235169689Skan tree_map_eq, 0); 236169689Skan 237169689Skan int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash, 238169689Skan int_cst_hash_eq, NULL); 239169689Skan 240169689Skan int_cst_node = make_node (INTEGER_CST); 241169689Skan 242169689Skan tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON] = 1; 243169689Skan tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON] = 1; 244169689Skan tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON] = 1; 245169689Skan 246169689Skan 247169689Skan tree_contains_struct[CONST_DECL][TS_DECL_COMMON] = 1; 248169689Skan tree_contains_struct[VAR_DECL][TS_DECL_COMMON] = 1; 249169689Skan tree_contains_struct[PARM_DECL][TS_DECL_COMMON] = 1; 250169689Skan tree_contains_struct[RESULT_DECL][TS_DECL_COMMON] = 1; 251169689Skan tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON] = 1; 252169689Skan tree_contains_struct[TYPE_DECL][TS_DECL_COMMON] = 1; 253169689Skan tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON] = 1; 254169689Skan tree_contains_struct[LABEL_DECL][TS_DECL_COMMON] = 1; 255169689Skan tree_contains_struct[FIELD_DECL][TS_DECL_COMMON] = 1; 256169689Skan 257169689Skan 258169689Skan tree_contains_struct[CONST_DECL][TS_DECL_WRTL] = 1; 259169689Skan tree_contains_struct[VAR_DECL][TS_DECL_WRTL] = 1; 260169689Skan tree_contains_struct[PARM_DECL][TS_DECL_WRTL] = 1; 261169689Skan tree_contains_struct[RESULT_DECL][TS_DECL_WRTL] = 1; 262169689Skan tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL] = 1; 263169689Skan tree_contains_struct[LABEL_DECL][TS_DECL_WRTL] = 1; 264169689Skan 265169689Skan tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL] = 1; 266169689Skan tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL] = 1; 267169689Skan tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL] = 1; 268169689Skan tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL] = 1; 269169689Skan tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL] = 1; 270169689Skan tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL] = 1; 271169689Skan tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL] = 1; 272169689Skan tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL] = 1; 273169689Skan tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL] = 1; 274169689Skan tree_contains_struct[STRUCT_FIELD_TAG][TS_DECL_MINIMAL] = 1; 275169689Skan tree_contains_struct[NAME_MEMORY_TAG][TS_DECL_MINIMAL] = 1; 276169689Skan tree_contains_struct[SYMBOL_MEMORY_TAG][TS_DECL_MINIMAL] = 1; 277169689Skan 278169689Skan tree_contains_struct[STRUCT_FIELD_TAG][TS_MEMORY_TAG] = 1; 279169689Skan tree_contains_struct[NAME_MEMORY_TAG][TS_MEMORY_TAG] = 1; 280169689Skan tree_contains_struct[SYMBOL_MEMORY_TAG][TS_MEMORY_TAG] = 1; 281169689Skan 282169689Skan tree_contains_struct[STRUCT_FIELD_TAG][TS_STRUCT_FIELD_TAG] = 1; 283169689Skan 284169689Skan tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS] = 1; 285169689Skan tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS] = 1; 286169689Skan tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS] = 1; 287169689Skan tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS] = 1; 288169689Skan 289169689Skan tree_contains_struct[VAR_DECL][TS_VAR_DECL] = 1; 290169689Skan tree_contains_struct[FIELD_DECL][TS_FIELD_DECL] = 1; 291169689Skan tree_contains_struct[PARM_DECL][TS_PARM_DECL] = 1; 292169689Skan tree_contains_struct[LABEL_DECL][TS_LABEL_DECL] = 1; 293169689Skan tree_contains_struct[RESULT_DECL][TS_RESULT_DECL] = 1; 294169689Skan tree_contains_struct[CONST_DECL][TS_CONST_DECL] = 1; 295169689Skan tree_contains_struct[TYPE_DECL][TS_TYPE_DECL] = 1; 296169689Skan tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL] = 1; 297169689Skan 298169689Skan lang_hooks.init_ts (); 29918334Speter} 30018334Speter 30118334Speter 302117395Skan/* The name of the object as the assembler will see it (but before any 303117395Skan translations made by ASM_OUTPUT_LABELREF). Often this is the same 304117395Skan as DECL_NAME. It is an IDENTIFIER_NODE. */ 305117395Skantree 306132718Skandecl_assembler_name (tree decl) 30718334Speter{ 308117395Skan if (!DECL_ASSEMBLER_NAME_SET_P (decl)) 309169689Skan lang_hooks.set_decl_assembler_name (decl); 310169689Skan return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name; 31118334Speter} 31218334Speter 313169689Skan/* Compute the number of bytes occupied by a tree with code CODE. 314169689Skan This function cannot be used for TREE_VEC, PHI_NODE, or STRING_CST 315169689Skan codes, which are of variable length. */ 31690075Sobriensize_t 317169689Skantree_code_size (enum tree_code code) 31818334Speter{ 31990075Sobrien switch (TREE_CODE_CLASS (code)) 32090075Sobrien { 321169689Skan case tcc_declaration: /* A decl node */ 322169689Skan { 323169689Skan switch (code) 324169689Skan { 325169689Skan case FIELD_DECL: 326169689Skan return sizeof (struct tree_field_decl); 327169689Skan case PARM_DECL: 328169689Skan return sizeof (struct tree_parm_decl); 329169689Skan case VAR_DECL: 330169689Skan return sizeof (struct tree_var_decl); 331169689Skan case LABEL_DECL: 332169689Skan return sizeof (struct tree_label_decl); 333169689Skan case RESULT_DECL: 334169689Skan return sizeof (struct tree_result_decl); 335169689Skan case CONST_DECL: 336169689Skan return sizeof (struct tree_const_decl); 337169689Skan case TYPE_DECL: 338169689Skan return sizeof (struct tree_type_decl); 339169689Skan case FUNCTION_DECL: 340169689Skan return sizeof (struct tree_function_decl); 341169689Skan case NAME_MEMORY_TAG: 342169689Skan case SYMBOL_MEMORY_TAG: 343169689Skan return sizeof (struct tree_memory_tag); 344169689Skan case STRUCT_FIELD_TAG: 345169689Skan return sizeof (struct tree_struct_field_tag); 346169689Skan default: 347169689Skan return sizeof (struct tree_decl_non_common); 348169689Skan } 349169689Skan } 35050397Sobrien 351169689Skan case tcc_type: /* a type node */ 35290075Sobrien return sizeof (struct tree_type); 35318334Speter 354169689Skan case tcc_reference: /* a reference */ 355169689Skan case tcc_expression: /* an expression */ 356169689Skan case tcc_statement: /* an expression with side effects */ 357169689Skan case tcc_comparison: /* a comparison expression */ 358169689Skan case tcc_unary: /* a unary arithmetic expression */ 359169689Skan case tcc_binary: /* a binary arithmetic expression */ 36090075Sobrien return (sizeof (struct tree_exp) 361169689Skan + (TREE_CODE_LENGTH (code) - 1) * sizeof (char *)); 36218334Speter 363169689Skan case tcc_constant: /* a constant */ 364132718Skan switch (code) 365132718Skan { 366132718Skan case INTEGER_CST: return sizeof (struct tree_int_cst); 367132718Skan case REAL_CST: return sizeof (struct tree_real_cst); 368132718Skan case COMPLEX_CST: return sizeof (struct tree_complex); 369132718Skan case VECTOR_CST: return sizeof (struct tree_vector); 370169689Skan case STRING_CST: gcc_unreachable (); 371132718Skan default: 372169689Skan return lang_hooks.tree_size (code); 373132718Skan } 37418334Speter 375169689Skan case tcc_exceptional: /* something random, like an identifier. */ 376132718Skan switch (code) 377132718Skan { 378132718Skan case IDENTIFIER_NODE: return lang_hooks.identifier_size; 379132718Skan case TREE_LIST: return sizeof (struct tree_list); 38018334Speter 381132718Skan case ERROR_MARK: 382132718Skan case PLACEHOLDER_EXPR: return sizeof (struct tree_common); 383132718Skan 384169689Skan case TREE_VEC: 385169689Skan case OMP_CLAUSE: 386169689Skan case PHI_NODE: gcc_unreachable (); 387169689Skan 388169689Skan case SSA_NAME: return sizeof (struct tree_ssa_name); 389169689Skan 390169689Skan case STATEMENT_LIST: return sizeof (struct tree_statement_list); 391169689Skan case BLOCK: return sizeof (struct tree_block); 392169689Skan case VALUE_HANDLE: return sizeof (struct tree_value_handle); 393169689Skan case CONSTRUCTOR: return sizeof (struct tree_constructor); 394169689Skan 395132718Skan default: 396169689Skan return lang_hooks.tree_size (code); 397132718Skan } 398132718Skan 39990075Sobrien default: 400169689Skan gcc_unreachable (); 40190075Sobrien } 40218334Speter} 40318334Speter 404169689Skan/* Compute the number of bytes occupied by NODE. This routine only 405169689Skan looks at TREE_CODE, except for PHI_NODE and TREE_VEC nodes. */ 406169689Skansize_t 407169689Skantree_size (tree node) 408169689Skan{ 409169689Skan enum tree_code code = TREE_CODE (node); 410169689Skan switch (code) 411169689Skan { 412169689Skan case PHI_NODE: 413169689Skan return (sizeof (struct tree_phi_node) 414169689Skan + (PHI_ARG_CAPACITY (node) - 1) * sizeof (struct phi_arg_d)); 41518334Speter 416169689Skan case TREE_BINFO: 417169689Skan return (offsetof (struct tree_binfo, base_binfos) 418169689Skan + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node))); 419169689Skan 420169689Skan case TREE_VEC: 421169689Skan return (sizeof (struct tree_vec) 422169689Skan + (TREE_VEC_LENGTH (node) - 1) * sizeof(char *)); 423169689Skan 424169689Skan case STRING_CST: 425169689Skan return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1; 426169689Skan 427169689Skan case OMP_CLAUSE: 428169689Skan return (sizeof (struct tree_omp_clause) 429169689Skan + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1) 430169689Skan * sizeof (tree)); 431169689Skan 432169689Skan default: 433169689Skan return tree_code_size (code); 434169689Skan } 435169689Skan} 436169689Skan 437169689Skan/* Return a newly allocated node of code CODE. For decl and type 438169689Skan nodes, some other fields are initialized. The rest of the node is 439169689Skan initialized to zero. This function cannot be used for PHI_NODE, 440169689Skan TREE_VEC or OMP_CLAUSE nodes, which is enforced by asserts in 441169689Skan tree_code_size. 442169689Skan 44318334Speter Achoo! I got a code in the node. */ 44418334Speter 44518334Spetertree 446169689Skanmake_node_stat (enum tree_code code MEM_STAT_DECL) 44718334Speter{ 44890075Sobrien tree t; 449169689Skan enum tree_code_class type = TREE_CODE_CLASS (code); 450169689Skan size_t length = tree_code_size (code); 45150397Sobrien#ifdef GATHER_STATISTICS 45290075Sobrien tree_node_kind kind; 453117395Skan 45418334Speter switch (type) 45518334Speter { 456169689Skan case tcc_declaration: /* A decl node */ 45718334Speter kind = d_kind; 45818334Speter break; 45918334Speter 460169689Skan case tcc_type: /* a type node */ 46118334Speter kind = t_kind; 46218334Speter break; 46318334Speter 464169689Skan case tcc_statement: /* an expression with side effects */ 46518334Speter kind = s_kind; 46690075Sobrien break; 46790075Sobrien 468169689Skan case tcc_reference: /* a reference */ 46918334Speter kind = r_kind; 47090075Sobrien break; 47190075Sobrien 472169689Skan case tcc_expression: /* an expression */ 473169689Skan case tcc_comparison: /* a comparison expression */ 474169689Skan case tcc_unary: /* a unary arithmetic expression */ 475169689Skan case tcc_binary: /* a binary arithmetic expression */ 47618334Speter kind = e_kind; 47718334Speter break; 47818334Speter 479169689Skan case tcc_constant: /* a constant */ 48018334Speter kind = c_kind; 48118334Speter break; 48218334Speter 483169689Skan case tcc_exceptional: /* something random, like an identifier. */ 484169689Skan switch (code) 485169689Skan { 486169689Skan case IDENTIFIER_NODE: 487169689Skan kind = id_kind; 488169689Skan break; 489169689Skan 490169689Skan case TREE_VEC: 491169689Skan kind = vec_kind; 492169689Skan break; 493169689Skan 494169689Skan case TREE_BINFO: 495169689Skan kind = binfo_kind; 496169689Skan break; 497169689Skan 498169689Skan case PHI_NODE: 499169689Skan kind = phi_kind; 500169689Skan break; 501169689Skan 502169689Skan case SSA_NAME: 503169689Skan kind = ssa_name_kind; 504169689Skan break; 505169689Skan 506169689Skan case BLOCK: 507169689Skan kind = b_kind; 508169689Skan break; 509169689Skan 510169689Skan case CONSTRUCTOR: 511169689Skan kind = constr_kind; 512169689Skan break; 513169689Skan 514169689Skan default: 515169689Skan kind = x_kind; 516169689Skan break; 517169689Skan } 51818334Speter break; 519169689Skan 52018334Speter default: 521169689Skan gcc_unreachable (); 52218334Speter } 52318334Speter 52490075Sobrien tree_node_counts[(int) kind]++; 52590075Sobrien tree_node_sizes[(int) kind] += length; 52618334Speter#endif 52718334Speter 528169689Skan if (code == IDENTIFIER_NODE) 529169689Skan t = ggc_alloc_zone_pass_stat (length, &tree_id_zone); 530169689Skan else 531169689Skan t = ggc_alloc_zone_pass_stat (length, &tree_zone); 53290075Sobrien 533132718Skan memset (t, 0, length); 53490075Sobrien 53518334Speter TREE_SET_CODE (t, code); 53618334Speter 53718334Speter switch (type) 53818334Speter { 539169689Skan case tcc_statement: 54018334Speter TREE_SIDE_EFFECTS (t) = 1; 54118334Speter break; 54218334Speter 543169689Skan case tcc_declaration: 544169689Skan if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) 545169689Skan DECL_IN_SYSTEM_HEADER (t) = in_system_header; 546169689Skan if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) 547169689Skan { 548259694Spfg if (code == FUNCTION_DECL) 549259694Spfg { 550259694Spfg DECL_ALIGN (t) = FUNCTION_BOUNDARY; 551259694Spfg DECL_MODE (t) = FUNCTION_MODE; 552259694Spfg } 553259694Spfg else 554169689Skan DECL_ALIGN (t) = 1; 555169689Skan /* We have not yet computed the alias set for this declaration. */ 556169689Skan DECL_POINTER_ALIAS_SET (t) = -1; 557169689Skan } 558132718Skan DECL_SOURCE_LOCATION (t) = input_location; 55918334Speter DECL_UID (t) = next_decl_uid++; 56090075Sobrien 56118334Speter break; 56218334Speter 563169689Skan case tcc_type: 56418334Speter TYPE_UID (t) = next_type_uid++; 565169689Skan TYPE_ALIGN (t) = BITS_PER_UNIT; 56690075Sobrien TYPE_USER_ALIGN (t) = 0; 56718334Speter TYPE_MAIN_VARIANT (t) = t; 56890075Sobrien 56990075Sobrien /* Default to no attributes for type, but let target change that. */ 57018334Speter TYPE_ATTRIBUTES (t) = NULL_TREE; 571169689Skan targetm.set_default_type_attributes (t); 57290075Sobrien 57390075Sobrien /* We have not yet computed the alias set for this type. */ 57450397Sobrien TYPE_ALIAS_SET (t) = -1; 57518334Speter break; 57618334Speter 577169689Skan case tcc_constant: 57818334Speter TREE_CONSTANT (t) = 1; 579169689Skan TREE_INVARIANT (t) = 1; 58018334Speter break; 58172562Sobrien 582169689Skan case tcc_expression: 58372562Sobrien switch (code) 58472562Sobrien { 58572562Sobrien case INIT_EXPR: 58672562Sobrien case MODIFY_EXPR: 58790075Sobrien case VA_ARG_EXPR: 58872562Sobrien case PREDECREMENT_EXPR: 58972562Sobrien case PREINCREMENT_EXPR: 59072562Sobrien case POSTDECREMENT_EXPR: 59172562Sobrien case POSTINCREMENT_EXPR: 59272562Sobrien /* All of these have side-effects, no matter what their 59372562Sobrien operands are. */ 59472562Sobrien TREE_SIDE_EFFECTS (t) = 1; 59572562Sobrien break; 59672562Sobrien 59772562Sobrien default: 59872562Sobrien break; 59972562Sobrien } 60072562Sobrien break; 601169689Skan 602169689Skan default: 603169689Skan /* Other classes need no special treatment. */ 604169689Skan break; 60518334Speter } 60618334Speter 60718334Speter return t; 60818334Speter} 60918334Speter 61090075Sobrien/* Return a new node with the same contents as NODE except that its 61190075Sobrien TREE_CHAIN is zero and it has a fresh uid. */ 61218334Speter 61318334Spetertree 614169689Skancopy_node_stat (tree node MEM_STAT_DECL) 61518334Speter{ 61690075Sobrien tree t; 61790075Sobrien enum tree_code code = TREE_CODE (node); 61890075Sobrien size_t length; 61918334Speter 620169689Skan gcc_assert (code != STATEMENT_LIST); 621169689Skan 62290075Sobrien length = tree_size (node); 623169689Skan t = ggc_alloc_zone_pass_stat (length, &tree_zone); 62452284Sobrien memcpy (t, node, length); 62518334Speter 62690075Sobrien TREE_CHAIN (t) = 0; 62750397Sobrien TREE_ASM_WRITTEN (t) = 0; 628169689Skan TREE_VISITED (t) = 0; 629169689Skan t->common.ann = 0; 63018334Speter 631169689Skan if (TREE_CODE_CLASS (code) == tcc_declaration) 63218334Speter { 633169689Skan DECL_UID (t) = next_decl_uid++; 634169689Skan if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL) 635169689Skan && DECL_HAS_VALUE_EXPR_P (node)) 636169689Skan { 637169689Skan SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node)); 638169689Skan DECL_HAS_VALUE_EXPR_P (t) = 1; 639169689Skan } 640169689Skan if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node)) 641169689Skan { 642169689Skan SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node)); 643169689Skan DECL_HAS_INIT_PRIORITY_P (t) = 1; 644169689Skan } 645169689Skan if (TREE_CODE (node) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (node)) 646169689Skan { 647169689Skan SET_DECL_RESTRICT_BASE (t, DECL_GET_RESTRICT_BASE (node)); 648169689Skan DECL_BASED_ON_RESTRICT_P (t) = 1; 649169689Skan } 650169689Skan } 651169689Skan else if (TREE_CODE_CLASS (code) == tcc_type) 652169689Skan { 65318334Speter TYPE_UID (t) = next_type_uid++; 65450397Sobrien /* The following is so that the debug code for 65550397Sobrien the copy is different from the original type. 65650397Sobrien The two statements usually duplicate each other 65750397Sobrien (because they clear fields of the same union), 65850397Sobrien but the optimizer should catch that. */ 65950397Sobrien TYPE_SYMTAB_POINTER (t) = 0; 66050397Sobrien TYPE_SYMTAB_ADDRESS (t) = 0; 661169689Skan 662169689Skan /* Do not copy the values cache. */ 663169689Skan if (TYPE_CACHED_VALUES_P(t)) 664169689Skan { 665169689Skan TYPE_CACHED_VALUES_P (t) = 0; 666169689Skan TYPE_CACHED_VALUES (t) = NULL_TREE; 667169689Skan } 66818334Speter } 66918334Speter 67018334Speter return t; 67118334Speter} 67218334Speter 67318334Speter/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field. 67418334Speter For example, this can copy a list made of TREE_LIST nodes. */ 67518334Speter 67618334Spetertree 677132718Skancopy_list (tree list) 67818334Speter{ 67918334Speter tree head; 68090075Sobrien tree prev, next; 68118334Speter 68218334Speter if (list == 0) 68318334Speter return 0; 68418334Speter 68518334Speter head = prev = copy_node (list); 68618334Speter next = TREE_CHAIN (list); 68718334Speter while (next) 68818334Speter { 68918334Speter TREE_CHAIN (prev) = copy_node (next); 69018334Speter prev = TREE_CHAIN (prev); 69118334Speter next = TREE_CHAIN (next); 69218334Speter } 69318334Speter return head; 69418334Speter} 69518334Speter 69618334Speter 697169689Skan/* Create an INT_CST node with a LOW value sign extended. */ 69818334Speter 699169689Skantree 700169689Skanbuild_int_cst (tree type, HOST_WIDE_INT low) 701169689Skan{ 702169689Skan return build_int_cst_wide (type, low, low < 0 ? -1 : 0); 703169689Skan} 70418334Speter 705169689Skan/* Create an INT_CST node with a LOW value zero extended. */ 706169689Skan 70718334Spetertree 708169689Skanbuild_int_cstu (tree type, unsigned HOST_WIDE_INT low) 70918334Speter{ 710169689Skan return build_int_cst_wide (type, low, 0); 711169689Skan} 71290075Sobrien 713169689Skan/* Create an INT_CST node with a LOW value in TYPE. The value is sign extended 714169689Skan if it is negative. This function is similar to build_int_cst, but 715169689Skan the extra bits outside of the type precision are cleared. Constants 716169689Skan with these extra bits may confuse the fold so that it detects overflows 717169689Skan even in cases when they do not occur, and in general should be avoided. 718169689Skan We cannot however make this a default behavior of build_int_cst without 719169689Skan more intrusive changes, since there are parts of gcc that rely on the extra 720169689Skan precision of the integer constants. */ 721169689Skan 722169689Skantree 723169689Skanbuild_int_cst_type (tree type, HOST_WIDE_INT low) 724169689Skan{ 725169689Skan unsigned HOST_WIDE_INT val = (unsigned HOST_WIDE_INT) low; 726169689Skan unsigned HOST_WIDE_INT hi, mask; 727169689Skan unsigned bits; 728169689Skan bool signed_p; 729169689Skan bool negative; 730169689Skan 731169689Skan if (!type) 732169689Skan type = integer_type_node; 733169689Skan 734169689Skan bits = TYPE_PRECISION (type); 735169689Skan signed_p = !TYPE_UNSIGNED (type); 736169689Skan 737169689Skan if (bits >= HOST_BITS_PER_WIDE_INT) 738169689Skan negative = (low < 0); 739169689Skan else 740169689Skan { 741169689Skan /* If the sign bit is inside precision of LOW, use it to determine 742169689Skan the sign of the constant. */ 743169689Skan negative = ((val >> (bits - 1)) & 1) != 0; 744169689Skan 745169689Skan /* Mask out the bits outside of the precision of the constant. */ 746169689Skan mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1; 747169689Skan 748169689Skan if (signed_p && negative) 749169689Skan val |= ~mask; 750169689Skan else 751169689Skan val &= mask; 752169689Skan } 753169689Skan 754169689Skan /* Determine the high bits. */ 755169689Skan hi = (negative ? ~(unsigned HOST_WIDE_INT) 0 : 0); 756169689Skan 757169689Skan /* For unsigned type we need to mask out the bits outside of the type 758169689Skan precision. */ 759169689Skan if (!signed_p) 760169689Skan { 761169689Skan if (bits <= HOST_BITS_PER_WIDE_INT) 762169689Skan hi = 0; 763169689Skan else 764169689Skan { 765169689Skan bits -= HOST_BITS_PER_WIDE_INT; 766169689Skan mask = (((unsigned HOST_WIDE_INT) 2) << (bits - 1)) - 1; 767169689Skan hi &= mask; 768169689Skan } 769169689Skan } 770169689Skan 771169689Skan return build_int_cst_wide (type, val, hi); 772169689Skan} 773169689Skan 774169689Skan/* These are the hash table functions for the hash table of INTEGER_CST 775169689Skan nodes of a sizetype. */ 776169689Skan 777169689Skan/* Return the hash code code X, an INTEGER_CST. */ 778169689Skan 779169689Skanstatic hashval_t 780169689Skanint_cst_hash_hash (const void *x) 781169689Skan{ 782169689Skan tree t = (tree) x; 783169689Skan 784169689Skan return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t) 785169689Skan ^ htab_hash_pointer (TREE_TYPE (t))); 786169689Skan} 787169689Skan 788169689Skan/* Return nonzero if the value represented by *X (an INTEGER_CST tree node) 789169689Skan is the same as that given by *Y, which is the same. */ 790169689Skan 791169689Skanstatic int 792169689Skanint_cst_hash_eq (const void *x, const void *y) 793169689Skan{ 794169689Skan tree xt = (tree) x; 795169689Skan tree yt = (tree) y; 796169689Skan 797169689Skan return (TREE_TYPE (xt) == TREE_TYPE (yt) 798169689Skan && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt) 799169689Skan && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt)); 800169689Skan} 801169689Skan 802169689Skan/* Create an INT_CST node of TYPE and value HI:LOW. If TYPE is NULL, 803169689Skan integer_type_node is used. The returned node is always shared. 804169689Skan For small integers we use a per-type vector cache, for larger ones 805169689Skan we use a single hash table. */ 806169689Skan 807169689Skantree 808169689Skanbuild_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi) 809169689Skan{ 810169689Skan tree t; 811169689Skan int ix = -1; 812169689Skan int limit = 0; 813169689Skan 814169689Skan if (!type) 815169689Skan type = integer_type_node; 816169689Skan 817169689Skan switch (TREE_CODE (type)) 818169689Skan { 819169689Skan case POINTER_TYPE: 820169689Skan case REFERENCE_TYPE: 821169689Skan /* Cache NULL pointer. */ 822169689Skan if (!hi && !low) 823169689Skan { 824169689Skan limit = 1; 825169689Skan ix = 0; 826169689Skan } 827169689Skan break; 828169689Skan 829169689Skan case BOOLEAN_TYPE: 830169689Skan /* Cache false or true. */ 831169689Skan limit = 2; 832169689Skan if (!hi && low < 2) 833169689Skan ix = low; 834169689Skan break; 835169689Skan 836169689Skan case INTEGER_TYPE: 837169689Skan case OFFSET_TYPE: 838169689Skan if (TYPE_UNSIGNED (type)) 839169689Skan { 840169689Skan /* Cache 0..N */ 841169689Skan limit = INTEGER_SHARE_LIMIT; 842169689Skan if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT) 843169689Skan ix = low; 844169689Skan } 845169689Skan else 846169689Skan { 847169689Skan /* Cache -1..N */ 848169689Skan limit = INTEGER_SHARE_LIMIT + 1; 849169689Skan if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT) 850169689Skan ix = low + 1; 851169689Skan else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1) 852169689Skan ix = 0; 853169689Skan } 854169689Skan break; 855169689Skan default: 856169689Skan break; 857169689Skan } 858169689Skan 859169689Skan if (ix >= 0) 860169689Skan { 861169689Skan /* Look for it in the type's vector of small shared ints. */ 862169689Skan if (!TYPE_CACHED_VALUES_P (type)) 863169689Skan { 864169689Skan TYPE_CACHED_VALUES_P (type) = 1; 865169689Skan TYPE_CACHED_VALUES (type) = make_tree_vec (limit); 866169689Skan } 867169689Skan 868169689Skan t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix); 869169689Skan if (t) 870169689Skan { 871169689Skan /* Make sure no one is clobbering the shared constant. */ 872169689Skan gcc_assert (TREE_TYPE (t) == type); 873169689Skan gcc_assert (TREE_INT_CST_LOW (t) == low); 874169689Skan gcc_assert (TREE_INT_CST_HIGH (t) == hi); 875169689Skan } 876169689Skan else 877169689Skan { 878169689Skan /* Create a new shared int. */ 879169689Skan t = make_node (INTEGER_CST); 880169689Skan 881169689Skan TREE_INT_CST_LOW (t) = low; 882169689Skan TREE_INT_CST_HIGH (t) = hi; 883169689Skan TREE_TYPE (t) = type; 884169689Skan 885169689Skan TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t; 886169689Skan } 887169689Skan } 888169689Skan else 889169689Skan { 890169689Skan /* Use the cache of larger shared ints. */ 891169689Skan void **slot; 892169689Skan 893169689Skan TREE_INT_CST_LOW (int_cst_node) = low; 894169689Skan TREE_INT_CST_HIGH (int_cst_node) = hi; 895169689Skan TREE_TYPE (int_cst_node) = type; 896169689Skan 897169689Skan slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT); 898169689Skan t = *slot; 899169689Skan if (!t) 900169689Skan { 901169689Skan /* Insert this one into the hash table. */ 902169689Skan t = int_cst_node; 903169689Skan *slot = t; 904169689Skan /* Make a new node for next time round. */ 905169689Skan int_cst_node = make_node (INTEGER_CST); 906169689Skan } 907169689Skan } 908169689Skan 90918334Speter return t; 91018334Speter} 91118334Speter 912169689Skan/* Builds an integer constant in TYPE such that lowest BITS bits are ones 913169689Skan and the rest are zeros. */ 914169689Skan 915169689Skantree 916169689Skanbuild_low_bits_mask (tree type, unsigned bits) 917169689Skan{ 918169689Skan unsigned HOST_WIDE_INT low; 919169689Skan HOST_WIDE_INT high; 920169689Skan unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0; 921169689Skan 922169689Skan gcc_assert (bits <= TYPE_PRECISION (type)); 923169689Skan 924169689Skan if (bits == TYPE_PRECISION (type) 925169689Skan && !TYPE_UNSIGNED (type)) 926169689Skan { 927169689Skan /* Sign extended all-ones mask. */ 928169689Skan low = all_ones; 929169689Skan high = -1; 930169689Skan } 931169689Skan else if (bits <= HOST_BITS_PER_WIDE_INT) 932169689Skan { 933169689Skan low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits); 934169689Skan high = 0; 935169689Skan } 936169689Skan else 937169689Skan { 938169689Skan bits -= HOST_BITS_PER_WIDE_INT; 939169689Skan low = all_ones; 940169689Skan high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits); 941169689Skan } 942169689Skan 943169689Skan return build_int_cst_wide (type, low, high); 944169689Skan} 945169689Skan 946169689Skan/* Checks that X is integer constant that can be expressed in (unsigned) 947169689Skan HOST_WIDE_INT without loss of precision. */ 948169689Skan 949169689Skanbool 950169689Skancst_and_fits_in_hwi (tree x) 951169689Skan{ 952169689Skan if (TREE_CODE (x) != INTEGER_CST) 953169689Skan return false; 954169689Skan 955169689Skan if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT) 956169689Skan return false; 957169689Skan 958169689Skan return (TREE_INT_CST_HIGH (x) == 0 959169689Skan || TREE_INT_CST_HIGH (x) == -1); 960169689Skan} 961169689Skan 96296263Sobrien/* Return a new VECTOR_CST node whose type is TYPE and whose values 963169689Skan are in a list pointed to by VALS. */ 96496263Sobrien 96596263Sobrientree 966132718Skanbuild_vector (tree type, tree vals) 96796263Sobrien{ 96896263Sobrien tree v = make_node (VECTOR_CST); 96996263Sobrien int over1 = 0, over2 = 0; 97096263Sobrien tree link; 97196263Sobrien 97296263Sobrien TREE_VECTOR_CST_ELTS (v) = vals; 97396263Sobrien TREE_TYPE (v) = type; 97496263Sobrien 97596263Sobrien /* Iterate through elements and check for overflow. */ 97696263Sobrien for (link = vals; link; link = TREE_CHAIN (link)) 97796263Sobrien { 97896263Sobrien tree value = TREE_VALUE (link); 97996263Sobrien 980169689Skan /* Don't crash if we get an address constant. */ 981169689Skan if (!CONSTANT_CLASS_P (value)) 982169689Skan continue; 983169689Skan 98496263Sobrien over1 |= TREE_OVERFLOW (value); 98596263Sobrien over2 |= TREE_CONSTANT_OVERFLOW (value); 98696263Sobrien } 987117395Skan 98896263Sobrien TREE_OVERFLOW (v) = over1; 98996263Sobrien TREE_CONSTANT_OVERFLOW (v) = over2; 99096263Sobrien 99196263Sobrien return v; 99296263Sobrien} 99396263Sobrien 994169689Skan/* Return a new VECTOR_CST node whose type is TYPE and whose values 995169689Skan are extracted from V, a vector of CONSTRUCTOR_ELT. */ 996169689Skan 997169689Skantree 998169689Skanbuild_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v) 999169689Skan{ 1000169689Skan tree list = NULL_TREE; 1001169689Skan unsigned HOST_WIDE_INT idx; 1002169689Skan tree value; 1003169689Skan 1004169689Skan FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value) 1005169689Skan list = tree_cons (NULL_TREE, value, list); 1006169689Skan return build_vector (type, nreverse (list)); 1007169689Skan} 1008169689Skan 1009132718Skan/* Return a new CONSTRUCTOR node whose type is TYPE and whose values 1010169689Skan are in the VEC pointed to by VALS. */ 1011132718Skantree 1012169689Skanbuild_constructor (tree type, VEC(constructor_elt,gc) *vals) 1013132718Skan{ 1014132718Skan tree c = make_node (CONSTRUCTOR); 1015132718Skan TREE_TYPE (c) = type; 1016132718Skan CONSTRUCTOR_ELTS (c) = vals; 1017169689Skan return c; 1018169689Skan} 1019132718Skan 1020169689Skan/* Build a CONSTRUCTOR node made of a single initializer, with the specified 1021169689Skan INDEX and VALUE. */ 1022169689Skantree 1023169689Skanbuild_constructor_single (tree type, tree index, tree value) 1024169689Skan{ 1025169689Skan VEC(constructor_elt,gc) *v; 1026169689Skan constructor_elt *elt; 1027169689Skan tree t; 1028169689Skan 1029169689Skan v = VEC_alloc (constructor_elt, gc, 1); 1030169689Skan elt = VEC_quick_push (constructor_elt, v, NULL); 1031169689Skan elt->index = index; 1032169689Skan elt->value = value; 1033169689Skan 1034169689Skan t = build_constructor (type, v); 1035169689Skan TREE_CONSTANT (t) = TREE_CONSTANT (value); 1036169689Skan return t; 1037169689Skan} 1038169689Skan 1039169689Skan 1040169689Skan/* Return a new CONSTRUCTOR node whose type is TYPE and whose values 1041169689Skan are in a list pointed to by VALS. */ 1042169689Skantree 1043169689Skanbuild_constructor_from_list (tree type, tree vals) 1044169689Skan{ 1045169689Skan tree t, val; 1046169689Skan VEC(constructor_elt,gc) *v = NULL; 1047169689Skan bool constant_p = true; 1048169689Skan 1049132718Skan if (vals) 1050132718Skan { 1051169689Skan v = VEC_alloc (constructor_elt, gc, list_length (vals)); 1052169689Skan for (t = vals; t; t = TREE_CHAIN (t)) 1053169689Skan { 1054169689Skan constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL); 1055169689Skan val = TREE_VALUE (t); 1056169689Skan elt->index = TREE_PURPOSE (t); 1057169689Skan elt->value = val; 1058169689Skan if (!TREE_CONSTANT (val)) 1059169689Skan constant_p = false; 1060169689Skan } 1061132718Skan } 1062132718Skan 1063169689Skan t = build_constructor (type, v); 1064169689Skan TREE_CONSTANT (t) = constant_p; 1065169689Skan return t; 1066132718Skan} 1067132718Skan 1068169689Skan 106918334Speter/* Return a new REAL_CST node whose type is TYPE and value is D. */ 107018334Speter 107118334Spetertree 1072132718Skanbuild_real (tree type, REAL_VALUE_TYPE d) 107318334Speter{ 107418334Speter tree v; 1075117395Skan REAL_VALUE_TYPE *dp; 107618334Speter int overflow = 0; 107718334Speter 1078117395Skan /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE. 1079117395Skan Consider doing it via real_convert now. */ 108018334Speter 108118334Speter v = make_node (REAL_CST); 1082117395Skan dp = ggc_alloc (sizeof (REAL_VALUE_TYPE)); 1083117395Skan memcpy (dp, &d, sizeof (REAL_VALUE_TYPE)); 1084117395Skan 108518334Speter TREE_TYPE (v) = type; 1086117395Skan TREE_REAL_CST_PTR (v) = dp; 108718334Speter TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow; 108818334Speter return v; 108918334Speter} 109018334Speter 109118334Speter/* Return a new REAL_CST node whose type is TYPE 109218334Speter and whose value is the integer value of the INTEGER_CST node I. */ 109318334Speter 109418334SpeterREAL_VALUE_TYPE 1095132718Skanreal_value_from_int_cst (tree type, tree i) 109618334Speter{ 109718334Speter REAL_VALUE_TYPE d; 109818334Speter 109990075Sobrien /* Clear all bits of the real value type so that we can later do 110090075Sobrien bitwise comparisons to see if two values are the same. */ 1101132718Skan memset (&d, 0, sizeof d); 110290075Sobrien 1103132718Skan real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode, 1104132718Skan TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i), 1105169689Skan TYPE_UNSIGNED (TREE_TYPE (i))); 110618334Speter return d; 110718334Speter} 110818334Speter 110990075Sobrien/* Given a tree representing an integer constant I, return a tree 1110117395Skan representing the same value as a floating-point constant of type TYPE. */ 111118334Speter 111218334Spetertree 1113132718Skanbuild_real_from_int_cst (tree type, tree i) 111418334Speter{ 111518334Speter tree v; 111618334Speter int overflow = TREE_OVERFLOW (i); 111718334Speter 1118117395Skan v = build_real (type, real_value_from_int_cst (type, i)); 111918334Speter 1120117395Skan TREE_OVERFLOW (v) |= overflow; 1121117395Skan TREE_CONSTANT_OVERFLOW (v) |= overflow; 112218334Speter return v; 112318334Speter} 112418334Speter 112518334Speter/* Return a newly constructed STRING_CST node whose value is 112618334Speter the LEN characters at STR. 112718334Speter The TREE_TYPE is not initialized. */ 112818334Speter 112918334Spetertree 1130132718Skanbuild_string (int len, const char *str) 113118334Speter{ 1132169689Skan tree s; 1133169689Skan size_t length; 113418334Speter 1135169689Skan /* Do not waste bytes provided by padding of struct tree_string. */ 1136169689Skan length = len + offsetof (struct tree_string, str) + 1; 1137169689Skan 1138169689Skan#ifdef GATHER_STATISTICS 1139169689Skan tree_node_counts[(int) c_kind]++; 1140169689Skan tree_node_sizes[(int) c_kind] += length; 1141169689Skan#endif 1142169689Skan 1143169689Skan s = ggc_alloc_tree (length); 1144169689Skan 1145169689Skan memset (s, 0, sizeof (struct tree_common)); 1146169689Skan TREE_SET_CODE (s, STRING_CST); 1147169689Skan TREE_CONSTANT (s) = 1; 1148169689Skan TREE_INVARIANT (s) = 1; 114918334Speter TREE_STRING_LENGTH (s) = len; 1150169689Skan memcpy ((char *) TREE_STRING_POINTER (s), str, len); 1151169689Skan ((char *) TREE_STRING_POINTER (s))[len] = '\0'; 115290075Sobrien 115318334Speter return s; 115418334Speter} 115518334Speter 115618334Speter/* Return a newly constructed COMPLEX_CST node whose value is 115718334Speter specified by the real and imaginary parts REAL and IMAG. 115850397Sobrien Both REAL and IMAG should be constant nodes. TYPE, if specified, 115950397Sobrien will be the type of the COMPLEX_CST; otherwise a new type will be made. */ 116018334Speter 116118334Spetertree 1162132718Skanbuild_complex (tree type, tree real, tree imag) 116318334Speter{ 116490075Sobrien tree t = make_node (COMPLEX_CST); 116518334Speter 116618334Speter TREE_REALPART (t) = real; 116718334Speter TREE_IMAGPART (t) = imag; 116850397Sobrien TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real)); 116918334Speter TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag); 117018334Speter TREE_CONSTANT_OVERFLOW (t) 117118334Speter = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag); 117218334Speter return t; 117318334Speter} 117418334Speter 1175169689Skan/* Return a constant of arithmetic type TYPE which is the 1176169689Skan multiplicative identity of the set TYPE. */ 1177169689Skan 1178169689Skantree 1179169689Skanbuild_one_cst (tree type) 1180169689Skan{ 1181169689Skan switch (TREE_CODE (type)) 1182169689Skan { 1183169689Skan case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE: 1184169689Skan case POINTER_TYPE: case REFERENCE_TYPE: 1185169689Skan case OFFSET_TYPE: 1186169689Skan return build_int_cst (type, 1); 1187169689Skan 1188169689Skan case REAL_TYPE: 1189169689Skan return build_real (type, dconst1); 1190169689Skan 1191169689Skan case VECTOR_TYPE: 1192169689Skan { 1193169689Skan tree scalar, cst; 1194169689Skan int i; 1195169689Skan 1196169689Skan scalar = build_one_cst (TREE_TYPE (type)); 1197169689Skan 1198169689Skan /* Create 'vect_cst_ = {cst,cst,...,cst}' */ 1199169689Skan cst = NULL_TREE; 1200169689Skan for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; ) 1201169689Skan cst = tree_cons (NULL_TREE, scalar, cst); 1202169689Skan 1203169689Skan return build_vector (type, cst); 1204169689Skan } 1205169689Skan 1206169689Skan case COMPLEX_TYPE: 1207169689Skan return build_complex (type, 1208169689Skan build_one_cst (TREE_TYPE (type)), 1209169689Skan fold_convert (TREE_TYPE (type), integer_zero_node)); 1210169689Skan 1211169689Skan default: 1212169689Skan gcc_unreachable (); 1213169689Skan } 1214169689Skan} 1215169689Skan 1216169689Skan/* Build a BINFO with LEN language slots. */ 1217169689Skan 1218169689Skantree 1219169689Skanmake_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL) 1220169689Skan{ 1221169689Skan tree t; 1222169689Skan size_t length = (offsetof (struct tree_binfo, base_binfos) 1223169689Skan + VEC_embedded_size (tree, base_binfos)); 1224169689Skan 1225169689Skan#ifdef GATHER_STATISTICS 1226169689Skan tree_node_counts[(int) binfo_kind]++; 1227169689Skan tree_node_sizes[(int) binfo_kind] += length; 1228169689Skan#endif 1229169689Skan 1230169689Skan t = ggc_alloc_zone_pass_stat (length, &tree_zone); 1231169689Skan 1232169689Skan memset (t, 0, offsetof (struct tree_binfo, base_binfos)); 1233169689Skan 1234169689Skan TREE_SET_CODE (t, TREE_BINFO); 1235169689Skan 1236169689Skan VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos); 1237169689Skan 1238169689Skan return t; 1239169689Skan} 1240169689Skan 1241169689Skan 124218334Speter/* Build a newly constructed TREE_VEC node of length LEN. */ 124350397Sobrien 124418334Spetertree 1245169689Skanmake_tree_vec_stat (int len MEM_STAT_DECL) 124618334Speter{ 124790075Sobrien tree t; 1248117395Skan int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec); 124918334Speter 125018334Speter#ifdef GATHER_STATISTICS 1251117395Skan tree_node_counts[(int) vec_kind]++; 1252117395Skan tree_node_sizes[(int) vec_kind] += length; 125318334Speter#endif 125418334Speter 1255169689Skan t = ggc_alloc_zone_pass_stat (length, &tree_zone); 125618334Speter 1257132718Skan memset (t, 0, length); 1258169689Skan 125918334Speter TREE_SET_CODE (t, TREE_VEC); 126018334Speter TREE_VEC_LENGTH (t) = len; 126118334Speter 126218334Speter return t; 126318334Speter} 126418334Speter 126518334Speter/* Return 1 if EXPR is the integer constant zero or a complex constant 126618334Speter of zero. */ 126718334Speter 126818334Speterint 1269132718Skaninteger_zerop (tree expr) 127018334Speter{ 127118334Speter STRIP_NOPS (expr); 127218334Speter 127318334Speter return ((TREE_CODE (expr) == INTEGER_CST 127418334Speter && TREE_INT_CST_LOW (expr) == 0 127518334Speter && TREE_INT_CST_HIGH (expr) == 0) 127618334Speter || (TREE_CODE (expr) == COMPLEX_CST 127718334Speter && integer_zerop (TREE_REALPART (expr)) 127818334Speter && integer_zerop (TREE_IMAGPART (expr)))); 127918334Speter} 128018334Speter 128118334Speter/* Return 1 if EXPR is the integer constant one or the corresponding 128218334Speter complex constant. */ 128318334Speter 128418334Speterint 1285132718Skaninteger_onep (tree expr) 128618334Speter{ 128718334Speter STRIP_NOPS (expr); 128818334Speter 128918334Speter return ((TREE_CODE (expr) == INTEGER_CST 129018334Speter && TREE_INT_CST_LOW (expr) == 1 129118334Speter && TREE_INT_CST_HIGH (expr) == 0) 129218334Speter || (TREE_CODE (expr) == COMPLEX_CST 129318334Speter && integer_onep (TREE_REALPART (expr)) 129418334Speter && integer_zerop (TREE_IMAGPART (expr)))); 129518334Speter} 129618334Speter 129718334Speter/* Return 1 if EXPR is an integer containing all 1's in as much precision as 129818334Speter it contains. Likewise for the corresponding complex constant. */ 129918334Speter 130018334Speterint 1301132718Skaninteger_all_onesp (tree expr) 130218334Speter{ 130390075Sobrien int prec; 130490075Sobrien int uns; 130518334Speter 130618334Speter STRIP_NOPS (expr); 130718334Speter 130818334Speter if (TREE_CODE (expr) == COMPLEX_CST 130918334Speter && integer_all_onesp (TREE_REALPART (expr)) 131018334Speter && integer_zerop (TREE_IMAGPART (expr))) 131118334Speter return 1; 131218334Speter 1313169689Skan else if (TREE_CODE (expr) != INTEGER_CST) 131418334Speter return 0; 131518334Speter 1316169689Skan uns = TYPE_UNSIGNED (TREE_TYPE (expr)); 1317169689Skan if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0 1318169689Skan && TREE_INT_CST_HIGH (expr) == -1) 1319169689Skan return 1; 132018334Speter if (!uns) 1321169689Skan return 0; 132218334Speter 132318334Speter /* Note that using TYPE_PRECISION here is wrong. We care about the 132418334Speter actual bits, not the (arbitrary) range of the type. */ 132518334Speter prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))); 132618334Speter if (prec >= HOST_BITS_PER_WIDE_INT) 132718334Speter { 132890075Sobrien HOST_WIDE_INT high_value; 132990075Sobrien int shift_amount; 133018334Speter 133118334Speter shift_amount = prec - HOST_BITS_PER_WIDE_INT; 133218334Speter 1333169689Skan /* Can not handle precisions greater than twice the host int size. */ 1334169689Skan gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT); 1335169689Skan if (shift_amount == HOST_BITS_PER_WIDE_INT) 133618334Speter /* Shifting by the host word size is undefined according to the ANSI 133718334Speter standard, so we must handle this as a special case. */ 133818334Speter high_value = -1; 133918334Speter else 134018334Speter high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1; 134118334Speter 134290075Sobrien return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0 134390075Sobrien && TREE_INT_CST_HIGH (expr) == high_value); 134418334Speter } 134518334Speter else 134690075Sobrien return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1; 134718334Speter} 134818334Speter 134918334Speter/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only 135018334Speter one bit on). */ 135118334Speter 135218334Speterint 1353132718Skaninteger_pow2p (tree expr) 135418334Speter{ 135550397Sobrien int prec; 135618334Speter HOST_WIDE_INT high, low; 135718334Speter 135818334Speter STRIP_NOPS (expr); 135918334Speter 136018334Speter if (TREE_CODE (expr) == COMPLEX_CST 136118334Speter && integer_pow2p (TREE_REALPART (expr)) 136218334Speter && integer_zerop (TREE_IMAGPART (expr))) 136318334Speter return 1; 136418334Speter 1365169689Skan if (TREE_CODE (expr) != INTEGER_CST) 136618334Speter return 0; 136718334Speter 136850397Sobrien prec = (POINTER_TYPE_P (TREE_TYPE (expr)) 136950397Sobrien ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr))); 137018334Speter high = TREE_INT_CST_HIGH (expr); 137118334Speter low = TREE_INT_CST_LOW (expr); 137218334Speter 137350397Sobrien /* First clear all bits that are beyond the type's precision in case 137450397Sobrien we've been sign extended. */ 137550397Sobrien 137650397Sobrien if (prec == 2 * HOST_BITS_PER_WIDE_INT) 137750397Sobrien ; 137850397Sobrien else if (prec > HOST_BITS_PER_WIDE_INT) 137950397Sobrien high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); 138050397Sobrien else 138150397Sobrien { 138250397Sobrien high = 0; 138350397Sobrien if (prec < HOST_BITS_PER_WIDE_INT) 138450397Sobrien low &= ~((HOST_WIDE_INT) (-1) << prec); 138550397Sobrien } 138650397Sobrien 138718334Speter if (high == 0 && low == 0) 138818334Speter return 0; 138918334Speter 139018334Speter return ((high == 0 && (low & (low - 1)) == 0) 139118334Speter || (low == 0 && (high & (high - 1)) == 0)); 139218334Speter} 139318334Speter 1394132718Skan/* Return 1 if EXPR is an integer constant other than zero or a 1395132718Skan complex constant other than zero. */ 1396132718Skan 1397132718Skanint 1398132718Skaninteger_nonzerop (tree expr) 1399132718Skan{ 1400132718Skan STRIP_NOPS (expr); 1401132718Skan 1402132718Skan return ((TREE_CODE (expr) == INTEGER_CST 1403132718Skan && (TREE_INT_CST_LOW (expr) != 0 1404132718Skan || TREE_INT_CST_HIGH (expr) != 0)) 1405132718Skan || (TREE_CODE (expr) == COMPLEX_CST 1406132718Skan && (integer_nonzerop (TREE_REALPART (expr)) 1407132718Skan || integer_nonzerop (TREE_IMAGPART (expr))))); 1408132718Skan} 1409132718Skan 141050397Sobrien/* Return the power of two represented by a tree node known to be a 141150397Sobrien power of two. */ 141250397Sobrien 141350397Sobrienint 1414132718Skantree_log2 (tree expr) 141550397Sobrien{ 141650397Sobrien int prec; 141750397Sobrien HOST_WIDE_INT high, low; 141850397Sobrien 141950397Sobrien STRIP_NOPS (expr); 142050397Sobrien 142150397Sobrien if (TREE_CODE (expr) == COMPLEX_CST) 142250397Sobrien return tree_log2 (TREE_REALPART (expr)); 142350397Sobrien 142450397Sobrien prec = (POINTER_TYPE_P (TREE_TYPE (expr)) 142550397Sobrien ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr))); 142650397Sobrien 142750397Sobrien high = TREE_INT_CST_HIGH (expr); 142850397Sobrien low = TREE_INT_CST_LOW (expr); 142950397Sobrien 143050397Sobrien /* First clear all bits that are beyond the type's precision in case 143150397Sobrien we've been sign extended. */ 143250397Sobrien 143350397Sobrien if (prec == 2 * HOST_BITS_PER_WIDE_INT) 143450397Sobrien ; 143550397Sobrien else if (prec > HOST_BITS_PER_WIDE_INT) 143650397Sobrien high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); 143750397Sobrien else 143850397Sobrien { 143950397Sobrien high = 0; 144050397Sobrien if (prec < HOST_BITS_PER_WIDE_INT) 144150397Sobrien low &= ~((HOST_WIDE_INT) (-1) << prec); 144250397Sobrien } 144350397Sobrien 144450397Sobrien return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high) 144590075Sobrien : exact_log2 (low)); 144650397Sobrien} 144750397Sobrien 144890075Sobrien/* Similar, but return the largest integer Y such that 2 ** Y is less 144990075Sobrien than or equal to EXPR. */ 145090075Sobrien 145190075Sobrienint 1452132718Skantree_floor_log2 (tree expr) 145390075Sobrien{ 145490075Sobrien int prec; 145590075Sobrien HOST_WIDE_INT high, low; 145690075Sobrien 145790075Sobrien STRIP_NOPS (expr); 145890075Sobrien 145990075Sobrien if (TREE_CODE (expr) == COMPLEX_CST) 146090075Sobrien return tree_log2 (TREE_REALPART (expr)); 146190075Sobrien 146290075Sobrien prec = (POINTER_TYPE_P (TREE_TYPE (expr)) 146390075Sobrien ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr))); 146490075Sobrien 146590075Sobrien high = TREE_INT_CST_HIGH (expr); 146690075Sobrien low = TREE_INT_CST_LOW (expr); 146790075Sobrien 146890075Sobrien /* First clear all bits that are beyond the type's precision in case 146990075Sobrien we've been sign extended. Ignore if type's precision hasn't been set 147090075Sobrien since what we are doing is setting it. */ 147190075Sobrien 147290075Sobrien if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0) 147390075Sobrien ; 147490075Sobrien else if (prec > HOST_BITS_PER_WIDE_INT) 147590075Sobrien high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT)); 147690075Sobrien else 147790075Sobrien { 147890075Sobrien high = 0; 147990075Sobrien if (prec < HOST_BITS_PER_WIDE_INT) 148090075Sobrien low &= ~((HOST_WIDE_INT) (-1) << prec); 148190075Sobrien } 148290075Sobrien 148390075Sobrien return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high) 148490075Sobrien : floor_log2 (low)); 148590075Sobrien} 148690075Sobrien 148718334Speter/* Return 1 if EXPR is the real constant zero. */ 148818334Speter 148918334Speterint 1490132718Skanreal_zerop (tree expr) 149118334Speter{ 149218334Speter STRIP_NOPS (expr); 149318334Speter 149418334Speter return ((TREE_CODE (expr) == REAL_CST 149518334Speter && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)) 149618334Speter || (TREE_CODE (expr) == COMPLEX_CST 149718334Speter && real_zerop (TREE_REALPART (expr)) 149818334Speter && real_zerop (TREE_IMAGPART (expr)))); 149918334Speter} 150018334Speter 150118334Speter/* Return 1 if EXPR is the real constant one in real or complex form. */ 150218334Speter 150318334Speterint 1504132718Skanreal_onep (tree expr) 150518334Speter{ 150618334Speter STRIP_NOPS (expr); 150718334Speter 150818334Speter return ((TREE_CODE (expr) == REAL_CST 150918334Speter && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)) 151018334Speter || (TREE_CODE (expr) == COMPLEX_CST 151118334Speter && real_onep (TREE_REALPART (expr)) 151218334Speter && real_zerop (TREE_IMAGPART (expr)))); 151318334Speter} 151418334Speter 151518334Speter/* Return 1 if EXPR is the real constant two. */ 151618334Speter 151718334Speterint 1518132718Skanreal_twop (tree expr) 151918334Speter{ 152018334Speter STRIP_NOPS (expr); 152118334Speter 152218334Speter return ((TREE_CODE (expr) == REAL_CST 152318334Speter && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)) 152418334Speter || (TREE_CODE (expr) == COMPLEX_CST 152518334Speter && real_twop (TREE_REALPART (expr)) 152618334Speter && real_zerop (TREE_IMAGPART (expr)))); 152718334Speter} 152818334Speter 1529117395Skan/* Return 1 if EXPR is the real constant minus one. */ 1530117395Skan 1531117395Skanint 1532132718Skanreal_minus_onep (tree expr) 1533117395Skan{ 1534117395Skan STRIP_NOPS (expr); 1535117395Skan 1536117395Skan return ((TREE_CODE (expr) == REAL_CST 1537117395Skan && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)) 1538117395Skan || (TREE_CODE (expr) == COMPLEX_CST 1539117395Skan && real_minus_onep (TREE_REALPART (expr)) 1540117395Skan && real_zerop (TREE_IMAGPART (expr)))); 1541117395Skan} 1542117395Skan 154318334Speter/* Nonzero if EXP is a constant or a cast of a constant. */ 154490075Sobrien 154518334Speterint 1546132718Skanreally_constant_p (tree exp) 154718334Speter{ 154818334Speter /* This is not quite the same as STRIP_NOPS. It does more. */ 154918334Speter while (TREE_CODE (exp) == NOP_EXPR 155018334Speter || TREE_CODE (exp) == CONVERT_EXPR 155118334Speter || TREE_CODE (exp) == NON_LVALUE_EXPR) 155218334Speter exp = TREE_OPERAND (exp, 0); 155318334Speter return TREE_CONSTANT (exp); 155418334Speter} 155518334Speter 155618334Speter/* Return first list element whose TREE_VALUE is ELEM. 155718334Speter Return 0 if ELEM is not in LIST. */ 155818334Speter 155918334Spetertree 1560132718Skanvalue_member (tree elem, tree list) 156118334Speter{ 156218334Speter while (list) 156318334Speter { 156418334Speter if (elem == TREE_VALUE (list)) 156518334Speter return list; 156618334Speter list = TREE_CHAIN (list); 156718334Speter } 156818334Speter return NULL_TREE; 156918334Speter} 157018334Speter 157118334Speter/* Return first list element whose TREE_PURPOSE is ELEM. 157218334Speter Return 0 if ELEM is not in LIST. */ 157318334Speter 157418334Spetertree 1575132718Skanpurpose_member (tree elem, tree list) 157618334Speter{ 157718334Speter while (list) 157818334Speter { 157918334Speter if (elem == TREE_PURPOSE (list)) 158018334Speter return list; 158118334Speter list = TREE_CHAIN (list); 158218334Speter } 158318334Speter return NULL_TREE; 158418334Speter} 158518334Speter 158650397Sobrien/* Return nonzero if ELEM is part of the chain CHAIN. */ 158718334Speter 158818334Speterint 1589132718Skanchain_member (tree elem, tree chain) 159018334Speter{ 159118334Speter while (chain) 159218334Speter { 159318334Speter if (elem == chain) 159418334Speter return 1; 159518334Speter chain = TREE_CHAIN (chain); 159618334Speter } 159718334Speter 159818334Speter return 0; 159918334Speter} 160018334Speter 160118334Speter/* Return the length of a chain of nodes chained through TREE_CHAIN. 160218334Speter We expect a null pointer to mark the end of the chain. 160318334Speter This is the Lisp primitive `length'. */ 160418334Speter 160518334Speterint 1606132718Skanlist_length (tree t) 160718334Speter{ 1608169689Skan tree p = t; 1609169689Skan#ifdef ENABLE_TREE_CHECKING 1610169689Skan tree q = t; 1611169689Skan#endif 161290075Sobrien int len = 0; 161318334Speter 1614169689Skan while (p) 1615169689Skan { 1616169689Skan p = TREE_CHAIN (p); 1617169689Skan#ifdef ENABLE_TREE_CHECKING 1618169689Skan if (len % 2) 1619169689Skan q = TREE_CHAIN (q); 1620169689Skan gcc_assert (p != q); 1621169689Skan#endif 1622169689Skan len++; 1623169689Skan } 162418334Speter 162518334Speter return len; 162618334Speter} 162718334Speter 162890075Sobrien/* Returns the number of FIELD_DECLs in TYPE. */ 162990075Sobrien 163090075Sobrienint 1631132718Skanfields_length (tree type) 163290075Sobrien{ 163390075Sobrien tree t = TYPE_FIELDS (type); 163490075Sobrien int count = 0; 163590075Sobrien 163690075Sobrien for (; t; t = TREE_CHAIN (t)) 163790075Sobrien if (TREE_CODE (t) == FIELD_DECL) 163890075Sobrien ++count; 163990075Sobrien 164090075Sobrien return count; 164190075Sobrien} 164290075Sobrien 164318334Speter/* Concatenate two chains of nodes (chained through TREE_CHAIN) 164418334Speter by modifying the last node in chain 1 to point to chain 2. 164518334Speter This is the Lisp primitive `nconc'. */ 164618334Speter 164718334Spetertree 1648132718Skanchainon (tree op1, tree op2) 164918334Speter{ 1650132718Skan tree t1; 165118334Speter 1652132718Skan if (!op1) 1653132718Skan return op2; 1654132718Skan if (!op2) 1655132718Skan return op1; 1656132718Skan 1657132718Skan for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1)) 1658132718Skan continue; 1659132718Skan TREE_CHAIN (t1) = op2; 1660132718Skan 166190075Sobrien#ifdef ENABLE_TREE_CHECKING 1662132718Skan { 1663132718Skan tree t2; 1664132718Skan for (t2 = op2; t2; t2 = TREE_CHAIN (t2)) 1665169689Skan gcc_assert (t2 != t1); 1666132718Skan } 166790075Sobrien#endif 166818334Speter 1669132718Skan return op1; 167018334Speter} 167118334Speter 167218334Speter/* Return the last node in a chain of nodes (chained through TREE_CHAIN). */ 167318334Speter 167418334Spetertree 1675132718Skantree_last (tree chain) 167618334Speter{ 167790075Sobrien tree next; 167818334Speter if (chain) 167950397Sobrien while ((next = TREE_CHAIN (chain))) 168018334Speter chain = next; 168118334Speter return chain; 168218334Speter} 168318334Speter 168418334Speter/* Reverse the order of elements in the chain T, 168518334Speter and return the new head of the chain (old last element). */ 168618334Speter 168718334Spetertree 1688132718Skannreverse (tree t) 168918334Speter{ 169090075Sobrien tree prev = 0, decl, next; 169118334Speter for (decl = t; decl; decl = next) 169218334Speter { 169318334Speter next = TREE_CHAIN (decl); 169418334Speter TREE_CHAIN (decl) = prev; 169518334Speter prev = decl; 169618334Speter } 169718334Speter return prev; 169818334Speter} 169918334Speter 170018334Speter/* Return a newly created TREE_LIST node whose 170118334Speter purpose and value fields are PARM and VALUE. */ 170218334Speter 170318334Spetertree 1704169689Skanbuild_tree_list_stat (tree parm, tree value MEM_STAT_DECL) 170518334Speter{ 1706169689Skan tree t = make_node_stat (TREE_LIST PASS_MEM_STAT); 170718334Speter TREE_PURPOSE (t) = parm; 170818334Speter TREE_VALUE (t) = value; 170918334Speter return t; 171018334Speter} 171118334Speter 171218334Speter/* Return a newly created TREE_LIST node whose 1713132718Skan purpose and value fields are PURPOSE and VALUE 171418334Speter and whose TREE_CHAIN is CHAIN. */ 171518334Speter 171618334Spetertree 1717169689Skantree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL) 171818334Speter{ 171990075Sobrien tree node; 172090075Sobrien 1721169689Skan node = ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone); 172290075Sobrien 172390075Sobrien memset (node, 0, sizeof (struct tree_common)); 172490075Sobrien 172518334Speter#ifdef GATHER_STATISTICS 172690075Sobrien tree_node_counts[(int) x_kind]++; 172790075Sobrien tree_node_sizes[(int) x_kind] += sizeof (struct tree_list); 172818334Speter#endif 172918334Speter 173018334Speter TREE_SET_CODE (node, TREE_LIST); 173118334Speter TREE_CHAIN (node) = chain; 173218334Speter TREE_PURPOSE (node) = purpose; 173318334Speter TREE_VALUE (node) = value; 173418334Speter return node; 173518334Speter} 173618334Speter 173718334Speter 173818334Speter/* Return the size nominally occupied by an object of type TYPE 173918334Speter when it resides in memory. The value is measured in units of bytes, 174018334Speter and its data type is that normally used for type sizes 174118334Speter (which is the first type created by make_signed_type or 174218334Speter make_unsigned_type). */ 174318334Speter 174418334Spetertree 1745132718Skansize_in_bytes (tree type) 174618334Speter{ 174718334Speter tree t; 174818334Speter 174918334Speter if (type == error_mark_node) 175018334Speter return integer_zero_node; 175150397Sobrien 175218334Speter type = TYPE_MAIN_VARIANT (type); 175350397Sobrien t = TYPE_SIZE_UNIT (type); 175490075Sobrien 175550397Sobrien if (t == 0) 175618334Speter { 1757169689Skan lang_hooks.types.incomplete_type_error (NULL_TREE, type); 175890075Sobrien return size_zero_node; 175918334Speter } 176090075Sobrien 176118334Speter if (TREE_CODE (t) == INTEGER_CST) 1762169689Skan t = force_fit_type (t, 0, false, false); 176350397Sobrien 176418334Speter return t; 176518334Speter} 176618334Speter 176750397Sobrien/* Return the size of TYPE (in bytes) as a wide integer 176850397Sobrien or return -1 if the size can vary or is larger than an integer. */ 176918334Speter 177050397SobrienHOST_WIDE_INT 1771132718Skanint_size_in_bytes (tree type) 177218334Speter{ 177350397Sobrien tree t; 177450397Sobrien 177518334Speter if (type == error_mark_node) 177618334Speter return 0; 177750397Sobrien 177818334Speter type = TYPE_MAIN_VARIANT (type); 177950397Sobrien t = TYPE_SIZE_UNIT (type); 178050397Sobrien if (t == 0 178150397Sobrien || TREE_CODE (t) != INTEGER_CST 178290075Sobrien || TREE_INT_CST_HIGH (t) != 0 178390075Sobrien /* If the result would appear negative, it's too big to represent. */ 178490075Sobrien || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0) 178518334Speter return -1; 178650397Sobrien 178750397Sobrien return TREE_INT_CST_LOW (t); 178818334Speter} 1789169689Skan 1790169689Skan/* Return the maximum size of TYPE (in bytes) as a wide integer 1791169689Skan or return -1 if the size can vary or is larger than an integer. */ 1792169689Skan 1793169689SkanHOST_WIDE_INT 1794169689Skanmax_int_size_in_bytes (tree type) 1795169689Skan{ 1796169689Skan HOST_WIDE_INT size = -1; 1797169689Skan tree size_tree; 1798169689Skan 1799169689Skan /* If this is an array type, check for a possible MAX_SIZE attached. */ 1800169689Skan 1801169689Skan if (TREE_CODE (type) == ARRAY_TYPE) 1802169689Skan { 1803169689Skan size_tree = TYPE_ARRAY_MAX_SIZE (type); 1804169689Skan 1805169689Skan if (size_tree && host_integerp (size_tree, 1)) 1806169689Skan size = tree_low_cst (size_tree, 1); 1807169689Skan } 1808169689Skan 1809169689Skan /* If we still haven't been able to get a size, see if the language 1810169689Skan can compute a maximum size. */ 1811169689Skan 1812169689Skan if (size == -1) 1813169689Skan { 1814169689Skan size_tree = lang_hooks.types.max_size (type); 1815169689Skan 1816169689Skan if (size_tree && host_integerp (size_tree, 1)) 1817169689Skan size = tree_low_cst (size_tree, 1); 1818169689Skan } 1819169689Skan 1820169689Skan return size; 1821169689Skan} 182218334Speter 182390075Sobrien/* Return the bit position of FIELD, in bits from the start of the record. 182490075Sobrien This is a tree of type bitsizetype. */ 182518334Speter 182690075Sobrientree 1827132718Skanbit_position (tree field) 182890075Sobrien{ 182990075Sobrien return bit_from_pos (DECL_FIELD_OFFSET (field), 183090075Sobrien DECL_FIELD_BIT_OFFSET (field)); 183190075Sobrien} 183290075Sobrien 1833169689Skan/* Likewise, but return as an integer. It must be representable in 1834169689Skan that way (since it could be a signed value, we don't have the 1835169689Skan option of returning -1 like int_size_in_byte can. */ 183690075Sobrien 183790075SobrienHOST_WIDE_INT 1838132718Skanint_bit_position (tree field) 183990075Sobrien{ 184090075Sobrien return tree_low_cst (bit_position (field), 0); 184190075Sobrien} 184290075Sobrien 184390075Sobrien/* Return the byte position of FIELD, in bytes from the start of the record. 184490075Sobrien This is a tree of type sizetype. */ 184590075Sobrien 184618334Spetertree 1847132718Skanbyte_position (tree field) 184890075Sobrien{ 184990075Sobrien return byte_from_pos (DECL_FIELD_OFFSET (field), 185090075Sobrien DECL_FIELD_BIT_OFFSET (field)); 185190075Sobrien} 185290075Sobrien 1853169689Skan/* Likewise, but return as an integer. It must be representable in 1854169689Skan that way (since it could be a signed value, we don't have the 1855169689Skan option of returning -1 like int_size_in_byte can. */ 185690075Sobrien 185790075SobrienHOST_WIDE_INT 1858132718Skanint_byte_position (tree field) 185990075Sobrien{ 186090075Sobrien return tree_low_cst (byte_position (field), 0); 186190075Sobrien} 186290075Sobrien 186390075Sobrien/* Return the strictest alignment, in bits, that T is known to have. */ 186490075Sobrien 186590075Sobrienunsigned int 1866132718Skanexpr_align (tree t) 186790075Sobrien{ 186890075Sobrien unsigned int align0, align1; 186990075Sobrien 187090075Sobrien switch (TREE_CODE (t)) 187190075Sobrien { 187290075Sobrien case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR: 187390075Sobrien /* If we have conversions, we know that the alignment of the 187490075Sobrien object must meet each of the alignments of the types. */ 187590075Sobrien align0 = expr_align (TREE_OPERAND (t, 0)); 187690075Sobrien align1 = TYPE_ALIGN (TREE_TYPE (t)); 187790075Sobrien return MAX (align0, align1); 187890075Sobrien 187990075Sobrien case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR: 188090075Sobrien case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR: 1881169689Skan case CLEANUP_POINT_EXPR: 188290075Sobrien /* These don't change the alignment of an object. */ 188390075Sobrien return expr_align (TREE_OPERAND (t, 0)); 188490075Sobrien 188590075Sobrien case COND_EXPR: 188690075Sobrien /* The best we can do is say that the alignment is the least aligned 188790075Sobrien of the two arms. */ 188890075Sobrien align0 = expr_align (TREE_OPERAND (t, 1)); 188990075Sobrien align1 = expr_align (TREE_OPERAND (t, 2)); 189090075Sobrien return MIN (align0, align1); 189190075Sobrien 1892259694Spfg /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set 1893259694Spfg meaningfully, it's always 1. */ 189490075Sobrien case LABEL_DECL: case CONST_DECL: 189590075Sobrien case VAR_DECL: case PARM_DECL: case RESULT_DECL: 189690075Sobrien case FUNCTION_DECL: 1897259694Spfg gcc_assert (DECL_ALIGN (t) != 0); 1898259694Spfg return DECL_ALIGN (t); 189990075Sobrien 190090075Sobrien default: 190190075Sobrien break; 190290075Sobrien } 190390075Sobrien 190490075Sobrien /* Otherwise take the alignment from that of the type. */ 190590075Sobrien return TYPE_ALIGN (TREE_TYPE (t)); 190690075Sobrien} 190790075Sobrien 190890075Sobrien/* Return, as a tree node, the number of elements for TYPE (which is an 190990075Sobrien ARRAY_TYPE) minus one. This counts only elements of the top array. */ 191090075Sobrien 191190075Sobrientree 1912132718Skanarray_type_nelts (tree type) 191318334Speter{ 191450397Sobrien tree index_type, min, max; 191518334Speter 191650397Sobrien /* If they did it with unspecified bounds, then we should have already 191750397Sobrien given an error about it before we got here. */ 191850397Sobrien if (! TYPE_DOMAIN (type)) 191950397Sobrien return error_mark_node; 192050397Sobrien 192150397Sobrien index_type = TYPE_DOMAIN (type); 192250397Sobrien min = TYPE_MIN_VALUE (index_type); 192350397Sobrien max = TYPE_MAX_VALUE (index_type); 192450397Sobrien 192550397Sobrien return (integer_zerop (min) 192650397Sobrien ? max 1927169689Skan : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min)); 192818334Speter} 192918334Speter 1930169689Skan/* If arg is static -- a reference to an object in static storage -- then 1931169689Skan return the object. This is not the same as the C meaning of `static'. 1932169689Skan If arg isn't static, return NULL. */ 193318334Speter 1934169689Skantree 1935132718Skanstaticp (tree arg) 193618334Speter{ 193718334Speter switch (TREE_CODE (arg)) 193818334Speter { 193918334Speter case FUNCTION_DECL: 1940169689Skan /* Nested functions are static, even though taking their address will 1941169689Skan involve a trampoline as we unnest the nested function and create 1942169689Skan the trampoline on the tree level. */ 1943169689Skan return arg; 194450397Sobrien 194518334Speter case VAR_DECL: 1946117395Skan return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg)) 1947169689Skan && ! DECL_THREAD_LOCAL_P (arg) 1948169689Skan && ! DECL_DLLIMPORT_P (arg) 1949169689Skan ? arg : NULL); 195018334Speter 1951169689Skan case CONST_DECL: 1952169689Skan return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg)) 1953169689Skan ? arg : NULL); 1954169689Skan 195518334Speter case CONSTRUCTOR: 1956169689Skan return TREE_STATIC (arg) ? arg : NULL; 195718334Speter 195890075Sobrien case LABEL_DECL: 195918334Speter case STRING_CST: 1960169689Skan return arg; 196118334Speter 1962169689Skan case COMPONENT_REF: 1963169689Skan /* If the thing being referenced is not a field, then it is 1964169689Skan something language specific. */ 1965169689Skan if (TREE_CODE (TREE_OPERAND (arg, 1)) != FIELD_DECL) 1966169689Skan return (*lang_hooks.staticp) (arg); 1967169689Skan 196850397Sobrien /* If we are referencing a bitfield, we can't evaluate an 196950397Sobrien ADDR_EXPR at compile time and so it isn't a constant. */ 1970169689Skan if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1))) 1971169689Skan return NULL; 197250397Sobrien 1973169689Skan return staticp (TREE_OPERAND (arg, 0)); 1974169689Skan 197518334Speter case BIT_FIELD_REF: 1976169689Skan return NULL; 197718334Speter 1978169689Skan case MISALIGNED_INDIRECT_REF: 1979169689Skan case ALIGN_INDIRECT_REF: 198018334Speter case INDIRECT_REF: 1981169689Skan return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL; 198218334Speter 198318334Speter case ARRAY_REF: 198490075Sobrien case ARRAY_RANGE_REF: 198518334Speter if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST 198618334Speter && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST) 198718334Speter return staticp (TREE_OPERAND (arg, 0)); 1988169689Skan else 1989169689Skan return false; 199050397Sobrien 199150397Sobrien default: 199290075Sobrien if ((unsigned int) TREE_CODE (arg) 199390075Sobrien >= (unsigned int) LAST_AND_UNUSED_TREE_CODE) 1994169689Skan return lang_hooks.staticp (arg); 199590075Sobrien else 1996169689Skan return NULL; 199718334Speter } 199818334Speter} 199918334Speter 200018334Speter/* Wrap a SAVE_EXPR around EXPR, if appropriate. 200118334Speter Do this to any expression which may be used in more than one place, 200218334Speter but must be evaluated only once. 200318334Speter 200418334Speter Normally, expand_expr would reevaluate the expression each time. 200518334Speter Calling save_expr produces something that is evaluated and recorded 200618334Speter the first time expand_expr is called on it. Subsequent calls to 200718334Speter expand_expr just reuse the recorded value. 200818334Speter 200918334Speter The call to expand_expr that generates code that actually computes 201018334Speter the value is the first call *at compile time*. Subsequent calls 201118334Speter *at compile time* generate code to use the saved value. 201218334Speter This produces correct result provided that *at run time* control 201318334Speter always flows through the insns made by the first expand_expr 201418334Speter before reaching the other places where the save_expr was evaluated. 201518334Speter You, the caller of save_expr, must make sure this is so. 201618334Speter 201718334Speter Constants, and certain read-only nodes, are returned with no 201818334Speter SAVE_EXPR because that is safe. Expressions containing placeholders 201918334Speter are not touched; see tree.def for an explanation of what these 202018334Speter are used for. */ 202118334Speter 202218334Spetertree 2023132718Skansave_expr (tree expr) 202418334Speter{ 202590075Sobrien tree t = fold (expr); 202690075Sobrien tree inner; 202718334Speter 202818334Speter /* If the tree evaluates to a constant, then we don't want to hide that 202918334Speter fact (i.e. this allows further folding, and direct checks for constants). 203018334Speter However, a read-only object that has side effects cannot be bypassed. 203190075Sobrien Since it is no problem to reevaluate literals, we just return the 203250397Sobrien literal node. */ 2033132718Skan inner = skip_simple_arithmetic (t); 2034169689Skan 2035169689Skan if (TREE_INVARIANT (inner) 203690075Sobrien || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner)) 2037132718Skan || TREE_CODE (inner) == SAVE_EXPR 2038132718Skan || TREE_CODE (inner) == ERROR_MARK) 203918334Speter return t; 204018334Speter 2041132718Skan /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since 204218334Speter it means that the size or offset of some field of an object depends on 204318334Speter the value within another field. 204418334Speter 204518334Speter Note that it must not be the case that T contains both a PLACEHOLDER_EXPR 204618334Speter and some variable since it would then need to be both evaluated once and 204718334Speter evaluated more than once. Front-ends must assure this case cannot 204818334Speter happen by surrounding any such subexpressions in their own SAVE_EXPR 204918334Speter and forcing evaluation at the proper time. */ 2050132718Skan if (contains_placeholder_p (inner)) 205118334Speter return t; 205218334Speter 2053169689Skan t = build1 (SAVE_EXPR, TREE_TYPE (expr), t); 205418334Speter 205518334Speter /* This expression might be placed ahead of a jump to ensure that the 205618334Speter value was computed on both sides of the jump. So make sure it isn't 205718334Speter eliminated as dead. */ 205818334Speter TREE_SIDE_EFFECTS (t) = 1; 2059169689Skan TREE_INVARIANT (t) = 1; 206018334Speter return t; 206118334Speter} 206250397Sobrien 2063132718Skan/* Look inside EXPR and into any simple arithmetic operations. Return 2064132718Skan the innermost non-arithmetic node. */ 2065132718Skan 2066132718Skantree 2067132718Skanskip_simple_arithmetic (tree expr) 2068132718Skan{ 2069132718Skan tree inner; 2070132718Skan 2071132718Skan /* We don't care about whether this can be used as an lvalue in this 2072132718Skan context. */ 2073132718Skan while (TREE_CODE (expr) == NON_LVALUE_EXPR) 2074132718Skan expr = TREE_OPERAND (expr, 0); 2075132718Skan 2076132718Skan /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and 2077132718Skan a constant, it will be more efficient to not make another SAVE_EXPR since 2078132718Skan it will allow better simplification and GCSE will be able to merge the 2079132718Skan computations if they actually occur. */ 2080132718Skan inner = expr; 2081132718Skan while (1) 2082132718Skan { 2083169689Skan if (UNARY_CLASS_P (inner)) 2084132718Skan inner = TREE_OPERAND (inner, 0); 2085169689Skan else if (BINARY_CLASS_P (inner)) 2086132718Skan { 2087169689Skan if (TREE_INVARIANT (TREE_OPERAND (inner, 1))) 2088132718Skan inner = TREE_OPERAND (inner, 0); 2089169689Skan else if (TREE_INVARIANT (TREE_OPERAND (inner, 0))) 2090132718Skan inner = TREE_OPERAND (inner, 1); 2091132718Skan else 2092132718Skan break; 2093132718Skan } 2094132718Skan else 2095132718Skan break; 2096132718Skan } 2097132718Skan 2098132718Skan return inner; 2099132718Skan} 2100132718Skan 2101117395Skan/* Return which tree structure is used by T. */ 2102117395Skan 2103117395Skanenum tree_node_structure_enum 2104132718Skantree_node_structure (tree t) 2105117395Skan{ 2106117395Skan enum tree_code code = TREE_CODE (t); 2107132718Skan 2108117395Skan switch (TREE_CODE_CLASS (code)) 2109169689Skan { 2110169689Skan case tcc_declaration: 2111169689Skan { 2112169689Skan switch (code) 2113169689Skan { 2114169689Skan case FIELD_DECL: 2115169689Skan return TS_FIELD_DECL; 2116169689Skan case PARM_DECL: 2117169689Skan return TS_PARM_DECL; 2118169689Skan case VAR_DECL: 2119169689Skan return TS_VAR_DECL; 2120169689Skan case LABEL_DECL: 2121169689Skan return TS_LABEL_DECL; 2122169689Skan case RESULT_DECL: 2123169689Skan return TS_RESULT_DECL; 2124169689Skan case CONST_DECL: 2125169689Skan return TS_CONST_DECL; 2126169689Skan case TYPE_DECL: 2127169689Skan return TS_TYPE_DECL; 2128169689Skan case FUNCTION_DECL: 2129169689Skan return TS_FUNCTION_DECL; 2130169689Skan case SYMBOL_MEMORY_TAG: 2131169689Skan case NAME_MEMORY_TAG: 2132169689Skan case STRUCT_FIELD_TAG: 2133169689Skan return TS_MEMORY_TAG; 2134169689Skan default: 2135169689Skan return TS_DECL_NON_COMMON; 2136169689Skan } 2137169689Skan } 2138169689Skan case tcc_type: 2139169689Skan return TS_TYPE; 2140169689Skan case tcc_reference: 2141169689Skan case tcc_comparison: 2142169689Skan case tcc_unary: 2143169689Skan case tcc_binary: 2144169689Skan case tcc_expression: 2145169689Skan case tcc_statement: 2146117395Skan return TS_EXP; 2147169689Skan default: /* tcc_constant and tcc_exceptional */ 2148117395Skan break; 2149117395Skan } 2150117395Skan switch (code) 2151117395Skan { 2152169689Skan /* tcc_constant cases. */ 2153117395Skan case INTEGER_CST: return TS_INT_CST; 2154117395Skan case REAL_CST: return TS_REAL_CST; 2155117395Skan case COMPLEX_CST: return TS_COMPLEX; 2156117395Skan case VECTOR_CST: return TS_VECTOR; 2157117395Skan case STRING_CST: return TS_STRING; 2158169689Skan /* tcc_exceptional cases. */ 2159117395Skan case ERROR_MARK: return TS_COMMON; 2160117395Skan case IDENTIFIER_NODE: return TS_IDENTIFIER; 2161117395Skan case TREE_LIST: return TS_LIST; 2162117395Skan case TREE_VEC: return TS_VEC; 2163169689Skan case PHI_NODE: return TS_PHI_NODE; 2164169689Skan case SSA_NAME: return TS_SSA_NAME; 2165117395Skan case PLACEHOLDER_EXPR: return TS_COMMON; 2166169689Skan case STATEMENT_LIST: return TS_STATEMENT_LIST; 2167169689Skan case BLOCK: return TS_BLOCK; 2168169689Skan case CONSTRUCTOR: return TS_CONSTRUCTOR; 2169169689Skan case TREE_BINFO: return TS_BINFO; 2170169689Skan case VALUE_HANDLE: return TS_VALUE_HANDLE; 2171169689Skan case OMP_CLAUSE: return TS_OMP_CLAUSE; 2172117395Skan 2173117395Skan default: 2174169689Skan gcc_unreachable (); 2175117395Skan } 2176117395Skan} 217718334Speter 217818334Speter/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size 217950397Sobrien or offset that depends on a field within a record. */ 218018334Speter 2181132718Skanbool 2182132718Skancontains_placeholder_p (tree exp) 218318334Speter{ 218490075Sobrien enum tree_code code; 218518334Speter 218690075Sobrien if (!exp) 218790075Sobrien return 0; 218890075Sobrien 218990075Sobrien code = TREE_CODE (exp); 2190169689Skan if (code == PLACEHOLDER_EXPR) 219150397Sobrien return 1; 219218334Speter 219318334Speter switch (TREE_CODE_CLASS (code)) 219418334Speter { 2195169689Skan case tcc_reference: 219650397Sobrien /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit 219750397Sobrien position computations since they will be converted into a 219850397Sobrien WITH_RECORD_EXPR involving the reference, which will assume 219950397Sobrien here will be valid. */ 2200132718Skan return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); 220118334Speter 2202169689Skan case tcc_exceptional: 220350397Sobrien if (code == TREE_LIST) 2204132718Skan return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp)) 2205132718Skan || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp))); 220650397Sobrien break; 220790075Sobrien 2208169689Skan case tcc_unary: 2209169689Skan case tcc_binary: 2210169689Skan case tcc_comparison: 2211169689Skan case tcc_expression: 221250397Sobrien switch (code) 221350397Sobrien { 221450397Sobrien case COMPOUND_EXPR: 221590075Sobrien /* Ignoring the first operand isn't quite right, but works best. */ 2216132718Skan return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)); 221750397Sobrien 221850397Sobrien case COND_EXPR: 2219132718Skan return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)) 2220132718Skan || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)) 2221132718Skan || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2))); 222250397Sobrien 222350397Sobrien case CALL_EXPR: 2224132718Skan return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)); 222550397Sobrien 222650397Sobrien default: 222750397Sobrien break; 222850397Sobrien } 222950397Sobrien 223090075Sobrien switch (TREE_CODE_LENGTH (code)) 223118334Speter { 223218334Speter case 1: 2233132718Skan return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)); 223418334Speter case 2: 2235132718Skan return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0)) 2236132718Skan || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))); 223750397Sobrien default: 223850397Sobrien return 0; 223918334Speter } 224050397Sobrien 224150397Sobrien default: 224250397Sobrien return 0; 224318334Speter } 224450397Sobrien return 0; 224550397Sobrien} 224618334Speter 2247169689Skan/* Return true if any part of the computation of TYPE involves a 2248169689Skan PLACEHOLDER_EXPR. This includes size, bounds, qualifiers 2249169689Skan (for QUAL_UNION_TYPE) and field positions. */ 2250132718Skan 2251169689Skanstatic bool 2252169689Skantype_contains_placeholder_1 (tree type) 2253132718Skan{ 2254132718Skan /* If the size contains a placeholder or the parent type (component type in 2255132718Skan the case of arrays) type involves a placeholder, this type does. */ 2256132718Skan if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type)) 2257132718Skan || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type)) 2258132718Skan || (TREE_TYPE (type) != 0 2259132718Skan && type_contains_placeholder_p (TREE_TYPE (type)))) 2260169689Skan return true; 2261132718Skan 2262132718Skan /* Now do type-specific checks. Note that the last part of the check above 2263132718Skan greatly limits what we have to do below. */ 2264132718Skan switch (TREE_CODE (type)) 2265132718Skan { 2266132718Skan case VOID_TYPE: 2267132718Skan case COMPLEX_TYPE: 2268132718Skan case ENUMERAL_TYPE: 2269132718Skan case BOOLEAN_TYPE: 2270132718Skan case POINTER_TYPE: 2271132718Skan case OFFSET_TYPE: 2272132718Skan case REFERENCE_TYPE: 2273132718Skan case METHOD_TYPE: 2274132718Skan case FUNCTION_TYPE: 2275169689Skan case VECTOR_TYPE: 2276169689Skan return false; 2277132718Skan 2278132718Skan case INTEGER_TYPE: 2279132718Skan case REAL_TYPE: 2280132718Skan /* Here we just check the bounds. */ 2281132718Skan return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type)) 2282132718Skan || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type))); 2283132718Skan 2284132718Skan case ARRAY_TYPE: 2285132718Skan /* We're already checked the component type (TREE_TYPE), so just check 2286132718Skan the index type. */ 2287132718Skan return type_contains_placeholder_p (TYPE_DOMAIN (type)); 2288132718Skan 2289132718Skan case RECORD_TYPE: 2290132718Skan case UNION_TYPE: 2291132718Skan case QUAL_UNION_TYPE: 2292132718Skan { 2293132718Skan tree field; 2294132718Skan 2295132718Skan for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 2296132718Skan if (TREE_CODE (field) == FIELD_DECL 2297132718Skan && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field)) 2298132718Skan || (TREE_CODE (type) == QUAL_UNION_TYPE 2299132718Skan && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field))) 2300132718Skan || type_contains_placeholder_p (TREE_TYPE (field)))) 2301169689Skan return true; 2302132718Skan 2303169689Skan return false; 2304132718Skan } 2305132718Skan 2306132718Skan default: 2307169689Skan gcc_unreachable (); 2308132718Skan } 2309132718Skan} 2310132718Skan 2311169689Skanbool 2312169689Skantype_contains_placeholder_p (tree type) 231350397Sobrien{ 2314169689Skan bool result; 231550397Sobrien 2316169689Skan /* If the contains_placeholder_bits field has been initialized, 2317169689Skan then we know the answer. */ 2318169689Skan if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0) 2319169689Skan return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1; 232050397Sobrien 2321169689Skan /* Indicate that we've seen this type node, and the answer is false. 2322169689Skan This is what we want to return if we run into recursion via fields. */ 2323169689Skan TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1; 232450397Sobrien 2325169689Skan /* Compute the real value. */ 2326169689Skan result = type_contains_placeholder_1 (type); 232750397Sobrien 2328169689Skan /* Store the real value. */ 2329169689Skan TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1; 233050397Sobrien 2331169689Skan return result; 233218334Speter} 233318334Speter 233418334Speter/* Given a tree EXP, a FIELD_DECL F, and a replacement value R, 233518334Speter return a tree with all occurrences of references to F in a 233618334Speter PLACEHOLDER_EXPR replaced by R. Note that we assume here that EXP 233750397Sobrien contains only arithmetic expressions or a CALL_EXPR with a 233850397Sobrien PLACEHOLDER_EXPR occurring only in its arglist. */ 233918334Speter 234018334Spetertree 2341132718Skansubstitute_in_expr (tree exp, tree f, tree r) 234218334Speter{ 234318334Speter enum tree_code code = TREE_CODE (exp); 2344169689Skan tree op0, op1, op2, op3; 234550397Sobrien tree new; 234618334Speter tree inner; 234718334Speter 2348169689Skan /* We handle TREE_LIST and COMPONENT_REF separately. */ 2349169689Skan if (code == TREE_LIST) 235018334Speter { 2351169689Skan op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r); 2352169689Skan op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r); 2353169689Skan if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp)) 2354169689Skan return exp; 235518334Speter 2356169689Skan return tree_cons (TREE_PURPOSE (exp), op1, op0); 2357169689Skan } 2358169689Skan else if (code == COMPONENT_REF) 2359169689Skan { 2360169689Skan /* If this expression is getting a value from a PLACEHOLDER_EXPR 2361169689Skan and it is the right field, replace it with R. */ 2362169689Skan for (inner = TREE_OPERAND (exp, 0); 2363169689Skan REFERENCE_CLASS_P (inner); 2364169689Skan inner = TREE_OPERAND (inner, 0)) 2365169689Skan ; 2366169689Skan if (TREE_CODE (inner) == PLACEHOLDER_EXPR 2367169689Skan && TREE_OPERAND (exp, 1) == f) 2368169689Skan return r; 2369169689Skan 2370169689Skan /* If this expression hasn't been completed let, leave it alone. */ 2371169689Skan if (TREE_CODE (inner) == PLACEHOLDER_EXPR && TREE_TYPE (inner) == 0) 2372169689Skan return exp; 2373169689Skan 2374169689Skan op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 2375169689Skan if (op0 == TREE_OPERAND (exp, 0)) 2376169689Skan return exp; 2377169689Skan 2378169689Skan new = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), 2379169689Skan op0, TREE_OPERAND (exp, 1), NULL_TREE); 2380169689Skan } 2381169689Skan else 2382169689Skan switch (TREE_CODE_CLASS (code)) 2383169689Skan { 2384169689Skan case tcc_constant: 2385169689Skan case tcc_declaration: 238618334Speter return exp; 2387169689Skan 2388169689Skan case tcc_exceptional: 2389169689Skan case tcc_unary: 2390169689Skan case tcc_binary: 2391169689Skan case tcc_comparison: 2392169689Skan case tcc_expression: 2393169689Skan case tcc_reference: 2394169689Skan switch (TREE_CODE_LENGTH (code)) 2395169689Skan { 2396169689Skan case 0: 239750397Sobrien return exp; 239818334Speter 2399169689Skan case 1: 2400169689Skan op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 2401169689Skan if (op0 == TREE_OPERAND (exp, 0)) 2402169689Skan return exp; 240350397Sobrien 2404169689Skan new = fold_build1 (code, TREE_TYPE (exp), op0); 2405169689Skan break; 240650397Sobrien 2407169689Skan case 2: 2408169689Skan op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 2409169689Skan op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r); 241090075Sobrien 2411169689Skan if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) 2412169689Skan return exp; 241390075Sobrien 2414169689Skan new = fold_build2 (code, TREE_TYPE (exp), op0, op1); 2415169689Skan break; 241618334Speter 2417169689Skan case 3: 2418169689Skan op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 2419169689Skan op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r); 2420169689Skan op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r); 242118334Speter 2422169689Skan if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 2423169689Skan && op2 == TREE_OPERAND (exp, 2)) 2424169689Skan return exp; 2425132718Skan 2426169689Skan new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); 2427169689Skan break; 242850397Sobrien 2429169689Skan case 4: 2430169689Skan op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r); 2431169689Skan op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r); 2432169689Skan op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r); 2433169689Skan op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r); 243418334Speter 2435169689Skan if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 2436169689Skan && op2 == TREE_OPERAND (exp, 2) 2437169689Skan && op3 == TREE_OPERAND (exp, 3)) 2438169689Skan return exp; 243918334Speter 2440169689Skan new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); 2441169689Skan break; 244250397Sobrien 2443169689Skan default: 2444169689Skan gcc_unreachable (); 2445169689Skan } 2446169689Skan break; 244750397Sobrien 2448169689Skan default: 2449169689Skan gcc_unreachable (); 2450169689Skan } 245118334Speter 2452169689Skan TREE_READONLY (new) = TREE_READONLY (exp); 2453169689Skan return new; 2454169689Skan} 2455132718Skan 2456169689Skan/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement 2457169689Skan for it within OBJ, a tree that is an object or a chain of references. */ 2458132718Skan 2459169689Skantree 2460169689Skansubstitute_placeholder_in_expr (tree exp, tree obj) 2461169689Skan{ 2462169689Skan enum tree_code code = TREE_CODE (exp); 2463169689Skan tree op0, op1, op2, op3; 246450397Sobrien 2465169689Skan /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type 2466169689Skan in the chain of OBJ. */ 2467169689Skan if (code == PLACEHOLDER_EXPR) 2468169689Skan { 2469169689Skan tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp)); 2470169689Skan tree elt; 247150397Sobrien 2472169689Skan for (elt = obj; elt != 0; 2473169689Skan elt = ((TREE_CODE (elt) == COMPOUND_EXPR 2474169689Skan || TREE_CODE (elt) == COND_EXPR) 2475169689Skan ? TREE_OPERAND (elt, 1) 2476169689Skan : (REFERENCE_CLASS_P (elt) 2477169689Skan || UNARY_CLASS_P (elt) 2478169689Skan || BINARY_CLASS_P (elt) 2479169689Skan || EXPRESSION_CLASS_P (elt)) 2480169689Skan ? TREE_OPERAND (elt, 0) : 0)) 2481169689Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type) 2482169689Skan return elt; 248318334Speter 2484169689Skan for (elt = obj; elt != 0; 2485169689Skan elt = ((TREE_CODE (elt) == COMPOUND_EXPR 2486169689Skan || TREE_CODE (elt) == COND_EXPR) 2487169689Skan ? TREE_OPERAND (elt, 1) 2488169689Skan : (REFERENCE_CLASS_P (elt) 2489169689Skan || UNARY_CLASS_P (elt) 2490169689Skan || BINARY_CLASS_P (elt) 2491169689Skan || EXPRESSION_CLASS_P (elt)) 2492169689Skan ? TREE_OPERAND (elt, 0) : 0)) 2493169689Skan if (POINTER_TYPE_P (TREE_TYPE (elt)) 2494169689Skan && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt))) 2495169689Skan == need_type)) 2496169689Skan return fold_build1 (INDIRECT_REF, need_type, elt); 249718334Speter 2498169689Skan /* If we didn't find it, return the original PLACEHOLDER_EXPR. If it 2499169689Skan survives until RTL generation, there will be an error. */ 2500169689Skan return exp; 2501169689Skan } 250218334Speter 2503169689Skan /* TREE_LIST is special because we need to look at TREE_VALUE 2504169689Skan and TREE_CHAIN, not TREE_OPERANDS. */ 2505169689Skan else if (code == TREE_LIST) 2506169689Skan { 2507169689Skan op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj); 2508169689Skan op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj); 2509169689Skan if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp)) 2510169689Skan return exp; 251150397Sobrien 2512169689Skan return tree_cons (TREE_PURPOSE (exp), op1, op0); 2513169689Skan } 2514169689Skan else 2515169689Skan switch (TREE_CODE_CLASS (code)) 2516169689Skan { 2517169689Skan case tcc_constant: 2518169689Skan case tcc_declaration: 2519169689Skan return exp; 2520169689Skan 2521169689Skan case tcc_exceptional: 2522169689Skan case tcc_unary: 2523169689Skan case tcc_binary: 2524169689Skan case tcc_comparison: 2525169689Skan case tcc_expression: 2526169689Skan case tcc_reference: 2527169689Skan case tcc_statement: 2528169689Skan switch (TREE_CODE_LENGTH (code)) 2529169689Skan { 2530169689Skan case 0: 253150397Sobrien return exp; 253250397Sobrien 2533169689Skan case 1: 2534169689Skan op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 2535169689Skan if (op0 == TREE_OPERAND (exp, 0)) 2536169689Skan return exp; 2537169689Skan else 2538169689Skan return fold_build1 (code, TREE_TYPE (exp), op0); 253918334Speter 2540169689Skan case 2: 2541169689Skan op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 2542169689Skan op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj); 254350397Sobrien 2544169689Skan if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) 2545169689Skan return exp; 2546169689Skan else 2547169689Skan return fold_build2 (code, TREE_TYPE (exp), op0, op1); 254818334Speter 2549169689Skan case 3: 2550169689Skan op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 2551169689Skan op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj); 2552169689Skan op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj); 255350397Sobrien 2554169689Skan if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 2555169689Skan && op2 == TREE_OPERAND (exp, 2)) 2556169689Skan return exp; 2557169689Skan else 2558169689Skan return fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); 255918334Speter 2560169689Skan case 4: 2561169689Skan op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj); 2562169689Skan op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj); 2563169689Skan op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj); 2564169689Skan op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj); 256590075Sobrien 2566169689Skan if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1) 2567169689Skan && op2 == TREE_OPERAND (exp, 2) 2568169689Skan && op3 == TREE_OPERAND (exp, 3)) 2569169689Skan return exp; 2570169689Skan else 2571169689Skan return fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); 257218334Speter 2573169689Skan default: 2574169689Skan gcc_unreachable (); 2575169689Skan } 2576169689Skan break; 2577169689Skan 2578169689Skan default: 2579169689Skan gcc_unreachable (); 2580169689Skan } 258118334Speter} 258218334Speter 258318334Speter/* Stabilize a reference so that we can use it any number of times 258418334Speter without causing its operands to be evaluated more than once. 258518334Speter Returns the stabilized reference. This works by means of save_expr, 258618334Speter so see the caveats in the comments about save_expr. 258718334Speter 258818334Speter Also allows conversion expressions whose operands are references. 258918334Speter Any other kind of expression is returned unchanged. */ 259018334Speter 259118334Spetertree 2592132718Skanstabilize_reference (tree ref) 259318334Speter{ 259490075Sobrien tree result; 259590075Sobrien enum tree_code code = TREE_CODE (ref); 259618334Speter 259718334Speter switch (code) 259818334Speter { 259918334Speter case VAR_DECL: 260018334Speter case PARM_DECL: 260118334Speter case RESULT_DECL: 260218334Speter /* No action is needed in this case. */ 260318334Speter return ref; 260418334Speter 260518334Speter case NOP_EXPR: 260618334Speter case CONVERT_EXPR: 260718334Speter case FLOAT_EXPR: 260818334Speter case FIX_TRUNC_EXPR: 260918334Speter case FIX_FLOOR_EXPR: 261018334Speter case FIX_ROUND_EXPR: 261118334Speter case FIX_CEIL_EXPR: 261218334Speter result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0))); 261318334Speter break; 261418334Speter 261518334Speter case INDIRECT_REF: 261618334Speter result = build_nt (INDIRECT_REF, 261718334Speter stabilize_reference_1 (TREE_OPERAND (ref, 0))); 261818334Speter break; 261918334Speter 262018334Speter case COMPONENT_REF: 262118334Speter result = build_nt (COMPONENT_REF, 262218334Speter stabilize_reference (TREE_OPERAND (ref, 0)), 2623169689Skan TREE_OPERAND (ref, 1), NULL_TREE); 262418334Speter break; 262518334Speter 262618334Speter case BIT_FIELD_REF: 262718334Speter result = build_nt (BIT_FIELD_REF, 262818334Speter stabilize_reference (TREE_OPERAND (ref, 0)), 262918334Speter stabilize_reference_1 (TREE_OPERAND (ref, 1)), 263018334Speter stabilize_reference_1 (TREE_OPERAND (ref, 2))); 263118334Speter break; 263218334Speter 263318334Speter case ARRAY_REF: 263418334Speter result = build_nt (ARRAY_REF, 263518334Speter stabilize_reference (TREE_OPERAND (ref, 0)), 2636169689Skan stabilize_reference_1 (TREE_OPERAND (ref, 1)), 2637169689Skan TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); 263818334Speter break; 263918334Speter 264090075Sobrien case ARRAY_RANGE_REF: 264190075Sobrien result = build_nt (ARRAY_RANGE_REF, 264290075Sobrien stabilize_reference (TREE_OPERAND (ref, 0)), 2643169689Skan stabilize_reference_1 (TREE_OPERAND (ref, 1)), 2644169689Skan TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3)); 264590075Sobrien break; 264690075Sobrien 264718334Speter case COMPOUND_EXPR: 264850397Sobrien /* We cannot wrap the first expression in a SAVE_EXPR, as then 264950397Sobrien it wouldn't be ignored. This matters when dealing with 265050397Sobrien volatiles. */ 265150397Sobrien return stabilize_reference_1 (ref); 265218334Speter 265318334Speter /* If arg isn't a kind of lvalue we recognize, make no change. 265418334Speter Caller should recognize the error for an invalid lvalue. */ 265518334Speter default: 265618334Speter return ref; 265718334Speter 265818334Speter case ERROR_MARK: 265918334Speter return error_mark_node; 266018334Speter } 266118334Speter 266218334Speter TREE_TYPE (result) = TREE_TYPE (ref); 266318334Speter TREE_READONLY (result) = TREE_READONLY (ref); 266418334Speter TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref); 266518334Speter TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref); 266618334Speter 266718334Speter return result; 266818334Speter} 266918334Speter 267018334Speter/* Subroutine of stabilize_reference; this is called for subtrees of 267118334Speter references. Any expression with side-effects must be put in a SAVE_EXPR 267218334Speter to ensure that it is only evaluated once. 267318334Speter 267418334Speter We don't put SAVE_EXPR nodes around everything, because assigning very 267518334Speter simple expressions to temporaries causes us to miss good opportunities 267618334Speter for optimizations. Among other things, the opportunity to fold in the 267718334Speter addition of a constant into an addressing mode often gets lost, e.g. 267818334Speter "y[i+1] += x;". In general, we take the approach that we should not make 267918334Speter an assignment unless we are forced into it - i.e., that any non-side effect 268018334Speter operator should be allowed, and that cse should take care of coalescing 268118334Speter multiple utterances of the same expression should that prove fruitful. */ 268218334Speter 268318334Spetertree 2684132718Skanstabilize_reference_1 (tree e) 268518334Speter{ 268690075Sobrien tree result; 268790075Sobrien enum tree_code code = TREE_CODE (e); 268818334Speter 268918334Speter /* We cannot ignore const expressions because it might be a reference 269018334Speter to a const array but whose index contains side-effects. But we can 269118334Speter ignore things that are actual constant or that already have been 269218334Speter handled by this function. */ 269318334Speter 2694169689Skan if (TREE_INVARIANT (e)) 269518334Speter return e; 269618334Speter 269718334Speter switch (TREE_CODE_CLASS (code)) 269818334Speter { 2699169689Skan case tcc_exceptional: 2700169689Skan case tcc_type: 2701169689Skan case tcc_declaration: 2702169689Skan case tcc_comparison: 2703169689Skan case tcc_statement: 2704169689Skan case tcc_expression: 2705169689Skan case tcc_reference: 270618334Speter /* If the expression has side-effects, then encase it in a SAVE_EXPR 270718334Speter so that it will only be evaluated once. */ 270818334Speter /* The reference (r) and comparison (<) classes could be handled as 270918334Speter below, but it is generally faster to only evaluate them once. */ 271018334Speter if (TREE_SIDE_EFFECTS (e)) 271118334Speter return save_expr (e); 271218334Speter return e; 271318334Speter 2714169689Skan case tcc_constant: 271518334Speter /* Constants need no processing. In fact, we should never reach 271618334Speter here. */ 271718334Speter return e; 271890075Sobrien 2719169689Skan case tcc_binary: 272018334Speter /* Division is slow and tends to be compiled with jumps, 272118334Speter especially the division by powers of 2 that is often 272218334Speter found inside of an array reference. So do it just once. */ 272318334Speter if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR 272418334Speter || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR 272518334Speter || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR 272618334Speter || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR) 272718334Speter return save_expr (e); 272818334Speter /* Recursively stabilize each operand. */ 272918334Speter result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)), 273018334Speter stabilize_reference_1 (TREE_OPERAND (e, 1))); 273118334Speter break; 273218334Speter 2733169689Skan case tcc_unary: 273418334Speter /* Recursively stabilize each operand. */ 273518334Speter result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0))); 273618334Speter break; 273718334Speter 273818334Speter default: 2739169689Skan gcc_unreachable (); 274018334Speter } 274190075Sobrien 274218334Speter TREE_TYPE (result) = TREE_TYPE (e); 274318334Speter TREE_READONLY (result) = TREE_READONLY (e); 274418334Speter TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e); 274518334Speter TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e); 2746169689Skan TREE_INVARIANT (result) = 1; 274718334Speter 274818334Speter return result; 274918334Speter} 275018334Speter 275118334Speter/* Low-level constructors for expressions. */ 275218334Speter 2753169689Skan/* A helper function for build1 and constant folders. Set TREE_CONSTANT, 2754169689Skan TREE_INVARIANT, and TREE_SIDE_EFFECTS for an ADDR_EXPR. */ 275518334Speter 2756169689Skanvoid 2757169689Skanrecompute_tree_invariant_for_addr_expr (tree t) 275818334Speter{ 2759132718Skan tree node; 2760169689Skan bool tc = true, ti = true, se = false; 276118334Speter 2762169689Skan /* We started out assuming this address is both invariant and constant, but 2763169689Skan does not have side effects. Now go down any handled components and see if 2764169689Skan any of them involve offsets that are either non-constant or non-invariant. 2765169689Skan Also check for side-effects. 276618334Speter 2767169689Skan ??? Note that this code makes no attempt to deal with the case where 2768169689Skan taking the address of something causes a copy due to misalignment. */ 276918334Speter 2770169689Skan#define UPDATE_TITCSE(NODE) \ 2771169689Skando { tree _node = (NODE); \ 2772169689Skan if (_node && !TREE_INVARIANT (_node)) ti = false; \ 2773169689Skan if (_node && !TREE_CONSTANT (_node)) tc = false; \ 2774169689Skan if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0) 277590075Sobrien 2776169689Skan for (node = TREE_OPERAND (t, 0); handled_component_p (node); 2777169689Skan node = TREE_OPERAND (node, 0)) 277818334Speter { 2779169689Skan /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus 2780169689Skan array reference (probably made temporarily by the G++ front end), 2781169689Skan so ignore all the operands. */ 2782169689Skan if ((TREE_CODE (node) == ARRAY_REF 2783169689Skan || TREE_CODE (node) == ARRAY_RANGE_REF) 2784169689Skan && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE) 278590075Sobrien { 2786169689Skan UPDATE_TITCSE (TREE_OPERAND (node, 1)); 2787169689Skan if (TREE_OPERAND (node, 2)) 2788169689Skan UPDATE_TITCSE (TREE_OPERAND (node, 2)); 2789169689Skan if (TREE_OPERAND (node, 3)) 2790169689Skan UPDATE_TITCSE (TREE_OPERAND (node, 3)); 279190075Sobrien } 2792169689Skan /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a 2793169689Skan FIELD_DECL, apparently. The G++ front end can put something else 2794169689Skan there, at least temporarily. */ 2795169689Skan else if (TREE_CODE (node) == COMPONENT_REF 2796169689Skan && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL) 279790075Sobrien { 2798169689Skan if (TREE_OPERAND (node, 2)) 2799169689Skan UPDATE_TITCSE (TREE_OPERAND (node, 2)); 280090075Sobrien } 2801169689Skan else if (TREE_CODE (node) == BIT_FIELD_REF) 2802169689Skan UPDATE_TITCSE (TREE_OPERAND (node, 2)); 280318334Speter } 280418334Speter 2805169689Skan node = lang_hooks.expr_to_decl (node, &tc, &ti, &se); 280690075Sobrien 2807169689Skan /* Now see what's inside. If it's an INDIRECT_REF, copy our properties from 2808169689Skan the address, since &(*a)->b is a form of addition. If it's a decl, it's 2809169689Skan invariant and constant if the decl is static. It's also invariant if it's 2810169689Skan a decl in the current function. Taking the address of a volatile variable 2811169689Skan is not volatile. If it's a constant, the address is both invariant and 2812169689Skan constant. Otherwise it's neither. */ 2813169689Skan if (TREE_CODE (node) == INDIRECT_REF) 2814169689Skan UPDATE_TITCSE (TREE_OPERAND (node, 0)); 2815169689Skan else if (DECL_P (node)) 2816169689Skan { 2817169689Skan if (staticp (node)) 2818169689Skan ; 2819169689Skan else if (decl_function_context (node) == current_function_decl 2820169689Skan /* Addresses of thread-local variables are invariant. */ 2821169689Skan || (TREE_CODE (node) == VAR_DECL 2822169689Skan && DECL_THREAD_LOCAL_P (node))) 2823169689Skan tc = false; 2824169689Skan else 2825169689Skan ti = tc = false; 282618334Speter } 2827169689Skan else if (CONSTANT_CLASS_P (node)) 2828169689Skan ; 282918334Speter else 283018334Speter { 2831169689Skan ti = tc = false; 2832169689Skan se |= TREE_SIDE_EFFECTS (node); 283318334Speter } 283490075Sobrien 2835169689Skan TREE_CONSTANT (t) = tc; 2836169689Skan TREE_INVARIANT (t) = ti; 2837169689Skan TREE_SIDE_EFFECTS (t) = se; 2838169689Skan#undef UPDATE_TITCSE 2839169689Skan} 2840132718Skan 2841169689Skan/* Build an expression of code CODE, data type TYPE, and operands as 2842169689Skan specified. Expressions and reference nodes can be created this way. 2843169689Skan Constants, decls, types and misc nodes cannot be. 2844132718Skan 2845169689Skan We define 5 non-variadic functions, from 0 to 4 arguments. This is 2846169689Skan enough for all extant tree codes. */ 2847169689Skan 2848169689Skantree 2849169689Skanbuild0_stat (enum tree_code code, tree tt MEM_STAT_DECL) 2850169689Skan{ 2851169689Skan tree t; 2852169689Skan 2853169689Skan gcc_assert (TREE_CODE_LENGTH (code) == 0); 2854169689Skan 2855169689Skan t = make_node_stat (code PASS_MEM_STAT); 2856169689Skan TREE_TYPE (t) = tt; 2857169689Skan 285818334Speter return t; 285918334Speter} 286018334Speter 286118334Spetertree 2862169689Skanbuild1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL) 286318334Speter{ 2864132718Skan int length = sizeof (struct tree_exp); 286550397Sobrien#ifdef GATHER_STATISTICS 286690075Sobrien tree_node_kind kind; 286750397Sobrien#endif 286890075Sobrien tree t; 286918334Speter 287018334Speter#ifdef GATHER_STATISTICS 2871132718Skan switch (TREE_CODE_CLASS (code)) 2872132718Skan { 2873169689Skan case tcc_statement: /* an expression with side effects */ 2874132718Skan kind = s_kind; 2875132718Skan break; 2876169689Skan case tcc_reference: /* a reference */ 2877132718Skan kind = r_kind; 2878132718Skan break; 2879132718Skan default: 2880132718Skan kind = e_kind; 2881132718Skan break; 2882132718Skan } 2883132718Skan 2884132718Skan tree_node_counts[(int) kind]++; 2885132718Skan tree_node_sizes[(int) kind] += length; 288618334Speter#endif 288718334Speter 2888169689Skan gcc_assert (TREE_CODE_LENGTH (code) == 1); 288990075Sobrien 2890169689Skan t = ggc_alloc_zone_pass_stat (length, &tree_zone); 289118334Speter 2892132718Skan memset (t, 0, sizeof (struct tree_common)); 289390075Sobrien 289418334Speter TREE_SET_CODE (t, code); 289518334Speter 289690075Sobrien TREE_TYPE (t) = type; 2897169689Skan#ifdef USE_MAPPED_LOCATION 2898169689Skan SET_EXPR_LOCATION (t, UNKNOWN_LOCATION); 2899169689Skan#else 2900169689Skan SET_EXPR_LOCUS (t, NULL); 2901169689Skan#endif 290290075Sobrien TREE_COMPLEXITY (t) = 0; 290318334Speter TREE_OPERAND (t, 0) = node; 2904169689Skan TREE_BLOCK (t) = NULL_TREE; 2905169689Skan if (node && !TYPE_P (node)) 290618334Speter { 290790075Sobrien TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node); 290890075Sobrien TREE_READONLY (t) = TREE_READONLY (node); 290918334Speter } 291018334Speter 2911169689Skan if (TREE_CODE_CLASS (code) == tcc_statement) 2912132718Skan TREE_SIDE_EFFECTS (t) = 1; 2913132718Skan else switch (code) 291472562Sobrien { 291590075Sobrien case VA_ARG_EXPR: 291672562Sobrien /* All of these have side-effects, no matter what their 291790075Sobrien operands are. */ 291872562Sobrien TREE_SIDE_EFFECTS (t) = 1; 291990075Sobrien TREE_READONLY (t) = 0; 292072562Sobrien break; 292172562Sobrien 2922169689Skan case MISALIGNED_INDIRECT_REF: 2923169689Skan case ALIGN_INDIRECT_REF: 292490075Sobrien case INDIRECT_REF: 292590075Sobrien /* Whether a dereference is readonly has nothing to do with whether 292690075Sobrien its operand is readonly. */ 292790075Sobrien TREE_READONLY (t) = 0; 292872562Sobrien break; 292990075Sobrien 2930132718Skan case ADDR_EXPR: 2931132718Skan if (node) 2932169689Skan recompute_tree_invariant_for_addr_expr (t); 2933132718Skan break; 2934132718Skan 293590075Sobrien default: 2936169689Skan if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR) 2937169689Skan && node && !TYPE_P (node) 2938169689Skan && TREE_CONSTANT (node)) 293990075Sobrien TREE_CONSTANT (t) = 1; 2940169689Skan if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR) 2941169689Skan && node && TREE_INVARIANT (node)) 2942169689Skan TREE_INVARIANT (t) = 1; 2943169689Skan if (TREE_CODE_CLASS (code) == tcc_reference 2944169689Skan && node && TREE_THIS_VOLATILE (node)) 2945169689Skan TREE_THIS_VOLATILE (t) = 1; 294690075Sobrien break; 294772562Sobrien } 294872562Sobrien 294918334Speter return t; 295018334Speter} 295118334Speter 2952169689Skan#define PROCESS_ARG(N) \ 2953169689Skan do { \ 2954169689Skan TREE_OPERAND (t, N) = arg##N; \ 2955169689Skan if (arg##N &&!TYPE_P (arg##N)) \ 2956169689Skan { \ 2957169689Skan if (TREE_SIDE_EFFECTS (arg##N)) \ 2958169689Skan side_effects = 1; \ 2959169689Skan if (!TREE_READONLY (arg##N)) \ 2960169689Skan read_only = 0; \ 2961169689Skan if (!TREE_CONSTANT (arg##N)) \ 2962169689Skan constant = 0; \ 2963169689Skan if (!TREE_INVARIANT (arg##N)) \ 2964169689Skan invariant = 0; \ 2965169689Skan } \ 2966169689Skan } while (0) 2967169689Skan 2968169689Skantree 2969169689Skanbuild2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL) 2970169689Skan{ 2971169689Skan bool constant, read_only, side_effects, invariant; 2972169689Skan tree t; 2973169689Skan 2974169689Skan gcc_assert (TREE_CODE_LENGTH (code) == 2); 2975169689Skan 2976169689Skan t = make_node_stat (code PASS_MEM_STAT); 2977169689Skan TREE_TYPE (t) = tt; 2978169689Skan 2979169689Skan /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the 2980169689Skan result based on those same flags for the arguments. But if the 2981169689Skan arguments aren't really even `tree' expressions, we shouldn't be trying 2982169689Skan to do this. */ 2983169689Skan 2984169689Skan /* Expressions without side effects may be constant if their 2985169689Skan arguments are as well. */ 2986169689Skan constant = (TREE_CODE_CLASS (code) == tcc_comparison 2987169689Skan || TREE_CODE_CLASS (code) == tcc_binary); 2988169689Skan read_only = 1; 2989169689Skan side_effects = TREE_SIDE_EFFECTS (t); 2990169689Skan invariant = constant; 2991169689Skan 2992169689Skan PROCESS_ARG(0); 2993169689Skan PROCESS_ARG(1); 2994169689Skan 2995169689Skan TREE_READONLY (t) = read_only; 2996169689Skan TREE_CONSTANT (t) = constant; 2997169689Skan TREE_INVARIANT (t) = invariant; 2998169689Skan TREE_SIDE_EFFECTS (t) = side_effects; 2999169689Skan TREE_THIS_VOLATILE (t) 3000169689Skan = (TREE_CODE_CLASS (code) == tcc_reference 3001169689Skan && arg0 && TREE_THIS_VOLATILE (arg0)); 3002169689Skan 3003169689Skan return t; 3004169689Skan} 3005169689Skan 3006169689Skantree 3007169689Skanbuild3_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3008169689Skan tree arg2 MEM_STAT_DECL) 3009169689Skan{ 3010169689Skan bool constant, read_only, side_effects, invariant; 3011169689Skan tree t; 3012169689Skan 3013169689Skan gcc_assert (TREE_CODE_LENGTH (code) == 3); 3014169689Skan 3015169689Skan t = make_node_stat (code PASS_MEM_STAT); 3016169689Skan TREE_TYPE (t) = tt; 3017169689Skan 3018169689Skan side_effects = TREE_SIDE_EFFECTS (t); 3019169689Skan 3020169689Skan PROCESS_ARG(0); 3021169689Skan PROCESS_ARG(1); 3022169689Skan PROCESS_ARG(2); 3023169689Skan 3024169689Skan if (code == CALL_EXPR && !side_effects) 3025169689Skan { 3026169689Skan tree node; 3027169689Skan int i; 3028169689Skan 3029169689Skan /* Calls have side-effects, except those to const or 3030169689Skan pure functions. */ 3031169689Skan i = call_expr_flags (t); 3032169689Skan if (!(i & (ECF_CONST | ECF_PURE))) 3033169689Skan side_effects = 1; 3034169689Skan 3035169689Skan /* And even those have side-effects if their arguments do. */ 3036169689Skan else for (node = arg1; node; node = TREE_CHAIN (node)) 3037169689Skan if (TREE_SIDE_EFFECTS (TREE_VALUE (node))) 3038169689Skan { 3039169689Skan side_effects = 1; 3040169689Skan break; 3041169689Skan } 3042169689Skan } 3043169689Skan 3044169689Skan TREE_SIDE_EFFECTS (t) = side_effects; 3045169689Skan TREE_THIS_VOLATILE (t) 3046169689Skan = (TREE_CODE_CLASS (code) == tcc_reference 3047169689Skan && arg0 && TREE_THIS_VOLATILE (arg0)); 3048169689Skan 3049169689Skan return t; 3050169689Skan} 3051169689Skan 3052169689Skantree 3053169689Skanbuild4_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3054169689Skan tree arg2, tree arg3 MEM_STAT_DECL) 3055169689Skan{ 3056169689Skan bool constant, read_only, side_effects, invariant; 3057169689Skan tree t; 3058169689Skan 3059169689Skan gcc_assert (TREE_CODE_LENGTH (code) == 4); 3060169689Skan 3061169689Skan t = make_node_stat (code PASS_MEM_STAT); 3062169689Skan TREE_TYPE (t) = tt; 3063169689Skan 3064169689Skan side_effects = TREE_SIDE_EFFECTS (t); 3065169689Skan 3066169689Skan PROCESS_ARG(0); 3067169689Skan PROCESS_ARG(1); 3068169689Skan PROCESS_ARG(2); 3069169689Skan PROCESS_ARG(3); 3070169689Skan 3071169689Skan TREE_SIDE_EFFECTS (t) = side_effects; 3072169689Skan TREE_THIS_VOLATILE (t) 3073169689Skan = (TREE_CODE_CLASS (code) == tcc_reference 3074169689Skan && arg0 && TREE_THIS_VOLATILE (arg0)); 3075169689Skan 3076169689Skan return t; 3077169689Skan} 3078169689Skan 3079169689Skantree 3080169689Skanbuild5_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3081169689Skan tree arg2, tree arg3, tree arg4 MEM_STAT_DECL) 3082169689Skan{ 3083169689Skan bool constant, read_only, side_effects, invariant; 3084169689Skan tree t; 3085169689Skan 3086169689Skan gcc_assert (TREE_CODE_LENGTH (code) == 5); 3087169689Skan 3088169689Skan t = make_node_stat (code PASS_MEM_STAT); 3089169689Skan TREE_TYPE (t) = tt; 3090169689Skan 3091169689Skan side_effects = TREE_SIDE_EFFECTS (t); 3092169689Skan 3093169689Skan PROCESS_ARG(0); 3094169689Skan PROCESS_ARG(1); 3095169689Skan PROCESS_ARG(2); 3096169689Skan PROCESS_ARG(3); 3097169689Skan PROCESS_ARG(4); 3098169689Skan 3099169689Skan TREE_SIDE_EFFECTS (t) = side_effects; 3100169689Skan TREE_THIS_VOLATILE (t) 3101169689Skan = (TREE_CODE_CLASS (code) == tcc_reference 3102169689Skan && arg0 && TREE_THIS_VOLATILE (arg0)); 3103169689Skan 3104169689Skan return t; 3105169689Skan} 3106169689Skan 3107169689Skantree 3108169689Skanbuild7_stat (enum tree_code code, tree tt, tree arg0, tree arg1, 3109169689Skan tree arg2, tree arg3, tree arg4, tree arg5, 3110169689Skan tree arg6 MEM_STAT_DECL) 3111169689Skan{ 3112169689Skan bool constant, read_only, side_effects, invariant; 3113169689Skan tree t; 3114169689Skan 3115169689Skan gcc_assert (code == TARGET_MEM_REF); 3116169689Skan 3117169689Skan t = make_node_stat (code PASS_MEM_STAT); 3118169689Skan TREE_TYPE (t) = tt; 3119169689Skan 3120169689Skan side_effects = TREE_SIDE_EFFECTS (t); 3121169689Skan 3122169689Skan PROCESS_ARG(0); 3123169689Skan PROCESS_ARG(1); 3124169689Skan PROCESS_ARG(2); 3125169689Skan PROCESS_ARG(3); 3126169689Skan PROCESS_ARG(4); 3127169689Skan PROCESS_ARG(5); 3128169689Skan PROCESS_ARG(6); 3129169689Skan 3130169689Skan TREE_SIDE_EFFECTS (t) = side_effects; 3131169689Skan TREE_THIS_VOLATILE (t) = 0; 3132169689Skan 3133169689Skan return t; 3134169689Skan} 3135169689Skan 313618334Speter/* Similar except don't specify the TREE_TYPE 313718334Speter and leave the TREE_SIDE_EFFECTS as 0. 313818334Speter It is permissible for arguments to be null, 313918334Speter or even garbage if their values do not matter. */ 314018334Speter 314118334Spetertree 3142132718Skanbuild_nt (enum tree_code code, ...) 314318334Speter{ 314490075Sobrien tree t; 314590075Sobrien int length; 314690075Sobrien int i; 3147132718Skan va_list p; 314818334Speter 3149132718Skan va_start (p, code); 315018334Speter 315118334Speter t = make_node (code); 315290075Sobrien length = TREE_CODE_LENGTH (code); 315318334Speter 315418334Speter for (i = 0; i < length; i++) 315518334Speter TREE_OPERAND (t, i) = va_arg (p, tree); 315618334Speter 3157132718Skan va_end (p); 315818334Speter return t; 315918334Speter} 316018334Speter 316118334Speter/* Create a DECL_... node of code CODE, name NAME and data type TYPE. 316218334Speter We do NOT enter this node in any sort of symbol table. 316318334Speter 316418334Speter layout_decl is used to set up the decl's storage layout. 316518334Speter Other slots are initialized to 0 or null pointers. */ 316618334Speter 316718334Spetertree 3168169689Skanbuild_decl_stat (enum tree_code code, tree name, tree type MEM_STAT_DECL) 316918334Speter{ 317090075Sobrien tree t; 317118334Speter 3172169689Skan t = make_node_stat (code PASS_MEM_STAT); 317318334Speter 317418334Speter/* if (type == error_mark_node) 317518334Speter type = integer_type_node; */ 317618334Speter/* That is not done, deliberately, so that having error_mark_node 317718334Speter as the type can suppress useless errors in the use of this variable. */ 317818334Speter 317918334Speter DECL_NAME (t) = name; 318018334Speter TREE_TYPE (t) = type; 318118334Speter 318218334Speter if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL) 318318334Speter layout_decl (t, 0); 318418334Speter 318518334Speter return t; 318618334Speter} 3187169689Skan 3188169689Skan/* Builds and returns function declaration with NAME and TYPE. */ 3189169689Skan 3190169689Skantree 3191169689Skanbuild_fn_decl (const char *name, tree type) 3192169689Skan{ 3193169689Skan tree id = get_identifier (name); 3194169689Skan tree decl = build_decl (FUNCTION_DECL, id, type); 3195169689Skan 3196169689Skan DECL_EXTERNAL (decl) = 1; 3197169689Skan TREE_PUBLIC (decl) = 1; 3198169689Skan DECL_ARTIFICIAL (decl) = 1; 3199169689Skan TREE_NOTHROW (decl) = 1; 3200169689Skan 3201169689Skan return decl; 3202169689Skan} 3203169689Skan 320418334Speter 320518334Speter/* BLOCK nodes are used to represent the structure of binding contours 320618334Speter and declarations, once those contours have been exited and their contents 320718334Speter compiled. This information is used for outputting debugging info. */ 320818334Speter 320918334Spetertree 3210169689Skanbuild_block (tree vars, tree subblocks, tree supercontext, tree chain) 321118334Speter{ 321290075Sobrien tree block = make_node (BLOCK); 321390075Sobrien 321418334Speter BLOCK_VARS (block) = vars; 321518334Speter BLOCK_SUBBLOCKS (block) = subblocks; 321618334Speter BLOCK_SUPERCONTEXT (block) = supercontext; 321718334Speter BLOCK_CHAIN (block) = chain; 321818334Speter return block; 321918334Speter} 322050397Sobrien 3221169689Skan#if 1 /* ! defined(USE_MAPPED_LOCATION) */ 3222169689Skan/* ??? gengtype doesn't handle conditionals */ 3223169689Skanstatic GTY(()) source_locus last_annotated_node; 3224169689Skan#endif 322550397Sobrien 3226169689Skan#ifdef USE_MAPPED_LOCATION 3227169689Skan 3228169689Skanexpanded_location 3229169689Skanexpand_location (source_location loc) 323050397Sobrien{ 3231169689Skan expanded_location xloc; 3232169689Skan if (loc == 0) { xloc.file = NULL; xloc.line = 0; xloc.column = 0; } 3233169689Skan else 3234169689Skan { 3235169689Skan const struct line_map *map = linemap_lookup (&line_table, loc); 3236169689Skan xloc.file = map->to_file; 3237169689Skan xloc.line = SOURCE_LINE (map, loc); 3238169689Skan xloc.column = SOURCE_COLUMN (map, loc); 3239169689Skan }; 3240169689Skan return xloc; 3241169689Skan} 324250397Sobrien 3243169689Skan#else 3244169689Skan 3245169689Skan/* Record the exact location where an expression or an identifier were 3246169689Skan encountered. */ 3247169689Skan 3248169689Skanvoid 3249169689Skanannotate_with_file_line (tree node, const char *file, int line) 3250169689Skan{ 3251169689Skan /* Roughly one percent of the calls to this function are to annotate 3252169689Skan a node with the same information already attached to that node! 3253169689Skan Just return instead of wasting memory. */ 3254169689Skan if (EXPR_LOCUS (node) 3255169689Skan && EXPR_LINENO (node) == line 3256169689Skan && (EXPR_FILENAME (node) == file 3257169689Skan || !strcmp (EXPR_FILENAME (node), file))) 325850397Sobrien { 3259169689Skan last_annotated_node = EXPR_LOCUS (node); 3260169689Skan return; 326150397Sobrien } 326290075Sobrien 3263169689Skan /* In heavily macroized code (such as GCC itself) this single 3264169689Skan entry cache can reduce the number of allocations by more 3265169689Skan than half. */ 3266169689Skan if (last_annotated_node 3267169689Skan && last_annotated_node->line == line 3268169689Skan && (last_annotated_node->file == file 3269169689Skan || !strcmp (last_annotated_node->file, file))) 327050397Sobrien { 3271169689Skan SET_EXPR_LOCUS (node, last_annotated_node); 3272169689Skan return; 327350397Sobrien } 327490075Sobrien 3275169689Skan SET_EXPR_LOCUS (node, ggc_alloc (sizeof (location_t))); 3276169689Skan EXPR_LINENO (node) = line; 3277169689Skan EXPR_FILENAME (node) = file; 3278169689Skan last_annotated_node = EXPR_LOCUS (node); 327950397Sobrien} 3280169689Skan 3281169689Skanvoid 3282169689Skanannotate_with_locus (tree node, location_t locus) 3283169689Skan{ 3284169689Skan annotate_with_file_line (node, locus.file, locus.line); 3285169689Skan} 3286169689Skan#endif 328718334Speter 328890075Sobrien/* Return a declaration like DDECL except that its DECL_ATTRIBUTES 328950397Sobrien is ATTRIBUTE. */ 329018334Speter 329118334Spetertree 3292132718Skanbuild_decl_attribute_variant (tree ddecl, tree attribute) 329318334Speter{ 329490075Sobrien DECL_ATTRIBUTES (ddecl) = attribute; 329518334Speter return ddecl; 329618334Speter} 329718334Speter 3298169689Skan/* Borrowed from hashtab.c iterative_hash implementation. */ 3299169689Skan#define mix(a,b,c) \ 3300169689Skan{ \ 3301169689Skan a -= b; a -= c; a ^= (c>>13); \ 3302169689Skan b -= c; b -= a; b ^= (a<< 8); \ 3303169689Skan c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \ 3304169689Skan a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \ 3305169689Skan b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \ 3306169689Skan c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \ 3307169689Skan a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \ 3308169689Skan b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \ 3309169689Skan c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \ 3310169689Skan} 3311169689Skan 3312169689Skan 3313169689Skan/* Produce good hash value combining VAL and VAL2. */ 3314169689Skanstatic inline hashval_t 3315169689Skaniterative_hash_hashval_t (hashval_t val, hashval_t val2) 3316169689Skan{ 3317169689Skan /* the golden ratio; an arbitrary value. */ 3318169689Skan hashval_t a = 0x9e3779b9; 3319169689Skan 3320169689Skan mix (a, val, val2); 3321169689Skan return val2; 3322169689Skan} 3323169689Skan 3324169689Skan/* Produce good hash value combining PTR and VAL2. */ 3325169689Skanstatic inline hashval_t 3326169689Skaniterative_hash_pointer (void *ptr, hashval_t val2) 3327169689Skan{ 3328169689Skan if (sizeof (ptr) == sizeof (hashval_t)) 3329169689Skan return iterative_hash_hashval_t ((size_t) ptr, val2); 3330169689Skan else 3331169689Skan { 3332169689Skan hashval_t a = (hashval_t) (size_t) ptr; 3333169689Skan /* Avoid warnings about shifting of more than the width of the type on 3334169689Skan hosts that won't execute this path. */ 3335169689Skan int zero = 0; 3336169689Skan hashval_t b = (hashval_t) ((size_t) ptr >> (sizeof (hashval_t) * 8 + zero)); 3337169689Skan mix (a, b, val2); 3338169689Skan return val2; 3339169689Skan } 3340169689Skan} 3341169689Skan 3342169689Skan/* Produce good hash value combining VAL and VAL2. */ 3343169689Skanstatic inline hashval_t 3344169689Skaniterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2) 3345169689Skan{ 3346169689Skan if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t)) 3347169689Skan return iterative_hash_hashval_t (val, val2); 3348169689Skan else 3349169689Skan { 3350169689Skan hashval_t a = (hashval_t) val; 3351169689Skan /* Avoid warnings about shifting of more than the width of the type on 3352169689Skan hosts that won't execute this path. */ 3353169689Skan int zero = 0; 3354169689Skan hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero)); 3355169689Skan mix (a, b, val2); 3356169689Skan if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t)) 3357169689Skan { 3358169689Skan hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero)); 3359169689Skan hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero)); 3360169689Skan mix (a, b, val2); 3361169689Skan } 3362169689Skan return val2; 3363169689Skan } 3364169689Skan} 3365169689Skan 336618334Speter/* Return a type like TTYPE except that its TYPE_ATTRIBUTE 3367169689Skan is ATTRIBUTE and its qualifiers are QUALS. 336818334Speter 336918334Speter Record such modified types already made so we don't make duplicates. */ 337018334Speter 3371169689Skanstatic tree 3372169689Skanbuild_type_attribute_qual_variant (tree ttype, tree attribute, int quals) 337318334Speter{ 3374117395Skan if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute)) 337518334Speter { 3376169689Skan hashval_t hashcode = 0; 337718334Speter tree ntype; 3378169689Skan enum tree_code code = TREE_CODE (ttype); 337918334Speter 338018334Speter ntype = copy_node (ttype); 338118334Speter 338218334Speter TYPE_POINTER_TO (ntype) = 0; 338318334Speter TYPE_REFERENCE_TO (ntype) = 0; 338418334Speter TYPE_ATTRIBUTES (ntype) = attribute; 338518334Speter 338618334Speter /* Create a new main variant of TYPE. */ 338718334Speter TYPE_MAIN_VARIANT (ntype) = ntype; 338818334Speter TYPE_NEXT_VARIANT (ntype) = 0; 338952284Sobrien set_type_quals (ntype, TYPE_UNQUALIFIED); 339018334Speter 3391169689Skan hashcode = iterative_hash_object (code, hashcode); 3392169689Skan if (TREE_TYPE (ntype)) 3393169689Skan hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)), 3394169689Skan hashcode); 3395169689Skan hashcode = attribute_hash_list (attribute, hashcode); 339618334Speter 339718334Speter switch (TREE_CODE (ntype)) 339890075Sobrien { 339950397Sobrien case FUNCTION_TYPE: 3400169689Skan hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode); 340150397Sobrien break; 340250397Sobrien case ARRAY_TYPE: 3403169689Skan hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)), 3404169689Skan hashcode); 340550397Sobrien break; 340650397Sobrien case INTEGER_TYPE: 3407169689Skan hashcode = iterative_hash_object 3408169689Skan (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode); 3409169689Skan hashcode = iterative_hash_object 3410169689Skan (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode); 341150397Sobrien break; 341250397Sobrien case REAL_TYPE: 3413169689Skan { 3414169689Skan unsigned int precision = TYPE_PRECISION (ntype); 3415169689Skan hashcode = iterative_hash_object (precision, hashcode); 3416169689Skan } 341750397Sobrien break; 341850397Sobrien default: 341950397Sobrien break; 342090075Sobrien } 342118334Speter 342218334Speter ntype = type_hash_canon (hashcode, ntype); 3423169689Skan ttype = build_qualified_type (ntype, quals); 342418334Speter } 342518334Speter 342618334Speter return ttype; 342718334Speter} 342818334Speter 3429169689Skan 3430169689Skan/* Return a type like TTYPE except that its TYPE_ATTRIBUTE 3431169689Skan is ATTRIBUTE. 3432169689Skan 3433169689Skan Record such modified types already made so we don't make duplicates. */ 3434169689Skan 3435169689Skantree 3436169689Skanbuild_type_attribute_variant (tree ttype, tree attribute) 3437169689Skan{ 3438169689Skan return build_type_attribute_qual_variant (ttype, attribute, 3439169689Skan TYPE_QUALS (ttype)); 3440169689Skan} 3441169689Skan 3442117395Skan/* Return nonzero if IDENT is a valid name for attribute ATTR, 344318334Speter or zero if not. 344418334Speter 344518334Speter We try both `text' and `__text__', ATTR may be either one. */ 344618334Speter/* ??? It might be a reasonable simplification to require ATTR to be only 344718334Speter `text'. One might then also require attribute lists to be stored in 344818334Speter their canonicalized form. */ 344918334Speter 3450169689Skanstatic int 3451169689Skanis_attribute_with_length_p (const char *attr, int attr_len, tree ident) 345218334Speter{ 3453169689Skan int ident_len; 345490075Sobrien const char *p; 345518334Speter 345618334Speter if (TREE_CODE (ident) != IDENTIFIER_NODE) 345718334Speter return 0; 3458169689Skan 3459169689Skan p = IDENTIFIER_POINTER (ident); 3460169689Skan ident_len = IDENTIFIER_LENGTH (ident); 3461169689Skan 3462169689Skan if (ident_len == attr_len 3463169689Skan && strcmp (attr, p) == 0) 346418334Speter return 1; 346518334Speter 346618334Speter /* If ATTR is `__text__', IDENT must be `text'; and vice versa. */ 346718334Speter if (attr[0] == '_') 346818334Speter { 3469169689Skan gcc_assert (attr[1] == '_'); 3470169689Skan gcc_assert (attr[attr_len - 2] == '_'); 3471169689Skan gcc_assert (attr[attr_len - 1] == '_'); 347218334Speter if (ident_len == attr_len - 4 347318334Speter && strncmp (attr + 2, p, attr_len - 4) == 0) 347418334Speter return 1; 347518334Speter } 347618334Speter else 347718334Speter { 347818334Speter if (ident_len == attr_len + 4 347918334Speter && p[0] == '_' && p[1] == '_' 348018334Speter && p[ident_len - 2] == '_' && p[ident_len - 1] == '_' 348118334Speter && strncmp (attr, p + 2, attr_len) == 0) 348218334Speter return 1; 348318334Speter } 348418334Speter 348518334Speter return 0; 348618334Speter} 348718334Speter 3488169689Skan/* Return nonzero if IDENT is a valid name for attribute ATTR, 3489169689Skan or zero if not. 3490169689Skan 3491169689Skan We try both `text' and `__text__', ATTR may be either one. */ 3492169689Skan 3493169689Skanint 3494169689Skanis_attribute_p (const char *attr, tree ident) 3495169689Skan{ 3496169689Skan return is_attribute_with_length_p (attr, strlen (attr), ident); 3497169689Skan} 3498169689Skan 349918334Speter/* Given an attribute name and a list of attributes, return a pointer to the 350018334Speter attribute's list element if the attribute is part of the list, or NULL_TREE 350190075Sobrien if not found. If the attribute appears more than once, this only 350290075Sobrien returns the first occurrence; the TREE_CHAIN of the return value should 350390075Sobrien be passed back in if further occurrences are wanted. */ 350418334Speter 350518334Spetertree 3506132718Skanlookup_attribute (const char *attr_name, tree list) 350718334Speter{ 350818334Speter tree l; 3509169689Skan size_t attr_len = strlen (attr_name); 351018334Speter 351118334Speter for (l = list; l; l = TREE_CHAIN (l)) 351218334Speter { 3513169689Skan gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE); 3514169689Skan if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l))) 351518334Speter return l; 351618334Speter } 351718334Speter 351818334Speter return NULL_TREE; 351918334Speter} 352050397Sobrien 3521169689Skan/* Remove any instances of attribute ATTR_NAME in LIST and return the 3522169689Skan modified list. */ 3523169689Skan 3524169689Skantree 3525169689Skanremove_attribute (const char *attr_name, tree list) 3526169689Skan{ 3527169689Skan tree *p; 3528169689Skan size_t attr_len = strlen (attr_name); 3529169689Skan 3530169689Skan for (p = &list; *p; ) 3531169689Skan { 3532169689Skan tree l = *p; 3533169689Skan gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE); 3534169689Skan if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l))) 3535169689Skan *p = TREE_CHAIN (l); 3536169689Skan else 3537169689Skan p = &TREE_CHAIN (l); 3538169689Skan } 3539169689Skan 3540169689Skan return list; 3541169689Skan} 3542169689Skan 354350397Sobrien/* Return an attribute list that is the union of a1 and a2. */ 354450397Sobrien 354550397Sobrientree 3546132718Skanmerge_attributes (tree a1, tree a2) 354750397Sobrien{ 354850397Sobrien tree attributes; 354950397Sobrien 355050397Sobrien /* Either one unset? Take the set one. */ 355150397Sobrien 355290075Sobrien if ((attributes = a1) == 0) 355350397Sobrien attributes = a2; 355450397Sobrien 355550397Sobrien /* One that completely contains the other? Take it. */ 355650397Sobrien 355790075Sobrien else if (a2 != 0 && ! attribute_list_contained (a1, a2)) 355890075Sobrien { 355990075Sobrien if (attribute_list_contained (a2, a1)) 356090075Sobrien attributes = a2; 356190075Sobrien else 356290075Sobrien { 356390075Sobrien /* Pick the longest list, and hang on the other list. */ 356450397Sobrien 356590075Sobrien if (list_length (a1) < list_length (a2)) 356690075Sobrien attributes = a2, a2 = a1; 356750397Sobrien 356890075Sobrien for (; a2 != 0; a2 = TREE_CHAIN (a2)) 356950397Sobrien { 357090075Sobrien tree a; 357190075Sobrien for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), 357290075Sobrien attributes); 357390075Sobrien a != NULL_TREE; 357490075Sobrien a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)), 357590075Sobrien TREE_CHAIN (a))) 357690075Sobrien { 3577169689Skan if (TREE_VALUE (a) != NULL 3578169689Skan && TREE_CODE (TREE_VALUE (a)) == TREE_LIST 3579169689Skan && TREE_VALUE (a2) != NULL 3580169689Skan && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST) 3581169689Skan { 3582169689Skan if (simple_cst_list_equal (TREE_VALUE (a), 3583169689Skan TREE_VALUE (a2)) == 1) 3584169689Skan break; 3585169689Skan } 3586169689Skan else if (simple_cst_equal (TREE_VALUE (a), 3587169689Skan TREE_VALUE (a2)) == 1) 358890075Sobrien break; 358990075Sobrien } 359090075Sobrien if (a == NULL_TREE) 359190075Sobrien { 359290075Sobrien a1 = copy_node (a2); 359390075Sobrien TREE_CHAIN (a1) = attributes; 359490075Sobrien attributes = a1; 359590075Sobrien } 359650397Sobrien } 359790075Sobrien } 359890075Sobrien } 359950397Sobrien return attributes; 360050397Sobrien} 360150397Sobrien 360250397Sobrien/* Given types T1 and T2, merge their attributes and return 360390075Sobrien the result. */ 360450397Sobrien 360550397Sobrientree 3606132718Skanmerge_type_attributes (tree t1, tree t2) 360750397Sobrien{ 360850397Sobrien return merge_attributes (TYPE_ATTRIBUTES (t1), 360950397Sobrien TYPE_ATTRIBUTES (t2)); 361050397Sobrien} 361150397Sobrien 361250397Sobrien/* Given decls OLDDECL and NEWDECL, merge their attributes and return 361350397Sobrien the result. */ 361450397Sobrien 361550397Sobrientree 3616132718Skanmerge_decl_attributes (tree olddecl, tree newdecl) 361750397Sobrien{ 361890075Sobrien return merge_attributes (DECL_ATTRIBUTES (olddecl), 361990075Sobrien DECL_ATTRIBUTES (newdecl)); 362050397Sobrien} 362190075Sobrien 3622169689Skan#if TARGET_DLLIMPORT_DECL_ATTRIBUTES 362390075Sobrien 362490075Sobrien/* Specialization of merge_decl_attributes for various Windows targets. 362590075Sobrien 362690075Sobrien This handles the following situation: 362790075Sobrien 362890075Sobrien __declspec (dllimport) int foo; 362990075Sobrien int foo; 363090075Sobrien 363190075Sobrien The second instance of `foo' nullifies the dllimport. */ 363290075Sobrien 363390075Sobrientree 3634132718Skanmerge_dllimport_decl_attributes (tree old, tree new) 363590075Sobrien{ 363690075Sobrien tree a; 3637169689Skan int delete_dllimport_p = 1; 363890075Sobrien 363990075Sobrien /* What we need to do here is remove from `old' dllimport if it doesn't 364090075Sobrien appear in `new'. dllimport behaves like extern: if a declaration is 364190075Sobrien marked dllimport and a definition appears later, then the object 3642169689Skan is not dllimport'd. We also remove a `new' dllimport if the old list 3643169689Skan contains dllexport: dllexport always overrides dllimport, regardless 3644169689Skan of the order of declaration. */ 3645169689Skan if (!VAR_OR_FUNCTION_DECL_P (new)) 3646169689Skan delete_dllimport_p = 0; 3647169689Skan else if (DECL_DLLIMPORT_P (new) 3648169689Skan && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old))) 3649169689Skan { 3650169689Skan DECL_DLLIMPORT_P (new) = 0; 3651169689Skan warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: " 3652169689Skan "dllimport ignored", new); 3653169689Skan } 3654169689Skan else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new)) 3655169689Skan { 3656169689Skan /* Warn about overriding a symbol that has already been used. eg: 3657169689Skan extern int __attribute__ ((dllimport)) foo; 3658169689Skan int* bar () {return &foo;} 3659169689Skan int foo; 3660169689Skan */ 3661169689Skan if (TREE_USED (old)) 3662169689Skan { 3663169689Skan warning (0, "%q+D redeclared without dllimport attribute " 3664169689Skan "after being referenced with dll linkage", new); 3665169689Skan /* If we have used a variable's address with dllimport linkage, 3666169689Skan keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the 3667169689Skan decl may already have had TREE_INVARIANT and TREE_CONSTANT 3668169689Skan computed. 3669169689Skan We still remove the attribute so that assembler code refers 3670169689Skan to '&foo rather than '_imp__foo'. */ 3671169689Skan if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old)) 3672169689Skan DECL_DLLIMPORT_P (new) = 1; 3673169689Skan } 3674169689Skan 3675169689Skan /* Let an inline definition silently override the external reference, 3676169689Skan but otherwise warn about attribute inconsistency. */ 3677169689Skan else if (TREE_CODE (new) == VAR_DECL 3678169689Skan || !DECL_DECLARED_INLINE_P (new)) 3679169689Skan warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: " 3680169689Skan "previous dllimport ignored", new); 3681169689Skan } 368290075Sobrien else 368390075Sobrien delete_dllimport_p = 0; 368490075Sobrien 3685169689Skan a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new)); 368690075Sobrien 3687169689Skan if (delete_dllimport_p) 368890075Sobrien { 368990075Sobrien tree prev, t; 3690169689Skan const size_t attr_len = strlen ("dllimport"); 3691169689Skan 369290075Sobrien /* Scan the list for dllimport and delete it. */ 369390075Sobrien for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t)) 369490075Sobrien { 3695169689Skan if (is_attribute_with_length_p ("dllimport", attr_len, 3696169689Skan TREE_PURPOSE (t))) 369790075Sobrien { 369890075Sobrien if (prev == NULL_TREE) 369990075Sobrien a = TREE_CHAIN (a); 370090075Sobrien else 370190075Sobrien TREE_CHAIN (prev) = TREE_CHAIN (t); 370290075Sobrien break; 370390075Sobrien } 370490075Sobrien } 370590075Sobrien } 370690075Sobrien 370790075Sobrien return a; 370890075Sobrien} 370990075Sobrien 3710169689Skan/* Handle a "dllimport" or "dllexport" attribute; arguments as in 3711169689Skan struct attribute_spec.handler. */ 3712169689Skan 3713169689Skantree 3714169689Skanhandle_dll_attribute (tree * pnode, tree name, tree args, int flags, 3715169689Skan bool *no_add_attrs) 3716169689Skan{ 3717169689Skan tree node = *pnode; 3718169689Skan 3719169689Skan /* These attributes may apply to structure and union types being created, 3720169689Skan but otherwise should pass to the declaration involved. */ 3721169689Skan if (!DECL_P (node)) 3722169689Skan { 3723169689Skan if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT 3724169689Skan | (int) ATTR_FLAG_ARRAY_NEXT)) 3725169689Skan { 3726169689Skan *no_add_attrs = true; 3727169689Skan return tree_cons (name, args, NULL_TREE); 3728169689Skan } 3729169689Skan if (TREE_CODE (node) != RECORD_TYPE && TREE_CODE (node) != UNION_TYPE) 3730169689Skan { 3731169689Skan warning (OPT_Wattributes, "%qs attribute ignored", 3732169689Skan IDENTIFIER_POINTER (name)); 3733169689Skan *no_add_attrs = true; 3734169689Skan } 3735169689Skan 3736169689Skan return NULL_TREE; 3737169689Skan } 3738169689Skan 3739169689Skan if (TREE_CODE (node) != FUNCTION_DECL 3740169689Skan && TREE_CODE (node) != VAR_DECL) 3741169689Skan { 3742169689Skan *no_add_attrs = true; 3743169689Skan warning (OPT_Wattributes, "%qs attribute ignored", 3744169689Skan IDENTIFIER_POINTER (name)); 3745169689Skan return NULL_TREE; 3746169689Skan } 3747169689Skan 3748169689Skan /* Report error on dllimport ambiguities seen now before they cause 3749169689Skan any damage. */ 3750169689Skan else if (is_attribute_p ("dllimport", name)) 3751169689Skan { 3752169689Skan /* Honor any target-specific overrides. */ 3753169689Skan if (!targetm.valid_dllimport_attribute_p (node)) 3754169689Skan *no_add_attrs = true; 3755169689Skan 3756169689Skan else if (TREE_CODE (node) == FUNCTION_DECL 3757169689Skan && DECL_DECLARED_INLINE_P (node)) 3758169689Skan { 3759169689Skan warning (OPT_Wattributes, "inline function %q+D declared as " 3760169689Skan " dllimport: attribute ignored", node); 3761169689Skan *no_add_attrs = true; 3762169689Skan } 3763169689Skan /* Like MS, treat definition of dllimported variables and 3764169689Skan non-inlined functions on declaration as syntax errors. */ 3765169689Skan else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node)) 3766169689Skan { 3767169689Skan error ("function %q+D definition is marked dllimport", node); 3768169689Skan *no_add_attrs = true; 3769169689Skan } 3770169689Skan 3771169689Skan else if (TREE_CODE (node) == VAR_DECL) 3772169689Skan { 3773169689Skan if (DECL_INITIAL (node)) 3774169689Skan { 3775169689Skan error ("variable %q+D definition is marked dllimport", 3776169689Skan node); 3777169689Skan *no_add_attrs = true; 3778169689Skan } 3779169689Skan 3780169689Skan /* `extern' needn't be specified with dllimport. 3781169689Skan Specify `extern' now and hope for the best. Sigh. */ 3782169689Skan DECL_EXTERNAL (node) = 1; 3783169689Skan /* Also, implicitly give dllimport'd variables declared within 3784169689Skan a function global scope, unless declared static. */ 3785169689Skan if (current_function_decl != NULL_TREE && !TREE_STATIC (node)) 3786169689Skan TREE_PUBLIC (node) = 1; 3787169689Skan } 3788169689Skan 3789169689Skan if (*no_add_attrs == false) 3790169689Skan DECL_DLLIMPORT_P (node) = 1; 3791169689Skan } 3792169689Skan 3793169689Skan /* Report error if symbol is not accessible at global scope. */ 3794169689Skan if (!TREE_PUBLIC (node) 3795169689Skan && (TREE_CODE (node) == VAR_DECL 3796169689Skan || TREE_CODE (node) == FUNCTION_DECL)) 3797169689Skan { 3798169689Skan error ("external linkage required for symbol %q+D because of " 3799169689Skan "%qs attribute", node, IDENTIFIER_POINTER (name)); 3800169689Skan *no_add_attrs = true; 3801169689Skan } 3802169689Skan 3803169689Skan return NULL_TREE; 3804169689Skan} 3805169689Skan 380690075Sobrien#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES */ 380718334Speter 380852284Sobrien/* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask 380952284Sobrien of the various TYPE_QUAL values. */ 381018334Speter 381152284Sobrienstatic void 3812132718Skanset_type_quals (tree type, int type_quals) 381352284Sobrien{ 381452284Sobrien TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0; 381552284Sobrien TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0; 381652284Sobrien TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0; 381752284Sobrien} 381818334Speter 3819169689Skan/* Returns true iff cand is equivalent to base with type_quals. */ 3820169689Skan 3821169689Skanbool 3822169689Skancheck_qualified_type (tree cand, tree base, int type_quals) 3823169689Skan{ 3824169689Skan return (TYPE_QUALS (cand) == type_quals 3825169689Skan && TYPE_NAME (cand) == TYPE_NAME (base) 3826169689Skan /* Apparently this is needed for Objective-C. */ 3827169689Skan && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base) 3828169689Skan && attribute_list_equal (TYPE_ATTRIBUTES (cand), 3829169689Skan TYPE_ATTRIBUTES (base))); 3830169689Skan} 3831169689Skan 383290075Sobrien/* Return a version of the TYPE, qualified as indicated by the 383390075Sobrien TYPE_QUALS, if one exists. If no qualified version exists yet, 383490075Sobrien return NULL_TREE. */ 383518334Speter 383618334Spetertree 3837132718Skanget_qualified_type (tree type, int type_quals) 383818334Speter{ 383990075Sobrien tree t; 384090075Sobrien 3841169689Skan if (TYPE_QUALS (type) == type_quals) 3842169689Skan return type; 3843169689Skan 384418334Speter /* Search the chain of variants to see if there is already one there just 384518334Speter like the one we need to have. If so, use that existing one. We must 384618334Speter preserve the TYPE_NAME, since there is code that depends on this. */ 384750397Sobrien for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t)) 3848169689Skan if (check_qualified_type (t, type, type_quals)) 384918334Speter return t; 385018334Speter 385190075Sobrien return NULL_TREE; 385290075Sobrien} 385390075Sobrien 385490075Sobrien/* Like get_qualified_type, but creates the type if it does not 385590075Sobrien exist. This function never returns NULL_TREE. */ 385690075Sobrien 385790075Sobrientree 3858132718Skanbuild_qualified_type (tree type, int type_quals) 385990075Sobrien{ 386090075Sobrien tree t; 386190075Sobrien 386290075Sobrien /* See if we already have the appropriate qualified variant. */ 386390075Sobrien t = get_qualified_type (type, type_quals); 386490075Sobrien 386590075Sobrien /* If not, build it. */ 386690075Sobrien if (!t) 386790075Sobrien { 3868169689Skan t = build_variant_type_copy (type); 386990075Sobrien set_type_quals (t, type_quals); 387090075Sobrien } 387190075Sobrien 387218334Speter return t; 387318334Speter} 387418334Speter 3875169689Skan/* Create a new distinct copy of TYPE. The new type is made its own 3876169689Skan MAIN_VARIANT. */ 3877169689Skan 3878169689Skantree 3879169689Skanbuild_distinct_type_copy (tree type) 3880169689Skan{ 3881169689Skan tree t = copy_node (type); 3882169689Skan 3883169689Skan TYPE_POINTER_TO (t) = 0; 3884169689Skan TYPE_REFERENCE_TO (t) = 0; 3885169689Skan 3886169689Skan /* Make it its own variant. */ 3887169689Skan TYPE_MAIN_VARIANT (t) = t; 3888169689Skan TYPE_NEXT_VARIANT (t) = 0; 3889169689Skan 3890169689Skan /* Note that it is now possible for TYPE_MIN_VALUE to be a value 3891169689Skan whose TREE_TYPE is not t. This can also happen in the Ada 3892169689Skan frontend when using subtypes. */ 3893169689Skan 3894169689Skan return t; 3895169689Skan} 3896169689Skan 389718334Speter/* Create a new variant of TYPE, equivalent but distinct. 389818334Speter This is so the caller can modify it. */ 389918334Speter 390018334Spetertree 3901169689Skanbuild_variant_type_copy (tree type) 390218334Speter{ 390390075Sobrien tree t, m = TYPE_MAIN_VARIANT (type); 390418334Speter 3905169689Skan t = build_distinct_type_copy (type); 3906169689Skan 3907169689Skan /* Add the new type to the chain of variants of TYPE. */ 390818334Speter TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m); 390918334Speter TYPE_NEXT_VARIANT (m) = t; 3910169689Skan TYPE_MAIN_VARIANT (t) = m; 391118334Speter 391218334Speter return t; 391318334Speter} 391418334Speter 3915169689Skan/* Return true if the from tree in both tree maps are equal. */ 3916169689Skan 3917169689Skanint 3918169689Skantree_map_eq (const void *va, const void *vb) 3919169689Skan{ 3920169689Skan const struct tree_map *a = va, *b = vb; 3921169689Skan return (a->from == b->from); 3922169689Skan} 3923169689Skan 3924169689Skan/* Hash a from tree in a tree_map. */ 3925169689Skan 3926169689Skanunsigned int 3927169689Skantree_map_hash (const void *item) 3928169689Skan{ 3929169689Skan return (((const struct tree_map *) item)->hash); 3930169689Skan} 3931169689Skan 3932169689Skan/* Return true if this tree map structure is marked for garbage collection 3933169689Skan purposes. We simply return true if the from tree is marked, so that this 3934169689Skan structure goes away when the from tree goes away. */ 3935169689Skan 3936169689Skanint 3937169689Skantree_map_marked_p (const void *p) 3938169689Skan{ 3939169689Skan tree from = ((struct tree_map *) p)->from; 3940169689Skan 3941169689Skan return ggc_marked_p (from); 3942169689Skan} 3943169689Skan 3944169689Skan/* Return true if the trees in the tree_int_map *'s VA and VB are equal. */ 3945169689Skan 3946169689Skanstatic int 3947169689Skantree_int_map_eq (const void *va, const void *vb) 3948169689Skan{ 3949169689Skan const struct tree_int_map *a = va, *b = vb; 3950169689Skan return (a->from == b->from); 3951169689Skan} 3952169689Skan 3953169689Skan/* Hash a from tree in the tree_int_map * ITEM. */ 3954169689Skan 3955169689Skanstatic unsigned int 3956169689Skantree_int_map_hash (const void *item) 3957169689Skan{ 3958169689Skan return htab_hash_pointer (((const struct tree_int_map *)item)->from); 3959169689Skan} 3960169689Skan 3961169689Skan/* Return true if this tree int map structure is marked for garbage collection 3962169689Skan purposes. We simply return true if the from tree_int_map *P's from tree is marked, so that this 3963169689Skan structure goes away when the from tree goes away. */ 3964169689Skan 3965169689Skanstatic int 3966169689Skantree_int_map_marked_p (const void *p) 3967169689Skan{ 3968169689Skan tree from = ((struct tree_int_map *) p)->from; 3969169689Skan 3970169689Skan return ggc_marked_p (from); 3971169689Skan} 3972169689Skan/* Lookup an init priority for FROM, and return it if we find one. */ 3973169689Skan 3974169689Skanunsigned short 3975169689Skandecl_init_priority_lookup (tree from) 3976169689Skan{ 3977169689Skan struct tree_int_map *h, in; 3978169689Skan in.from = from; 3979169689Skan 3980169689Skan h = htab_find_with_hash (init_priority_for_decl, 3981169689Skan &in, htab_hash_pointer (from)); 3982169689Skan if (h) 3983169689Skan return h->to; 3984169689Skan return 0; 3985169689Skan} 3986169689Skan 3987169689Skan/* Insert a mapping FROM->TO in the init priority hashtable. */ 3988169689Skan 3989169689Skanvoid 3990169689Skandecl_init_priority_insert (tree from, unsigned short to) 3991169689Skan{ 3992169689Skan struct tree_int_map *h; 3993169689Skan void **loc; 3994169689Skan 3995169689Skan h = ggc_alloc (sizeof (struct tree_int_map)); 3996169689Skan h->from = from; 3997169689Skan h->to = to; 3998169689Skan loc = htab_find_slot_with_hash (init_priority_for_decl, h, 3999169689Skan htab_hash_pointer (from), INSERT); 4000169689Skan *(struct tree_int_map **) loc = h; 4001169689Skan} 4002169689Skan 4003169689Skan/* Look up a restrict qualified base decl for FROM. */ 4004169689Skan 4005169689Skantree 4006169689Skandecl_restrict_base_lookup (tree from) 4007169689Skan{ 4008169689Skan struct tree_map *h; 4009169689Skan struct tree_map in; 4010169689Skan 4011169689Skan in.from = from; 4012169689Skan h = htab_find_with_hash (restrict_base_for_decl, &in, 4013169689Skan htab_hash_pointer (from)); 4014169689Skan return h ? h->to : NULL_TREE; 4015169689Skan} 4016169689Skan 4017169689Skan/* Record the restrict qualified base TO for FROM. */ 4018169689Skan 4019169689Skanvoid 4020169689Skandecl_restrict_base_insert (tree from, tree to) 4021169689Skan{ 4022169689Skan struct tree_map *h; 4023169689Skan void **loc; 4024169689Skan 4025169689Skan h = ggc_alloc (sizeof (struct tree_map)); 4026169689Skan h->hash = htab_hash_pointer (from); 4027169689Skan h->from = from; 4028169689Skan h->to = to; 4029169689Skan loc = htab_find_slot_with_hash (restrict_base_for_decl, h, h->hash, INSERT); 4030169689Skan *(struct tree_map **) loc = h; 4031169689Skan} 4032169689Skan 4033169689Skan/* Print out the statistics for the DECL_DEBUG_EXPR hash table. */ 4034169689Skan 4035169689Skanstatic void 4036169689Skanprint_debug_expr_statistics (void) 4037169689Skan{ 4038169689Skan fprintf (stderr, "DECL_DEBUG_EXPR hash: size %ld, %ld elements, %f collisions\n", 4039169689Skan (long) htab_size (debug_expr_for_decl), 4040169689Skan (long) htab_elements (debug_expr_for_decl), 4041169689Skan htab_collisions (debug_expr_for_decl)); 4042169689Skan} 4043169689Skan 4044169689Skan/* Print out the statistics for the DECL_VALUE_EXPR hash table. */ 4045169689Skan 4046169689Skanstatic void 4047169689Skanprint_value_expr_statistics (void) 4048169689Skan{ 4049169689Skan fprintf (stderr, "DECL_VALUE_EXPR hash: size %ld, %ld elements, %f collisions\n", 4050169689Skan (long) htab_size (value_expr_for_decl), 4051169689Skan (long) htab_elements (value_expr_for_decl), 4052169689Skan htab_collisions (value_expr_for_decl)); 4053169689Skan} 4054169689Skan 4055169689Skan/* Print out statistics for the RESTRICT_BASE_FOR_DECL hash table, but 4056169689Skan don't print anything if the table is empty. */ 4057169689Skan 4058169689Skanstatic void 4059169689Skanprint_restrict_base_statistics (void) 4060169689Skan{ 4061169689Skan if (htab_elements (restrict_base_for_decl) != 0) 4062169689Skan fprintf (stderr, 4063169689Skan "RESTRICT_BASE hash: size %ld, %ld elements, %f collisions\n", 4064169689Skan (long) htab_size (restrict_base_for_decl), 4065169689Skan (long) htab_elements (restrict_base_for_decl), 4066169689Skan htab_collisions (restrict_base_for_decl)); 4067169689Skan} 4068169689Skan 4069169689Skan/* Lookup a debug expression for FROM, and return it if we find one. */ 4070169689Skan 4071169689Skantree 4072169689Skandecl_debug_expr_lookup (tree from) 4073169689Skan{ 4074169689Skan struct tree_map *h, in; 4075169689Skan in.from = from; 4076169689Skan 4077169689Skan h = htab_find_with_hash (debug_expr_for_decl, &in, htab_hash_pointer (from)); 4078169689Skan if (h) 4079169689Skan return h->to; 4080169689Skan return NULL_TREE; 4081169689Skan} 4082169689Skan 4083169689Skan/* Insert a mapping FROM->TO in the debug expression hashtable. */ 4084169689Skan 4085169689Skanvoid 4086169689Skandecl_debug_expr_insert (tree from, tree to) 4087169689Skan{ 4088169689Skan struct tree_map *h; 4089169689Skan void **loc; 4090169689Skan 4091169689Skan h = ggc_alloc (sizeof (struct tree_map)); 4092169689Skan h->hash = htab_hash_pointer (from); 4093169689Skan h->from = from; 4094169689Skan h->to = to; 4095169689Skan loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT); 4096169689Skan *(struct tree_map **) loc = h; 4097169689Skan} 4098169689Skan 4099169689Skan/* Lookup a value expression for FROM, and return it if we find one. */ 4100169689Skan 4101169689Skantree 4102169689Skandecl_value_expr_lookup (tree from) 4103169689Skan{ 4104169689Skan struct tree_map *h, in; 4105169689Skan in.from = from; 4106169689Skan 4107169689Skan h = htab_find_with_hash (value_expr_for_decl, &in, htab_hash_pointer (from)); 4108169689Skan if (h) 4109169689Skan return h->to; 4110169689Skan return NULL_TREE; 4111169689Skan} 4112169689Skan 4113169689Skan/* Insert a mapping FROM->TO in the value expression hashtable. */ 4114169689Skan 4115169689Skanvoid 4116169689Skandecl_value_expr_insert (tree from, tree to) 4117169689Skan{ 4118169689Skan struct tree_map *h; 4119169689Skan void **loc; 4120169689Skan 4121169689Skan h = ggc_alloc (sizeof (struct tree_map)); 4122169689Skan h->hash = htab_hash_pointer (from); 4123169689Skan h->from = from; 4124169689Skan h->to = to; 4125169689Skan loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT); 4126169689Skan *(struct tree_map **) loc = h; 4127169689Skan} 4128169689Skan 412918334Speter/* Hashing of types so that we don't make duplicates. 413018334Speter The entry point is `type_hash_canon'. */ 413118334Speter 413218334Speter/* Compute a hash code for a list of types (chain of TREE_LIST nodes 413318334Speter with types in the TREE_VALUE slots), by adding the hash codes 413418334Speter of the individual types. */ 413518334Speter 413690075Sobrienunsigned int 4137169689Skantype_hash_list (tree list, hashval_t hashcode) 413818334Speter{ 413990075Sobrien tree tail; 414090075Sobrien 4141169689Skan for (tail = list; tail; tail = TREE_CHAIN (tail)) 4142169689Skan if (TREE_VALUE (tail) != error_mark_node) 4143169689Skan hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)), 4144169689Skan hashcode); 414590075Sobrien 414618334Speter return hashcode; 414718334Speter} 414818334Speter 414990075Sobrien/* These are the Hashtable callback functions. */ 415090075Sobrien 4151169689Skan/* Returns true iff the types are equivalent. */ 415290075Sobrien 415390075Sobrienstatic int 4154132718Skantype_hash_eq (const void *va, const void *vb) 415590075Sobrien{ 415690075Sobrien const struct type_hash *a = va, *b = vb; 4157169689Skan 4158169689Skan /* First test the things that are the same for all types. */ 4159169689Skan if (a->hash != b->hash 4160169689Skan || TREE_CODE (a->type) != TREE_CODE (b->type) 4161169689Skan || TREE_TYPE (a->type) != TREE_TYPE (b->type) 4162169689Skan || !attribute_list_equal (TYPE_ATTRIBUTES (a->type), 4163169689Skan TYPE_ATTRIBUTES (b->type)) 4164169689Skan || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type) 4165169689Skan || TYPE_MODE (a->type) != TYPE_MODE (b->type)) 4166169689Skan return 0; 4167169689Skan 4168169689Skan switch (TREE_CODE (a->type)) 4169169689Skan { 4170169689Skan case VOID_TYPE: 4171169689Skan case COMPLEX_TYPE: 4172169689Skan case POINTER_TYPE: 4173169689Skan case REFERENCE_TYPE: 4174169689Skan return 1; 4175169689Skan 4176169689Skan case VECTOR_TYPE: 4177169689Skan return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type); 4178169689Skan 4179169689Skan case ENUMERAL_TYPE: 4180169689Skan if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type) 4181169689Skan && !(TYPE_VALUES (a->type) 4182169689Skan && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST 4183169689Skan && TYPE_VALUES (b->type) 4184169689Skan && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST 4185169689Skan && type_list_equal (TYPE_VALUES (a->type), 4186169689Skan TYPE_VALUES (b->type)))) 4187169689Skan return 0; 4188169689Skan 4189169689Skan /* ... fall through ... */ 4190169689Skan 4191169689Skan case INTEGER_TYPE: 4192169689Skan case REAL_TYPE: 4193169689Skan case BOOLEAN_TYPE: 4194169689Skan return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type) 4195169689Skan || tree_int_cst_equal (TYPE_MAX_VALUE (a->type), 4196169689Skan TYPE_MAX_VALUE (b->type))) 4197169689Skan && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type) 4198169689Skan || tree_int_cst_equal (TYPE_MIN_VALUE (a->type), 4199169689Skan TYPE_MIN_VALUE (b->type)))); 4200169689Skan 4201169689Skan case OFFSET_TYPE: 4202169689Skan return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type); 4203169689Skan 4204169689Skan case METHOD_TYPE: 4205169689Skan return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type) 4206169689Skan && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type) 4207169689Skan || (TYPE_ARG_TYPES (a->type) 4208169689Skan && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST 4209169689Skan && TYPE_ARG_TYPES (b->type) 4210169689Skan && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST 4211169689Skan && type_list_equal (TYPE_ARG_TYPES (a->type), 4212169689Skan TYPE_ARG_TYPES (b->type))))); 4213169689Skan 4214169689Skan case ARRAY_TYPE: 4215169689Skan return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type); 4216169689Skan 4217169689Skan case RECORD_TYPE: 4218169689Skan case UNION_TYPE: 4219169689Skan case QUAL_UNION_TYPE: 4220169689Skan return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type) 4221169689Skan || (TYPE_FIELDS (a->type) 4222169689Skan && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST 4223169689Skan && TYPE_FIELDS (b->type) 4224169689Skan && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST 4225169689Skan && type_list_equal (TYPE_FIELDS (a->type), 4226169689Skan TYPE_FIELDS (b->type)))); 4227169689Skan 4228169689Skan case FUNCTION_TYPE: 4229169689Skan return (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type) 4230169689Skan || (TYPE_ARG_TYPES (a->type) 4231169689Skan && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST 4232169689Skan && TYPE_ARG_TYPES (b->type) 4233169689Skan && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST 4234169689Skan && type_list_equal (TYPE_ARG_TYPES (a->type), 4235169689Skan TYPE_ARG_TYPES (b->type)))); 4236169689Skan 4237169689Skan default: 4238169689Skan return 0; 4239169689Skan } 424090075Sobrien} 424190075Sobrien 424290075Sobrien/* Return the cached hash value. */ 424390075Sobrien 4244117395Skanstatic hashval_t 4245132718Skantype_hash_hash (const void *item) 424690075Sobrien{ 424790075Sobrien return ((const struct type_hash *) item)->hash; 424890075Sobrien} 424990075Sobrien 425018334Speter/* Look in the type hash table for a type isomorphic to TYPE. 425118334Speter If one is found, return it. Otherwise return 0. */ 425218334Speter 425318334Spetertree 4254169689Skantype_hash_lookup (hashval_t hashcode, tree type) 425518334Speter{ 425690075Sobrien struct type_hash *h, in; 425790075Sobrien 425890075Sobrien /* The TYPE_ALIGN field of a type is set by layout_type(), so we 425990075Sobrien must call that routine before comparing TYPE_ALIGNs. */ 426090075Sobrien layout_type (type); 426190075Sobrien 426290075Sobrien in.hash = hashcode; 426390075Sobrien in.type = type; 426490075Sobrien 426590075Sobrien h = htab_find_with_hash (type_hash_table, &in, hashcode); 426690075Sobrien if (h) 426790075Sobrien return h->type; 426890075Sobrien return NULL_TREE; 426918334Speter} 427018334Speter 427118334Speter/* Add an entry to the type-hash-table 427218334Speter for a type TYPE whose hash code is HASHCODE. */ 427318334Speter 427418334Spetervoid 4275169689Skantype_hash_add (hashval_t hashcode, tree type) 427618334Speter{ 427790075Sobrien struct type_hash *h; 427890075Sobrien void **loc; 427918334Speter 4280132718Skan h = ggc_alloc (sizeof (struct type_hash)); 428190075Sobrien h->hash = hashcode; 428218334Speter h->type = type; 428390075Sobrien loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT); 428490075Sobrien *(struct type_hash **) loc = h; 428518334Speter} 428618334Speter 428718334Speter/* Given TYPE, and HASHCODE its hash code, return the canonical 428818334Speter object for an identical type if one already exists. 4289169689Skan Otherwise, return TYPE, and record it as the canonical object. 429018334Speter 429118334Speter To use this function, first create a type of the sort you want. 429218334Speter Then compute its hash code from the fields of the type that 429318334Speter make it different from other similar types. 4294169689Skan Then call this function and use the value. */ 429518334Speter 429618334Spetertree 4297132718Skantype_hash_canon (unsigned int hashcode, tree type) 429818334Speter{ 429918334Speter tree t1; 430018334Speter 4301169689Skan /* The hash table only contains main variants, so ensure that's what we're 4302169689Skan being passed. */ 4303169689Skan gcc_assert (TYPE_MAIN_VARIANT (type) == type); 4304169689Skan 4305169689Skan if (!lang_hooks.types.hash_types) 430618334Speter return type; 430718334Speter 430890075Sobrien /* See if the type is in the hash table already. If so, return it. 430990075Sobrien Otherwise, add the type. */ 431018334Speter t1 = type_hash_lookup (hashcode, type); 431118334Speter if (t1 != 0) 431218334Speter { 431318334Speter#ifdef GATHER_STATISTICS 431490075Sobrien tree_node_counts[(int) t_kind]--; 431590075Sobrien tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type); 431618334Speter#endif 431718334Speter return t1; 431818334Speter } 431990075Sobrien else 432090075Sobrien { 432190075Sobrien type_hash_add (hashcode, type); 432290075Sobrien return type; 432390075Sobrien } 432490075Sobrien} 432518334Speter 432690075Sobrien/* See if the data pointed to by the type hash table is marked. We consider 432790075Sobrien it marked if the type is marked or if a debug type number or symbol 432890075Sobrien table entry has been made for the type. This reduces the amount of 432990075Sobrien debugging output and eliminates that dependency of the debug output on 433090075Sobrien the number of garbage collections. */ 433118334Speter 433290075Sobrienstatic int 4333132718Skantype_hash_marked_p (const void *p) 433490075Sobrien{ 433590075Sobrien tree type = ((struct type_hash *) p)->type; 433690075Sobrien 433790075Sobrien return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type); 433818334Speter} 433918334Speter 434090075Sobrienstatic void 4341132718Skanprint_type_hash_statistics (void) 434290075Sobrien{ 434390075Sobrien fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n", 434490075Sobrien (long) htab_size (type_hash_table), 434590075Sobrien (long) htab_elements (type_hash_table), 434690075Sobrien htab_collisions (type_hash_table)); 434790075Sobrien} 434890075Sobrien 434918334Speter/* Compute a hash code for a list of attributes (chain of TREE_LIST nodes 435018334Speter with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots), 435118334Speter by adding the hash codes of the individual attributes. */ 435218334Speter 435390075Sobrienunsigned int 4354169689Skanattribute_hash_list (tree list, hashval_t hashcode) 435518334Speter{ 435690075Sobrien tree tail; 435790075Sobrien 4358169689Skan for (tail = list; tail; tail = TREE_CHAIN (tail)) 435918334Speter /* ??? Do we want to add in TREE_VALUE too? */ 4360169689Skan hashcode = iterative_hash_object 4361169689Skan (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode); 436218334Speter return hashcode; 436318334Speter} 436418334Speter 436518334Speter/* Given two lists of attributes, return true if list l2 is 436618334Speter equivalent to l1. */ 436718334Speter 436818334Speterint 4369132718Skanattribute_list_equal (tree l1, tree l2) 437018334Speter{ 4371117395Skan return attribute_list_contained (l1, l2) 4372117395Skan && attribute_list_contained (l2, l1); 437318334Speter} 437418334Speter 437518334Speter/* Given two lists of attributes, return true if list L2 is 437618334Speter completely contained within L1. */ 437718334Speter/* ??? This would be faster if attribute names were stored in a canonicalized 437818334Speter form. Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method 437918334Speter must be used to show these elements are equivalent (which they are). */ 438018334Speter/* ??? It's not clear that attributes with arguments will always be handled 438118334Speter correctly. */ 438218334Speter 438318334Speterint 4384132718Skanattribute_list_contained (tree l1, tree l2) 438518334Speter{ 438690075Sobrien tree t1, t2; 438718334Speter 438818334Speter /* First check the obvious, maybe the lists are identical. */ 438918334Speter if (l1 == l2) 439090075Sobrien return 1; 439118334Speter 439218334Speter /* Maybe the lists are similar. */ 439318334Speter for (t1 = l1, t2 = l2; 439490075Sobrien t1 != 0 && t2 != 0 439518334Speter && TREE_PURPOSE (t1) == TREE_PURPOSE (t2) 439618334Speter && TREE_VALUE (t1) == TREE_VALUE (t2); 439718334Speter t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)); 439818334Speter 439918334Speter /* Maybe the lists are equal. */ 440018334Speter if (t1 == 0 && t2 == 0) 440190075Sobrien return 1; 440218334Speter 440390075Sobrien for (; t2 != 0; t2 = TREE_CHAIN (t2)) 440418334Speter { 440590075Sobrien tree attr; 440690075Sobrien for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1); 440790075Sobrien attr != NULL_TREE; 440890075Sobrien attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), 440990075Sobrien TREE_CHAIN (attr))) 441090075Sobrien { 4411169689Skan if (TREE_VALUE (t2) != NULL 4412169689Skan && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST 4413169689Skan && TREE_VALUE (attr) != NULL 4414169689Skan && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST) 4415169689Skan { 4416169689Skan if (simple_cst_list_equal (TREE_VALUE (t2), 4417169689Skan TREE_VALUE (attr)) == 1) 4418169689Skan break; 4419169689Skan } 4420169689Skan else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1) 442190075Sobrien break; 442290075Sobrien } 442318334Speter 442490075Sobrien if (attr == 0) 442518334Speter return 0; 442618334Speter } 442718334Speter 442818334Speter return 1; 442918334Speter} 443018334Speter 443118334Speter/* Given two lists of types 443218334Speter (chains of TREE_LIST nodes with types in the TREE_VALUE slots) 443318334Speter return 1 if the lists contain the same types in the same order. 443418334Speter Also, the TREE_PURPOSEs must match. */ 443518334Speter 443618334Speterint 4437132718Skantype_list_equal (tree l1, tree l2) 443818334Speter{ 443990075Sobrien tree t1, t2; 444018334Speter 444118334Speter for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2)) 444218334Speter if (TREE_VALUE (t1) != TREE_VALUE (t2) 444318334Speter || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2) 444418334Speter && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2)) 444518334Speter && (TREE_TYPE (TREE_PURPOSE (t1)) 444618334Speter == TREE_TYPE (TREE_PURPOSE (t2)))))) 444718334Speter return 0; 444818334Speter 444918334Speter return t1 == t2; 445018334Speter} 445118334Speter 445290075Sobrien/* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE 445390075Sobrien given by TYPE. If the argument list accepts variable arguments, 445490075Sobrien then this function counts only the ordinary arguments. */ 445590075Sobrien 445690075Sobrienint 4457132718Skantype_num_arguments (tree type) 445890075Sobrien{ 445990075Sobrien int i = 0; 446090075Sobrien tree t; 446190075Sobrien 446290075Sobrien for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t)) 446390075Sobrien /* If the function does not take a variable number of arguments, 446490075Sobrien the last element in the list will have type `void'. */ 446590075Sobrien if (VOID_TYPE_P (TREE_VALUE (t))) 446690075Sobrien break; 446790075Sobrien else 446890075Sobrien ++i; 446990075Sobrien 447090075Sobrien return i; 447190075Sobrien} 447290075Sobrien 447318334Speter/* Nonzero if integer constants T1 and T2 447418334Speter represent the same constant value. */ 447518334Speter 447618334Speterint 4477132718Skantree_int_cst_equal (tree t1, tree t2) 447818334Speter{ 447918334Speter if (t1 == t2) 448018334Speter return 1; 448190075Sobrien 448218334Speter if (t1 == 0 || t2 == 0) 448318334Speter return 0; 448490075Sobrien 448518334Speter if (TREE_CODE (t1) == INTEGER_CST 448618334Speter && TREE_CODE (t2) == INTEGER_CST 448718334Speter && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 448818334Speter && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)) 448918334Speter return 1; 449090075Sobrien 449118334Speter return 0; 449218334Speter} 449318334Speter 449418334Speter/* Nonzero if integer constants T1 and T2 represent values that satisfy <. 449518334Speter The precise way of comparison depends on their data type. */ 449618334Speter 449718334Speterint 4498132718Skantree_int_cst_lt (tree t1, tree t2) 449918334Speter{ 450018334Speter if (t1 == t2) 450118334Speter return 0; 450218334Speter 4503169689Skan if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2))) 450496263Sobrien { 450596263Sobrien int t1_sgn = tree_int_cst_sgn (t1); 450696263Sobrien int t2_sgn = tree_int_cst_sgn (t2); 450796263Sobrien 450896263Sobrien if (t1_sgn < t2_sgn) 450996263Sobrien return 1; 451096263Sobrien else if (t1_sgn > t2_sgn) 451196263Sobrien return 0; 451296263Sobrien /* Otherwise, both are non-negative, so we compare them as 451396263Sobrien unsigned just in case one of them would overflow a signed 451496263Sobrien type. */ 451596263Sobrien } 4516169689Skan else if (!TYPE_UNSIGNED (TREE_TYPE (t1))) 451718334Speter return INT_CST_LT (t1, t2); 451890075Sobrien 451918334Speter return INT_CST_LT_UNSIGNED (t1, t2); 452018334Speter} 452118334Speter 452290075Sobrien/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2. */ 452390075Sobrien 452490075Sobrienint 4525132718Skantree_int_cst_compare (tree t1, tree t2) 452690075Sobrien{ 452790075Sobrien if (tree_int_cst_lt (t1, t2)) 452890075Sobrien return -1; 452990075Sobrien else if (tree_int_cst_lt (t2, t1)) 453090075Sobrien return 1; 4531117395Skan else 453290075Sobrien return 0; 453390075Sobrien} 453490075Sobrien 453596263Sobrien/* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on 453696263Sobrien the host. If POS is zero, the value can be represented in a single 4537169689Skan HOST_WIDE_INT. If POS is nonzero, the value must be non-negative and can 453896263Sobrien be represented in a single unsigned HOST_WIDE_INT. */ 453990075Sobrien 454090075Sobrienint 4541132718Skanhost_integerp (tree t, int pos) 454290075Sobrien{ 454390075Sobrien return (TREE_CODE (t) == INTEGER_CST 454490075Sobrien && ((TREE_INT_CST_HIGH (t) == 0 454590075Sobrien && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0) 454690075Sobrien || (! pos && TREE_INT_CST_HIGH (t) == -1 454796263Sobrien && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0 4548220150Smm && (!TYPE_UNSIGNED (TREE_TYPE (t)) 4549220150Smm || TYPE_IS_SIZETYPE (TREE_TYPE (t)))) 455096263Sobrien || (pos && TREE_INT_CST_HIGH (t) == 0))); 455190075Sobrien} 455290075Sobrien 455390075Sobrien/* Return the HOST_WIDE_INT least significant bits of T if it is an 455490075Sobrien INTEGER_CST and there is no overflow. POS is nonzero if the result must 4555169689Skan be non-negative. We must be able to satisfy the above conditions. */ 455690075Sobrien 455790075SobrienHOST_WIDE_INT 4558132718Skantree_low_cst (tree t, int pos) 455990075Sobrien{ 4560169689Skan gcc_assert (host_integerp (t, pos)); 4561169689Skan return TREE_INT_CST_LOW (t); 456290075Sobrien} 456390075Sobrien 456490075Sobrien/* Return the most significant bit of the integer constant T. */ 456590075Sobrien 456690075Sobrienint 4567132718Skantree_int_cst_msb (tree t) 456890075Sobrien{ 456990075Sobrien int prec; 457090075Sobrien HOST_WIDE_INT h; 457190075Sobrien unsigned HOST_WIDE_INT l; 457290075Sobrien 457390075Sobrien /* Note that using TYPE_PRECISION here is wrong. We care about the 457490075Sobrien actual bits, not the (arbitrary) range of the type. */ 457590075Sobrien prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1; 457690075Sobrien rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec, 457790075Sobrien 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0); 457890075Sobrien return (l & 1) == 1; 457990075Sobrien} 458090075Sobrien 458118334Speter/* Return an indication of the sign of the integer constant T. 458218334Speter The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0. 4583169689Skan Note that -1 will never be returned if T's type is unsigned. */ 458418334Speter 458518334Speterint 4586132718Skantree_int_cst_sgn (tree t) 458718334Speter{ 458818334Speter if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0) 458918334Speter return 0; 4590169689Skan else if (TYPE_UNSIGNED (TREE_TYPE (t))) 459118334Speter return 1; 459218334Speter else if (TREE_INT_CST_HIGH (t) < 0) 459318334Speter return -1; 459418334Speter else 459518334Speter return 1; 459618334Speter} 459718334Speter 459818334Speter/* Compare two constructor-element-type constants. Return 1 if the lists 459918334Speter are known to be equal; otherwise return 0. */ 460018334Speter 460118334Speterint 4602132718Skansimple_cst_list_equal (tree l1, tree l2) 460318334Speter{ 460418334Speter while (l1 != NULL_TREE && l2 != NULL_TREE) 460518334Speter { 460618334Speter if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1) 460718334Speter return 0; 460818334Speter 460918334Speter l1 = TREE_CHAIN (l1); 461018334Speter l2 = TREE_CHAIN (l2); 461118334Speter } 461218334Speter 461390075Sobrien return l1 == l2; 461418334Speter} 461518334Speter 461618334Speter/* Return truthvalue of whether T1 is the same tree structure as T2. 461718334Speter Return 1 if they are the same. 461818334Speter Return 0 if they are understandably different. 461918334Speter Return -1 if either contains tree structure not understood by 462018334Speter this function. */ 462118334Speter 462218334Speterint 4623132718Skansimple_cst_equal (tree t1, tree t2) 462418334Speter{ 462590075Sobrien enum tree_code code1, code2; 462618334Speter int cmp; 462790075Sobrien int i; 462818334Speter 462918334Speter if (t1 == t2) 463018334Speter return 1; 463118334Speter if (t1 == 0 || t2 == 0) 463218334Speter return 0; 463318334Speter 463418334Speter code1 = TREE_CODE (t1); 463518334Speter code2 = TREE_CODE (t2); 463618334Speter 463718334Speter if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR) 463852284Sobrien { 463952284Sobrien if (code2 == NOP_EXPR || code2 == CONVERT_EXPR 464052284Sobrien || code2 == NON_LVALUE_EXPR) 464152284Sobrien return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 464252284Sobrien else 464352284Sobrien return simple_cst_equal (TREE_OPERAND (t1, 0), t2); 464452284Sobrien } 464590075Sobrien 464618334Speter else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR 464718334Speter || code2 == NON_LVALUE_EXPR) 464818334Speter return simple_cst_equal (t1, TREE_OPERAND (t2, 0)); 464918334Speter 465018334Speter if (code1 != code2) 465118334Speter return 0; 465218334Speter 465318334Speter switch (code1) 465418334Speter { 465518334Speter case INTEGER_CST: 465690075Sobrien return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2) 465790075Sobrien && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2)); 465818334Speter 465918334Speter case REAL_CST: 466050397Sobrien return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2)); 466118334Speter 466218334Speter case STRING_CST: 466390075Sobrien return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2) 466490075Sobrien && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2), 466590075Sobrien TREE_STRING_LENGTH (t1))); 466618334Speter 466718334Speter case CONSTRUCTOR: 4668169689Skan { 4669169689Skan unsigned HOST_WIDE_INT idx; 4670169689Skan VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1); 4671169689Skan VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2); 467218334Speter 4673169689Skan if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2)) 4674169689Skan return false; 4675169689Skan 4676169689Skan for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx) 4677169689Skan /* ??? Should we handle also fields here? */ 4678169689Skan if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value, 4679169689Skan VEC_index (constructor_elt, v2, idx)->value)) 4680169689Skan return false; 4681169689Skan return true; 4682169689Skan } 4683169689Skan 468418334Speter case SAVE_EXPR: 468518334Speter return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 468618334Speter 468718334Speter case CALL_EXPR: 468818334Speter cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 468918334Speter if (cmp <= 0) 469018334Speter return cmp; 469190075Sobrien return 469290075Sobrien simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 469318334Speter 469418334Speter case TARGET_EXPR: 469518334Speter /* Special case: if either target is an unallocated VAR_DECL, 469618334Speter it means that it's going to be unified with whatever the 469718334Speter TARGET_EXPR is really supposed to initialize, so treat it 469818334Speter as being equivalent to anything. */ 469918334Speter if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL 470018334Speter && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE 470190075Sobrien && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0))) 470218334Speter || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL 470318334Speter && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE 470490075Sobrien && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0)))) 470518334Speter cmp = 1; 470618334Speter else 470718334Speter cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 470890075Sobrien 470918334Speter if (cmp <= 0) 471018334Speter return cmp; 471190075Sobrien 471218334Speter return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)); 471318334Speter 471418334Speter case WITH_CLEANUP_EXPR: 471518334Speter cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 471618334Speter if (cmp <= 0) 471718334Speter return cmp; 471818334Speter 471990075Sobrien return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1)); 472090075Sobrien 472118334Speter case COMPONENT_REF: 472218334Speter if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1)) 472318334Speter return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)); 472490075Sobrien 472518334Speter return 0; 472618334Speter 472718334Speter case VAR_DECL: 472818334Speter case PARM_DECL: 472918334Speter case CONST_DECL: 473018334Speter case FUNCTION_DECL: 473118334Speter return 0; 473290075Sobrien 473350397Sobrien default: 473450397Sobrien break; 473518334Speter } 473618334Speter 473718334Speter /* This general rule works for most tree codes. All exceptions should be 473818334Speter handled above. If this is a language-specific tree code, we can't 473918334Speter trust what might be in the operand, so say we don't know 474018334Speter the situation. */ 474150397Sobrien if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE) 474218334Speter return -1; 474318334Speter 474418334Speter switch (TREE_CODE_CLASS (code1)) 474518334Speter { 4746169689Skan case tcc_unary: 4747169689Skan case tcc_binary: 4748169689Skan case tcc_comparison: 4749169689Skan case tcc_expression: 4750169689Skan case tcc_reference: 4751169689Skan case tcc_statement: 475218334Speter cmp = 1; 475390075Sobrien for (i = 0; i < TREE_CODE_LENGTH (code1); i++) 475418334Speter { 475518334Speter cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i)); 475618334Speter if (cmp <= 0) 475718334Speter return cmp; 475818334Speter } 475990075Sobrien 476018334Speter return cmp; 476150397Sobrien 476250397Sobrien default: 476350397Sobrien return -1; 476418334Speter } 476518334Speter} 476690075Sobrien 476790075Sobrien/* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value. 476890075Sobrien Return -1, 0, or 1 if the value of T is less than, equal to, or greater 476990075Sobrien than U, respectively. */ 477090075Sobrien 477190075Sobrienint 4772132718Skancompare_tree_int (tree t, unsigned HOST_WIDE_INT u) 477390075Sobrien{ 477490075Sobrien if (tree_int_cst_sgn (t) < 0) 477590075Sobrien return -1; 477690075Sobrien else if (TREE_INT_CST_HIGH (t) != 0) 477790075Sobrien return 1; 477890075Sobrien else if (TREE_INT_CST_LOW (t) == u) 477990075Sobrien return 0; 478090075Sobrien else if (TREE_INT_CST_LOW (t) < u) 478190075Sobrien return -1; 478290075Sobrien else 478390075Sobrien return 1; 478490075Sobrien} 4785132718Skan 4786169689Skan/* Return true if CODE represents an associative tree code. Otherwise 4787169689Skan return false. */ 4788169689Skanbool 4789169689Skanassociative_tree_code (enum tree_code code) 4790169689Skan{ 4791169689Skan switch (code) 4792169689Skan { 4793169689Skan case BIT_IOR_EXPR: 4794169689Skan case BIT_AND_EXPR: 4795169689Skan case BIT_XOR_EXPR: 4796169689Skan case PLUS_EXPR: 4797169689Skan case MULT_EXPR: 4798169689Skan case MIN_EXPR: 4799169689Skan case MAX_EXPR: 4800169689Skan return true; 4801169689Skan 4802169689Skan default: 4803169689Skan break; 4804169689Skan } 4805169689Skan return false; 4806169689Skan} 4807169689Skan 4808169689Skan/* Return true if CODE represents a commutative tree code. Otherwise 4809169689Skan return false. */ 4810169689Skanbool 4811169689Skancommutative_tree_code (enum tree_code code) 4812169689Skan{ 4813169689Skan switch (code) 4814169689Skan { 4815169689Skan case PLUS_EXPR: 4816169689Skan case MULT_EXPR: 4817169689Skan case MIN_EXPR: 4818169689Skan case MAX_EXPR: 4819169689Skan case BIT_IOR_EXPR: 4820169689Skan case BIT_XOR_EXPR: 4821169689Skan case BIT_AND_EXPR: 4822169689Skan case NE_EXPR: 4823169689Skan case EQ_EXPR: 4824169689Skan case UNORDERED_EXPR: 4825169689Skan case ORDERED_EXPR: 4826169689Skan case UNEQ_EXPR: 4827169689Skan case LTGT_EXPR: 4828169689Skan case TRUTH_AND_EXPR: 4829169689Skan case TRUTH_XOR_EXPR: 4830169689Skan case TRUTH_OR_EXPR: 4831169689Skan return true; 4832169689Skan 4833169689Skan default: 4834169689Skan break; 4835169689Skan } 4836169689Skan return false; 4837169689Skan} 4838169689Skan 4839132718Skan/* Generate a hash value for an expression. This can be used iteratively 4840132718Skan by passing a previous result as the "val" argument. 4841132718Skan 4842132718Skan This function is intended to produce the same hash for expressions which 4843132718Skan would compare equal using operand_equal_p. */ 4844132718Skan 4845132718Skanhashval_t 4846132718Skaniterative_hash_expr (tree t, hashval_t val) 4847132718Skan{ 4848132718Skan int i; 4849132718Skan enum tree_code code; 4850132718Skan char class; 4851132718Skan 4852132718Skan if (t == NULL_TREE) 4853169689Skan return iterative_hash_pointer (t, val); 4854132718Skan 4855132718Skan code = TREE_CODE (t); 4856132718Skan 4857169689Skan switch (code) 4858132718Skan { 4859169689Skan /* Alas, constants aren't shared, so we can't rely on pointer 4860169689Skan identity. */ 4861169689Skan case INTEGER_CST: 4862169689Skan val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val); 4863169689Skan return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val); 4864169689Skan case REAL_CST: 4865169689Skan { 4866169689Skan unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t)); 4867169689Skan 4868169689Skan return iterative_hash_hashval_t (val2, val); 4869169689Skan } 4870169689Skan case STRING_CST: 4871169689Skan return iterative_hash (TREE_STRING_POINTER (t), 4872169689Skan TREE_STRING_LENGTH (t), val); 4873169689Skan case COMPLEX_CST: 4874169689Skan val = iterative_hash_expr (TREE_REALPART (t), val); 4875169689Skan return iterative_hash_expr (TREE_IMAGPART (t), val); 4876169689Skan case VECTOR_CST: 4877169689Skan return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val); 4878169689Skan 4879169689Skan case SSA_NAME: 4880169689Skan case VALUE_HANDLE: 4881169689Skan /* we can just compare by pointer. */ 4882169689Skan return iterative_hash_pointer (t, val); 4883169689Skan 4884169689Skan case TREE_LIST: 4885169689Skan /* A list of expressions, for a CALL_EXPR or as the elements of a 4886169689Skan VECTOR_CST. */ 4887169689Skan for (; t; t = TREE_CHAIN (t)) 4888169689Skan val = iterative_hash_expr (TREE_VALUE (t), val); 4889169689Skan return val; 4890169689Skan case CONSTRUCTOR: 4891169689Skan { 4892169689Skan unsigned HOST_WIDE_INT idx; 4893169689Skan tree field, value; 4894169689Skan FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value) 4895169689Skan { 4896169689Skan val = iterative_hash_expr (field, val); 4897169689Skan val = iterative_hash_expr (value, val); 4898169689Skan } 4899169689Skan return val; 4900169689Skan } 4901169689Skan case FUNCTION_DECL: 4902169689Skan /* When referring to a built-in FUNCTION_DECL, use the 4903169689Skan __builtin__ form. Otherwise nodes that compare equal 4904169689Skan according to operand_equal_p might get different 4905169689Skan hash codes. */ 4906169689Skan if (DECL_BUILT_IN (t)) 4907132718Skan { 4908169689Skan val = iterative_hash_pointer (built_in_decls[DECL_FUNCTION_CODE (t)], 4909169689Skan val); 4910169689Skan return val; 4911132718Skan } 4912169689Skan /* else FALL THROUGH */ 4913169689Skan default: 4914169689Skan class = TREE_CODE_CLASS (code); 4915169689Skan 4916169689Skan if (class == tcc_declaration) 4917132718Skan { 4918169689Skan /* DECL's have a unique ID */ 4919169689Skan val = iterative_hash_host_wide_int (DECL_UID (t), val); 4920132718Skan } 4921132718Skan else 4922169689Skan { 4923169689Skan gcc_assert (IS_EXPR_CODE_CLASS (class)); 4924169689Skan 4925169689Skan val = iterative_hash_object (code, val); 4926132718Skan 4927169689Skan /* Don't hash the type, that can lead to having nodes which 4928169689Skan compare equal according to operand_equal_p, but which 4929169689Skan have different hash codes. */ 4930169689Skan if (code == NOP_EXPR 4931169689Skan || code == CONVERT_EXPR 4932169689Skan || code == NON_LVALUE_EXPR) 4933169689Skan { 4934169689Skan /* Make sure to include signness in the hash computation. */ 4935169689Skan val += TYPE_UNSIGNED (TREE_TYPE (t)); 4936169689Skan val = iterative_hash_expr (TREE_OPERAND (t, 0), val); 4937169689Skan } 4938132718Skan 4939169689Skan else if (commutative_tree_code (code)) 4940169689Skan { 4941169689Skan /* It's a commutative expression. We want to hash it the same 4942169689Skan however it appears. We do this by first hashing both operands 4943169689Skan and then rehashing based on the order of their independent 4944169689Skan hashes. */ 4945169689Skan hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0); 4946169689Skan hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0); 4947169689Skan hashval_t t; 4948132718Skan 4949169689Skan if (one > two) 4950169689Skan t = one, one = two, two = t; 4951132718Skan 4952169689Skan val = iterative_hash_hashval_t (one, val); 4953169689Skan val = iterative_hash_hashval_t (two, val); 4954169689Skan } 4955169689Skan else 4956169689Skan for (i = TREE_CODE_LENGTH (code) - 1; i >= 0; --i) 4957169689Skan val = iterative_hash_expr (TREE_OPERAND (t, i), val); 4958132718Skan } 4959169689Skan return val; 4960169689Skan break; 4961132718Skan } 4962132718Skan} 496318334Speter 496418334Speter/* Constructors for pointer, array and function types. 496518334Speter (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are 496618334Speter constructed by language-dependent code, not here.) */ 496718334Speter 4968169689Skan/* Construct, lay out and return the type of pointers to TO_TYPE with 4969169689Skan mode MODE. If CAN_ALIAS_ALL is TRUE, indicate this type can 4970169689Skan reference all of memory. If such a type has already been 4971169689Skan constructed, reuse it. */ 497218334Speter 497318334Spetertree 4974169689Skanbuild_pointer_type_for_mode (tree to_type, enum machine_mode mode, 4975169689Skan bool can_alias_all) 497618334Speter{ 4977169689Skan tree t; 497818334Speter 4979169689Skan if (to_type == error_mark_node) 4980169689Skan return error_mark_node; 498118334Speter 4982169689Skan /* In some cases, languages will have things that aren't a POINTER_TYPE 4983169689Skan (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO. 4984169689Skan In that case, return that type without regard to the rest of our 4985169689Skan operands. 4986169689Skan 4987169689Skan ??? This is a kludge, but consistent with the way this function has 4988169689Skan always operated and there doesn't seem to be a good way to avoid this 4989169689Skan at the moment. */ 4990169689Skan if (TYPE_POINTER_TO (to_type) != 0 4991169689Skan && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE) 4992169689Skan return TYPE_POINTER_TO (to_type); 4993169689Skan 4994169689Skan /* First, if we already have a type for pointers to TO_TYPE and it's 4995169689Skan the proper mode, use it. */ 4996169689Skan for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t)) 4997169689Skan if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all) 4998169689Skan return t; 4999169689Skan 500018334Speter t = make_node (POINTER_TYPE); 500118334Speter 500218334Speter TREE_TYPE (t) = to_type; 5003132718Skan TYPE_MODE (t) = mode; 5004169689Skan TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all; 5005169689Skan TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type); 500618334Speter TYPE_POINTER_TO (to_type) = t; 500718334Speter 500818334Speter /* Lay out the type. This function has many callers that are concerned 5009169689Skan with expression-construction, and this simplifies them all. */ 501018334Speter layout_type (t); 501118334Speter 501218334Speter return t; 501318334Speter} 501418334Speter 5015132718Skan/* By default build pointers in ptr_mode. */ 501690075Sobrien 501790075Sobrientree 5018132718Skanbuild_pointer_type (tree to_type) 501990075Sobrien{ 5020169689Skan return build_pointer_type_for_mode (to_type, ptr_mode, false); 5021132718Skan} 5022132718Skan 5023261188Spfg/* APPLE LOCAL begin radar 5732232 - blocks */ 5024261188Spfgtree 5025261188Spfgbuild_block_pointer_type (tree to_type) 5026261188Spfg{ 5027261188Spfg tree t; 5028261188Spfg 5029261188Spfg /* APPLE LOCAL begin radar 6300081 & 6353006 */ 5030261188Spfg if (!generic_block_literal_struct_type) 5031261188Spfg generic_block_literal_struct_type = 5032261188Spfg lang_hooks.build_generic_block_struct_type (); 5033261188Spfg /* APPLE LOCAL end radar 6300081 & 6353006 */ 5034261188Spfg 5035261188Spfg t = make_node (BLOCK_POINTER_TYPE); 5036261188Spfg 5037261188Spfg TREE_TYPE (t) = to_type; 5038261188Spfg TYPE_MODE (t) = ptr_mode; 5039261188Spfg 5040261188Spfg /* Lay out the type. This function has many callers that are concerned 5041261188Spfg with expression-construction, and this simplifies them all. */ 5042261188Spfg layout_type (t); 5043261188Spfg 5044261188Spfg return t; 5045261188Spfg} 5046261188Spfg/* APPLE LOCAL end radar 5732232 - blocks */ 5047261188Spfg 5048169689Skan/* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE. */ 5049132718Skan 5050132718Skantree 5051169689Skanbuild_reference_type_for_mode (tree to_type, enum machine_mode mode, 5052169689Skan bool can_alias_all) 5053132718Skan{ 5054169689Skan tree t; 505590075Sobrien 5056169689Skan /* In some cases, languages will have things that aren't a REFERENCE_TYPE 5057169689Skan (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO. 5058169689Skan In that case, return that type without regard to the rest of our 5059169689Skan operands. 506090075Sobrien 5061169689Skan ??? This is a kludge, but consistent with the way this function has 5062169689Skan always operated and there doesn't seem to be a good way to avoid this 5063169689Skan at the moment. */ 5064169689Skan if (TYPE_REFERENCE_TO (to_type) != 0 5065169689Skan && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE) 5066169689Skan return TYPE_REFERENCE_TO (to_type); 5067169689Skan 5068169689Skan /* First, if we already have a type for pointers to TO_TYPE and it's 5069169689Skan the proper mode, use it. */ 5070169689Skan for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t)) 5071169689Skan if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all) 5072169689Skan return t; 5073169689Skan 507490075Sobrien t = make_node (REFERENCE_TYPE); 507590075Sobrien 507690075Sobrien TREE_TYPE (t) = to_type; 5077132718Skan TYPE_MODE (t) = mode; 5078169689Skan TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all; 5079169689Skan TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type); 508090075Sobrien TYPE_REFERENCE_TO (to_type) = t; 508190075Sobrien 508290075Sobrien layout_type (t); 508390075Sobrien 508490075Sobrien return t; 508590075Sobrien} 508690075Sobrien 5087132718Skan 5088132718Skan/* Build the node for the type of references-to-TO_TYPE by default 5089132718Skan in ptr_mode. */ 5090132718Skan 5091132718Skantree 5092132718Skanbuild_reference_type (tree to_type) 5093132718Skan{ 5094169689Skan return build_reference_type_for_mode (to_type, ptr_mode, false); 5095132718Skan} 5096132718Skan 509790075Sobrien/* Build a type that is compatible with t but has no cv quals anywhere 509890075Sobrien in its type, thus 509990075Sobrien 510090075Sobrien const char *const *const * -> char ***. */ 510190075Sobrien 510290075Sobrientree 5103132718Skanbuild_type_no_quals (tree t) 510490075Sobrien{ 510590075Sobrien switch (TREE_CODE (t)) 510690075Sobrien { 510790075Sobrien case POINTER_TYPE: 5108169689Skan return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)), 5109169689Skan TYPE_MODE (t), 5110169689Skan TYPE_REF_CAN_ALIAS_ALL (t)); 511190075Sobrien case REFERENCE_TYPE: 5112169689Skan return 5113169689Skan build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)), 5114169689Skan TYPE_MODE (t), 5115169689Skan TYPE_REF_CAN_ALIAS_ALL (t)); 511690075Sobrien default: 511790075Sobrien return TYPE_MAIN_VARIANT (t); 511890075Sobrien } 511990075Sobrien} 512090075Sobrien 512118334Speter/* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE. 512218334Speter MAXVAL should be the maximum value in the domain 512350397Sobrien (one less than the length of the array). 512418334Speter 512550397Sobrien The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT. 512650397Sobrien We don't enforce this limit, that is up to caller (e.g. language front end). 512750397Sobrien The limit exists because the result is a signed type and we don't handle 512850397Sobrien sizes that use more than one HOST_WIDE_INT. */ 512950397Sobrien 513018334Spetertree 5131132718Skanbuild_index_type (tree maxval) 513218334Speter{ 513390075Sobrien tree itype = make_node (INTEGER_TYPE); 513450397Sobrien 513590075Sobrien TREE_TYPE (itype) = sizetype; 513618334Speter TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype); 513750397Sobrien TYPE_MIN_VALUE (itype) = size_zero_node; 5138169689Skan TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval); 513918334Speter TYPE_MODE (itype) = TYPE_MODE (sizetype); 514018334Speter TYPE_SIZE (itype) = TYPE_SIZE (sizetype); 514150397Sobrien TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype); 514218334Speter TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype); 514390075Sobrien TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype); 514490075Sobrien 514590075Sobrien if (host_integerp (maxval, 1)) 514690075Sobrien return type_hash_canon (tree_low_cst (maxval, 1), itype); 514718334Speter else 514818334Speter return itype; 514918334Speter} 515018334Speter 5151169689Skan/* Builds a signed or unsigned integer type of precision PRECISION. 5152169689Skan Used for C bitfields whose precision does not match that of 5153169689Skan built-in target types. */ 5154169689Skantree 5155169689Skanbuild_nonstandard_integer_type (unsigned HOST_WIDE_INT precision, 5156169689Skan int unsignedp) 5157169689Skan{ 5158169689Skan tree itype = make_node (INTEGER_TYPE); 5159169689Skan 5160169689Skan TYPE_PRECISION (itype) = precision; 5161169689Skan 5162169689Skan if (unsignedp) 5163169689Skan fixup_unsigned_type (itype); 5164169689Skan else 5165169689Skan fixup_signed_type (itype); 5166169689Skan 5167169689Skan if (host_integerp (TYPE_MAX_VALUE (itype), 1)) 5168169689Skan return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype); 5169169689Skan 5170169689Skan return itype; 5171169689Skan} 5172169689Skan 517318334Speter/* Create a range of some discrete type TYPE (an INTEGER_TYPE, 5174169689Skan ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and 5175169689Skan high bound HIGHVAL. If TYPE is NULL, sizetype is used. */ 517618334Speter 517718334Spetertree 5178132718Skanbuild_range_type (tree type, tree lowval, tree highval) 517918334Speter{ 518090075Sobrien tree itype = make_node (INTEGER_TYPE); 518150397Sobrien 518218334Speter TREE_TYPE (itype) = type; 518318334Speter if (type == NULL_TREE) 518418334Speter type = sizetype; 518550397Sobrien 5186169689Skan TYPE_MIN_VALUE (itype) = fold_convert (type, lowval); 5187169689Skan TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL; 518850397Sobrien 518918334Speter TYPE_PRECISION (itype) = TYPE_PRECISION (type); 519018334Speter TYPE_MODE (itype) = TYPE_MODE (type); 519118334Speter TYPE_SIZE (itype) = TYPE_SIZE (type); 519250397Sobrien TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type); 519318334Speter TYPE_ALIGN (itype) = TYPE_ALIGN (type); 519490075Sobrien TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type); 519550397Sobrien 519690075Sobrien if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0)) 519790075Sobrien return type_hash_canon (tree_low_cst (highval, 0) 519890075Sobrien - tree_low_cst (lowval, 0), 519990075Sobrien itype); 520018334Speter else 520118334Speter return itype; 520218334Speter} 520318334Speter 520418334Speter/* Just like build_index_type, but takes lowval and highval instead 520550397Sobrien of just highval (maxval). */ 520618334Speter 520718334Spetertree 5208132718Skanbuild_index_2_type (tree lowval, tree highval) 520918334Speter{ 521090075Sobrien return build_range_type (sizetype, lowval, highval); 521118334Speter} 521218334Speter 521318334Speter/* Construct, lay out and return the type of arrays of elements with ELT_TYPE 521418334Speter and number of elements specified by the range of values of INDEX_TYPE. 521518334Speter If such a type has already been constructed, reuse it. */ 521618334Speter 521718334Spetertree 5218132718Skanbuild_array_type (tree elt_type, tree index_type) 521918334Speter{ 522090075Sobrien tree t; 5221169689Skan hashval_t hashcode = 0; 522218334Speter 522318334Speter if (TREE_CODE (elt_type) == FUNCTION_TYPE) 522418334Speter { 522518334Speter error ("arrays of functions are not meaningful"); 522618334Speter elt_type = integer_type_node; 522718334Speter } 522818334Speter 522918334Speter t = make_node (ARRAY_TYPE); 523018334Speter TREE_TYPE (t) = elt_type; 523118334Speter TYPE_DOMAIN (t) = index_type; 5232169689Skan 523318334Speter if (index_type == 0) 523418334Speter { 5235169689Skan tree save = t; 5236169689Skan hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode); 5237169689Skan t = type_hash_canon (hashcode, t); 5238169689Skan if (save == t) 5239169689Skan layout_type (t); 524018334Speter return t; 524118334Speter } 524218334Speter 5243169689Skan hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode); 5244169689Skan hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode); 524518334Speter t = type_hash_canon (hashcode, t); 524618334Speter 524790075Sobrien if (!COMPLETE_TYPE_P (t)) 524818334Speter layout_type (t); 524918334Speter return t; 525018334Speter} 525118334Speter 525250397Sobrien/* Return the TYPE of the elements comprising 525350397Sobrien the innermost dimension of ARRAY. */ 525450397Sobrien 525550397Sobrientree 5256132718Skanget_inner_array_type (tree array) 525750397Sobrien{ 525850397Sobrien tree type = TREE_TYPE (array); 525950397Sobrien 526050397Sobrien while (TREE_CODE (type) == ARRAY_TYPE) 526150397Sobrien type = TREE_TYPE (type); 526250397Sobrien 526350397Sobrien return type; 526450397Sobrien} 526550397Sobrien 526618334Speter/* Construct, lay out and return 526718334Speter the type of functions returning type VALUE_TYPE 526818334Speter given arguments of types ARG_TYPES. 526918334Speter ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs 527018334Speter are data type nodes for the arguments of the function. 527118334Speter If such a type has already been constructed, reuse it. */ 527218334Speter 527318334Spetertree 5274132718Skanbuild_function_type (tree value_type, tree arg_types) 527518334Speter{ 527690075Sobrien tree t; 5277169689Skan hashval_t hashcode = 0; 527818334Speter 527918334Speter if (TREE_CODE (value_type) == FUNCTION_TYPE) 528018334Speter { 528118334Speter error ("function return type cannot be function"); 528218334Speter value_type = integer_type_node; 528318334Speter } 528418334Speter 528518334Speter /* Make a node of the sort we want. */ 528618334Speter t = make_node (FUNCTION_TYPE); 528718334Speter TREE_TYPE (t) = value_type; 528818334Speter TYPE_ARG_TYPES (t) = arg_types; 528918334Speter 5290169689Skan /* If we already have such a type, use the old one. */ 5291169689Skan hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode); 5292169689Skan hashcode = type_hash_list (arg_types, hashcode); 529318334Speter t = type_hash_canon (hashcode, t); 529418334Speter 529590075Sobrien if (!COMPLETE_TYPE_P (t)) 529618334Speter layout_type (t); 529718334Speter return t; 529818334Speter} 529918334Speter 5300132718Skan/* Build a function type. The RETURN_TYPE is the type returned by the 5301117395Skan function. If additional arguments are provided, they are 5302117395Skan additional argument types. The list of argument types must always 5303117395Skan be terminated by NULL_TREE. */ 5304117395Skan 5305117395Skantree 5306132718Skanbuild_function_type_list (tree return_type, ...) 5307117395Skan{ 5308117395Skan tree t, args, last; 5309132718Skan va_list p; 5310117395Skan 5311132718Skan va_start (p, return_type); 5312117395Skan 5313117395Skan t = va_arg (p, tree); 5314117395Skan for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree)) 5315117395Skan args = tree_cons (NULL_TREE, t, args); 5316117395Skan 5317169689Skan if (args == NULL_TREE) 5318169689Skan args = void_list_node; 5319169689Skan else 5320169689Skan { 5321169689Skan last = args; 5322169689Skan args = nreverse (args); 5323169689Skan TREE_CHAIN (last) = void_list_node; 5324169689Skan } 5325117395Skan args = build_function_type (return_type, args); 5326117395Skan 5327132718Skan va_end (p); 5328117395Skan return args; 5329117395Skan} 5330117395Skan 5331132718Skan/* Build a METHOD_TYPE for a member of BASETYPE. The RETTYPE (a TYPE) 5332132718Skan and ARGTYPES (a TREE_LIST) are the return type and arguments types 5333132718Skan for the method. An implicit additional parameter (of type 5334132718Skan pointer-to-BASETYPE) is added to the ARGTYPES. */ 533518334Speter 533618334Spetertree 5337132718Skanbuild_method_type_directly (tree basetype, 5338132718Skan tree rettype, 5339132718Skan tree argtypes) 534018334Speter{ 534190075Sobrien tree t; 5342132718Skan tree ptype; 5343169689Skan int hashcode = 0; 534418334Speter 534518334Speter /* Make a node of the sort we want. */ 534618334Speter t = make_node (METHOD_TYPE); 534718334Speter 534818334Speter TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); 5349132718Skan TREE_TYPE (t) = rettype; 5350132718Skan ptype = build_pointer_type (basetype); 535118334Speter 535218334Speter /* The actual arglist for this function includes a "hidden" argument 535318334Speter which is "this". Put it into the list of argument types. */ 5354132718Skan argtypes = tree_cons (NULL_TREE, ptype, argtypes); 5355132718Skan TYPE_ARG_TYPES (t) = argtypes; 535618334Speter 5357169689Skan /* If we already have such a type, use the old one. */ 5358169689Skan hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode); 5359169689Skan hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode); 5360169689Skan hashcode = type_hash_list (argtypes, hashcode); 536118334Speter t = type_hash_canon (hashcode, t); 536218334Speter 536390075Sobrien if (!COMPLETE_TYPE_P (t)) 536418334Speter layout_type (t); 536518334Speter 536618334Speter return t; 536718334Speter} 536818334Speter 5369132718Skan/* Construct, lay out and return the type of methods belonging to class 5370132718Skan BASETYPE and whose arguments and values are described by TYPE. 5371132718Skan If that type exists already, reuse it. 5372132718Skan TYPE must be a FUNCTION_TYPE node. */ 5373132718Skan 5374132718Skantree 5375132718Skanbuild_method_type (tree basetype, tree type) 5376132718Skan{ 5377169689Skan gcc_assert (TREE_CODE (type) == FUNCTION_TYPE); 5378132718Skan 5379169689Skan return build_method_type_directly (basetype, 5380132718Skan TREE_TYPE (type), 5381132718Skan TYPE_ARG_TYPES (type)); 5382132718Skan} 5383132718Skan 538418334Speter/* Construct, lay out and return the type of offsets to a value 538518334Speter of type TYPE, within an object of type BASETYPE. 538618334Speter If a suitable offset type exists already, reuse it. */ 538718334Speter 538818334Spetertree 5389132718Skanbuild_offset_type (tree basetype, tree type) 539018334Speter{ 539190075Sobrien tree t; 5392169689Skan hashval_t hashcode = 0; 539318334Speter 539418334Speter /* Make a node of the sort we want. */ 539518334Speter t = make_node (OFFSET_TYPE); 539618334Speter 539718334Speter TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype); 539818334Speter TREE_TYPE (t) = type; 539918334Speter 5400169689Skan /* If we already have such a type, use the old one. */ 5401169689Skan hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode); 5402169689Skan hashcode = iterative_hash_object (TYPE_HASH (type), hashcode); 540318334Speter t = type_hash_canon (hashcode, t); 540418334Speter 540590075Sobrien if (!COMPLETE_TYPE_P (t)) 540618334Speter layout_type (t); 540718334Speter 540818334Speter return t; 540918334Speter} 541018334Speter 541118334Speter/* Create a complex type whose components are COMPONENT_TYPE. */ 541218334Speter 541318334Spetertree 5414132718Skanbuild_complex_type (tree component_type) 541518334Speter{ 541690075Sobrien tree t; 5417169689Skan hashval_t hashcode; 541818334Speter 541918334Speter /* Make a node of the sort we want. */ 542018334Speter t = make_node (COMPLEX_TYPE); 542118334Speter 542218334Speter TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type); 542318334Speter 5424169689Skan /* If we already have such a type, use the old one. */ 5425169689Skan hashcode = iterative_hash_object (TYPE_HASH (component_type), 0); 542618334Speter t = type_hash_canon (hashcode, t); 542718334Speter 542890075Sobrien if (!COMPLETE_TYPE_P (t)) 542918334Speter layout_type (t); 543018334Speter 543190075Sobrien /* If we are writing Dwarf2 output we need to create a name, 543290075Sobrien since complex is a fundamental type. */ 543390075Sobrien if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 543490075Sobrien && ! TYPE_NAME (t)) 543590075Sobrien { 543690075Sobrien const char *name; 543790075Sobrien if (component_type == char_type_node) 543890075Sobrien name = "complex char"; 543990075Sobrien else if (component_type == signed_char_type_node) 544090075Sobrien name = "complex signed char"; 544190075Sobrien else if (component_type == unsigned_char_type_node) 544290075Sobrien name = "complex unsigned char"; 544390075Sobrien else if (component_type == short_integer_type_node) 544490075Sobrien name = "complex short int"; 544590075Sobrien else if (component_type == short_unsigned_type_node) 544690075Sobrien name = "complex short unsigned int"; 544790075Sobrien else if (component_type == integer_type_node) 544890075Sobrien name = "complex int"; 544990075Sobrien else if (component_type == unsigned_type_node) 545090075Sobrien name = "complex unsigned int"; 545190075Sobrien else if (component_type == long_integer_type_node) 545290075Sobrien name = "complex long int"; 545390075Sobrien else if (component_type == long_unsigned_type_node) 545490075Sobrien name = "complex long unsigned int"; 545590075Sobrien else if (component_type == long_long_integer_type_node) 545690075Sobrien name = "complex long long int"; 545790075Sobrien else if (component_type == long_long_unsigned_type_node) 545890075Sobrien name = "complex long long unsigned int"; 545990075Sobrien else 546090075Sobrien name = 0; 546190075Sobrien 546290075Sobrien if (name != 0) 546390075Sobrien TYPE_NAME (t) = get_identifier (name); 546490075Sobrien } 546590075Sobrien 5466169689Skan return build_qualified_type (t, TYPE_QUALS (component_type)); 546718334Speter} 546818334Speter 546918334Speter/* Return OP, stripped of any conversions to wider types as much as is safe. 547018334Speter Converting the value back to OP's type makes a value equivalent to OP. 547118334Speter 547218334Speter If FOR_TYPE is nonzero, we return a value which, if converted to 547318334Speter type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE. 547418334Speter 547518334Speter If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the 547618334Speter narrowest type that can hold the value, even if they don't exactly fit. 547718334Speter Otherwise, bit-field references are changed to a narrower type 547818334Speter only if they can be fetched directly from memory in that type. 547918334Speter 548018334Speter OP must have integer, real or enumeral type. Pointers are not allowed! 548118334Speter 548218334Speter There are some cases where the obvious value we could return 548390075Sobrien would regenerate to OP if converted to OP's type, 548418334Speter but would not extend like OP to wider types. 548518334Speter If FOR_TYPE indicates such extension is contemplated, we eschew such values. 548618334Speter For example, if OP is (unsigned short)(signed char)-1, 548718334Speter we avoid returning (signed char)-1 if FOR_TYPE is int, 548818334Speter even though extending that to an unsigned short would regenerate OP, 548918334Speter since the result of extending (signed char)-1 to (int) 549018334Speter is different from (int) OP. */ 549118334Speter 549218334Spetertree 5493132718Skanget_unwidened (tree op, tree for_type) 549418334Speter{ 549518334Speter /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension. */ 549690075Sobrien tree type = TREE_TYPE (op); 549790075Sobrien unsigned final_prec 549818334Speter = TYPE_PRECISION (for_type != 0 ? for_type : type); 549990075Sobrien int uns 550018334Speter = (for_type != 0 && for_type != type 550118334Speter && final_prec > TYPE_PRECISION (type) 5502169689Skan && TYPE_UNSIGNED (type)); 550390075Sobrien tree win = op; 550418334Speter 5505169689Skan while (TREE_CODE (op) == NOP_EXPR 5506169689Skan || TREE_CODE (op) == CONVERT_EXPR) 550718334Speter { 5508169689Skan int bitschange; 550918334Speter 5510169689Skan /* TYPE_PRECISION on vector types has different meaning 5511169689Skan (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions, 5512169689Skan so avoid them here. */ 5513169689Skan if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE) 5514169689Skan break; 5515169689Skan 5516169689Skan bitschange = TYPE_PRECISION (TREE_TYPE (op)) 5517169689Skan - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))); 5518169689Skan 551918334Speter /* Truncations are many-one so cannot be removed. 552018334Speter Unless we are later going to truncate down even farther. */ 552118334Speter if (bitschange < 0 552218334Speter && final_prec > TYPE_PRECISION (TREE_TYPE (op))) 552318334Speter break; 552418334Speter 552518334Speter /* See what's inside this conversion. If we decide to strip it, 552618334Speter we will set WIN. */ 552718334Speter op = TREE_OPERAND (op, 0); 552818334Speter 552918334Speter /* If we have not stripped any zero-extensions (uns is 0), 553018334Speter we can strip any kind of extension. 553118334Speter If we have previously stripped a zero-extension, 553218334Speter only zero-extensions can safely be stripped. 553318334Speter Any extension can be stripped if the bits it would produce 553418334Speter are all going to be discarded later by truncating to FOR_TYPE. */ 553518334Speter 553618334Speter if (bitschange > 0) 553718334Speter { 553818334Speter if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op))) 553918334Speter win = op; 5540169689Skan /* TYPE_UNSIGNED says whether this is a zero-extension. 554118334Speter Let's avoid computing it if it does not affect WIN 554218334Speter and if UNS will not be needed again. */ 5543169689Skan if ((uns 5544169689Skan || TREE_CODE (op) == NOP_EXPR 5545169689Skan || TREE_CODE (op) == CONVERT_EXPR) 5546169689Skan && TYPE_UNSIGNED (TREE_TYPE (op))) 554718334Speter { 554818334Speter uns = 1; 554918334Speter win = op; 555018334Speter } 555118334Speter } 555218334Speter } 555318334Speter 555418334Speter if (TREE_CODE (op) == COMPONENT_REF 555518334Speter /* Since type_for_size always gives an integer type. */ 555650397Sobrien && TREE_CODE (type) != REAL_TYPE 555750397Sobrien /* Don't crash if field not laid out yet. */ 555890075Sobrien && DECL_SIZE (TREE_OPERAND (op, 1)) != 0 555990075Sobrien && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1)) 556018334Speter { 556190075Sobrien unsigned int innerprec 556290075Sobrien = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); 5563169689Skan int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1)) 5564169689Skan || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); 5565169689Skan type = lang_hooks.types.type_for_size (innerprec, unsignedp); 556690075Sobrien 556718334Speter /* We can get this structure field in the narrowest type it fits in. 556818334Speter If FOR_TYPE is 0, do this only for a field that matches the 556918334Speter narrower type exactly and is aligned for it 557018334Speter The resulting extension to its nominal type (a fullword type) 557118334Speter must fit the same conditions as for other extensions. */ 557218334Speter 5573132718Skan if (type != 0 5574132718Skan && INT_CST_LT_UNSIGNED (TYPE_SIZE (type), TYPE_SIZE (TREE_TYPE (op))) 557518334Speter && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))) 5576132718Skan && (! uns || final_prec <= innerprec || unsignedp)) 557718334Speter { 5578169689Skan win = build3 (COMPONENT_REF, type, TREE_OPERAND (op, 0), 5579169689Skan TREE_OPERAND (op, 1), NULL_TREE); 558018334Speter TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op); 558118334Speter TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op); 558218334Speter } 558318334Speter } 558490075Sobrien 558518334Speter return win; 558618334Speter} 558718334Speter 558818334Speter/* Return OP or a simpler expression for a narrower value 558918334Speter which can be sign-extended or zero-extended to give back OP. 559018334Speter Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended 559118334Speter or 0 if the value should be sign-extended. */ 559218334Speter 559318334Spetertree 5594132718Skanget_narrower (tree op, int *unsignedp_ptr) 559518334Speter{ 559690075Sobrien int uns = 0; 559718334Speter int first = 1; 559890075Sobrien tree win = op; 5599161651Skan bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op)); 560018334Speter 560118334Speter while (TREE_CODE (op) == NOP_EXPR) 560218334Speter { 560390075Sobrien int bitschange 560490075Sobrien = (TYPE_PRECISION (TREE_TYPE (op)) 560590075Sobrien - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)))); 560618334Speter 560718334Speter /* Truncations are many-one so cannot be removed. */ 560818334Speter if (bitschange < 0) 560918334Speter break; 561018334Speter 561118334Speter /* See what's inside this conversion. If we decide to strip it, 561218334Speter we will set WIN. */ 561318334Speter 561418334Speter if (bitschange > 0) 561518334Speter { 5616117395Skan op = TREE_OPERAND (op, 0); 561718334Speter /* An extension: the outermost one can be stripped, 561818334Speter but remember whether it is zero or sign extension. */ 561918334Speter if (first) 5620169689Skan uns = TYPE_UNSIGNED (TREE_TYPE (op)); 562118334Speter /* Otherwise, if a sign extension has been stripped, 562218334Speter only sign extensions can now be stripped; 562318334Speter if a zero extension has been stripped, only zero-extensions. */ 5624169689Skan else if (uns != TYPE_UNSIGNED (TREE_TYPE (op))) 562518334Speter break; 562618334Speter first = 0; 562718334Speter } 562818334Speter else /* bitschange == 0 */ 562918334Speter { 563018334Speter /* A change in nominal type can always be stripped, but we must 563118334Speter preserve the unsignedness. */ 563218334Speter if (first) 5633169689Skan uns = TYPE_UNSIGNED (TREE_TYPE (op)); 563418334Speter first = 0; 5635117395Skan op = TREE_OPERAND (op, 0); 5636161651Skan /* Keep trying to narrow, but don't assign op to win if it 5637161651Skan would turn an integral type into something else. */ 5638161651Skan if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p) 5639161651Skan continue; 564018334Speter } 564118334Speter 564218334Speter win = op; 564318334Speter } 564418334Speter 564518334Speter if (TREE_CODE (op) == COMPONENT_REF 564618334Speter /* Since type_for_size always gives an integer type. */ 564790075Sobrien && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE 564890075Sobrien /* Ensure field is laid out already. */ 5649169689Skan && DECL_SIZE (TREE_OPERAND (op, 1)) != 0 5650169689Skan && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1)) 565118334Speter { 565290075Sobrien unsigned HOST_WIDE_INT innerprec 565390075Sobrien = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1); 5654169689Skan int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1)) 5655169689Skan || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1)))); 5656169689Skan tree type = lang_hooks.types.type_for_size (innerprec, unsignedp); 565718334Speter 565818334Speter /* We can get this structure field in a narrower type that fits it, 565918334Speter but the resulting extension to its nominal type (a fullword type) 566018334Speter must satisfy the same conditions as for other extensions. 566118334Speter 566218334Speter Do this only for fields that are aligned (not bit-fields), 566318334Speter because when bit-field insns will be used there is no 566418334Speter advantage in doing this. */ 566518334Speter 566618334Speter if (innerprec < TYPE_PRECISION (TREE_TYPE (op)) 566718334Speter && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)) 5668169689Skan && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1))) 566918334Speter && type != 0) 567018334Speter { 567118334Speter if (first) 5672169689Skan uns = DECL_UNSIGNED (TREE_OPERAND (op, 1)); 5673169689Skan win = fold_convert (type, op); 567418334Speter } 567518334Speter } 5676169689Skan 567718334Speter *unsignedp_ptr = uns; 567818334Speter return win; 567918334Speter} 568018334Speter 568118334Speter/* Nonzero if integer constant C has a value that is permissible 568218334Speter for type TYPE (an INTEGER_TYPE). */ 568318334Speter 568418334Speterint 5685132718Skanint_fits_type_p (tree c, tree type) 568618334Speter{ 5687132718Skan tree type_low_bound = TYPE_MIN_VALUE (type); 5688132718Skan tree type_high_bound = TYPE_MAX_VALUE (type); 5689169689Skan bool ok_for_low_bound, ok_for_high_bound; 5690169689Skan tree tmp; 5691132718Skan 5692132718Skan /* If at least one bound of the type is a constant integer, we can check 5693132718Skan ourselves and maybe make a decision. If no such decision is possible, but 5694132718Skan this type is a subtype, try checking against that. Otherwise, use 5695132718Skan force_fit_type, which checks against the precision. 5696132718Skan 5697132718Skan Compute the status for each possibly constant bound, and return if we see 5698132718Skan one does not match. Use ok_for_xxx_bound for this purpose, assigning -1 5699132718Skan for "unknown if constant fits", 0 for "constant known *not* to fit" and 1 5700132718Skan for "constant known to fit". */ 5701132718Skan 5702132718Skan /* Check if C >= type_low_bound. */ 5703132718Skan if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST) 570490075Sobrien { 5705169689Skan if (tree_int_cst_lt (c, type_low_bound)) 5706132718Skan return 0; 5707169689Skan ok_for_low_bound = true; 570890075Sobrien } 5709169689Skan else 5710169689Skan ok_for_low_bound = false; 5711132718Skan 5712132718Skan /* Check if c <= type_high_bound. */ 5713132718Skan if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST) 5714132718Skan { 5715169689Skan if (tree_int_cst_lt (type_high_bound, c)) 5716132718Skan return 0; 5717169689Skan ok_for_high_bound = true; 5718132718Skan } 5719169689Skan else 5720169689Skan ok_for_high_bound = false; 5721132718Skan 5722132718Skan /* If the constant fits both bounds, the result is known. */ 5723169689Skan if (ok_for_low_bound && ok_for_high_bound) 5724132718Skan return 1; 5725132718Skan 5726169689Skan /* Perform some generic filtering which may allow making a decision 5727169689Skan even if the bounds are not constant. First, negative integers 5728169689Skan never fit in unsigned types, */ 5729169689Skan if (TYPE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0) 5730169689Skan return 0; 5731169689Skan 5732169689Skan /* Second, narrower types always fit in wider ones. */ 5733169689Skan if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c))) 5734169689Skan return 1; 5735169689Skan 5736169689Skan /* Third, unsigned integers with top bit set never fit signed types. */ 5737169689Skan if (! TYPE_UNSIGNED (type) 5738169689Skan && TYPE_UNSIGNED (TREE_TYPE (c)) 5739169689Skan && tree_int_cst_msb (c)) 5740169689Skan return 0; 5741169689Skan 5742132718Skan /* If we haven't been able to decide at this point, there nothing more we 5743169689Skan can check ourselves here. Look at the base type if we have one and it 5744169689Skan has the same precision. */ 5745169689Skan if (TREE_CODE (type) == INTEGER_TYPE 5746169689Skan && TREE_TYPE (type) != 0 5747169689Skan && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type))) 574890075Sobrien return int_fits_type_p (c, TREE_TYPE (type)); 5749132718Skan 5750132718Skan /* Or to force_fit_type, if nothing else. */ 5751169689Skan tmp = copy_node (c); 5752169689Skan TREE_TYPE (tmp) = type; 5753169689Skan tmp = force_fit_type (tmp, -1, false, false); 5754169689Skan return TREE_INT_CST_HIGH (tmp) == TREE_INT_CST_HIGH (c) 5755169689Skan && TREE_INT_CST_LOW (tmp) == TREE_INT_CST_LOW (c); 575618334Speter} 575718334Speter 5758169689Skan/* Subprogram of following function. Called by walk_tree. 5759169689Skan 5760169689Skan Return *TP if it is an automatic variable or parameter of the 5761169689Skan function passed in as DATA. */ 5762169689Skan 5763169689Skanstatic tree 5764169689Skanfind_var_from_fn (tree *tp, int *walk_subtrees, void *data) 5765169689Skan{ 5766169689Skan tree fn = (tree) data; 5767169689Skan 5768169689Skan if (TYPE_P (*tp)) 5769169689Skan *walk_subtrees = 0; 5770169689Skan 5771169689Skan else if (DECL_P (*tp) 5772169689Skan && lang_hooks.tree_inlining.auto_var_in_fn_p (*tp, fn)) 5773169689Skan return *tp; 5774169689Skan 5775169689Skan return NULL_TREE; 5776169689Skan} 5777169689Skan 5778107590Sobrien/* Returns true if T is, contains, or refers to a type with variable 5779169689Skan size. For METHOD_TYPEs and FUNCTION_TYPEs we exclude the 5780169689Skan arguments, but not the return type. If FN is nonzero, only return 5781169689Skan true if a modifier of the type or position of FN is a variable or 5782169689Skan parameter inside FN. 5783132718Skan 5784169689Skan This concept is more general than that of C99 'variably modified types': 5785169689Skan in C99, a struct type is never variably modified because a VLA may not 5786169689Skan appear as a structure member. However, in GNU C code like: 5787169689Skan 5788107590Sobrien struct S { int i[f()]; }; 5789107590Sobrien 5790107590Sobrien is valid, and other languages may define similar constructs. */ 5791107590Sobrien 5792107590Sobrienbool 5793169689Skanvariably_modified_type_p (tree type, tree fn) 5794107590Sobrien{ 5795132718Skan tree t; 5796132718Skan 5797169689Skan/* Test if T is either variable (if FN is zero) or an expression containing 5798169689Skan a variable in FN. */ 5799169689Skan#define RETURN_TRUE_IF_VAR(T) \ 5800169689Skan do { tree _t = (T); \ 5801169689Skan if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST \ 5802169689Skan && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL))) \ 5803169689Skan return true; } while (0) 5804169689Skan 5805117395Skan if (type == error_mark_node) 5806117395Skan return false; 5807117395Skan 5808169689Skan /* If TYPE itself has variable size, it is variably modified. */ 5809169689Skan RETURN_TRUE_IF_VAR (TYPE_SIZE (type)); 5810169689Skan RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type)); 5811107590Sobrien 5812132718Skan switch (TREE_CODE (type)) 5813107590Sobrien { 5814132718Skan case POINTER_TYPE: 5815132718Skan case REFERENCE_TYPE: 5816169689Skan case VECTOR_TYPE: 5817169689Skan if (variably_modified_type_p (TREE_TYPE (type), fn)) 5818169689Skan return true; 5819169689Skan break; 5820107590Sobrien 5821132718Skan case FUNCTION_TYPE: 5822132718Skan case METHOD_TYPE: 5823169689Skan /* If TYPE is a function type, it is variably modified if the 5824169689Skan return type is variably modified. */ 5825169689Skan if (variably_modified_type_p (TREE_TYPE (type), fn)) 5826132718Skan return true; 5827132718Skan break; 5828132718Skan 5829132718Skan case INTEGER_TYPE: 5830169689Skan case REAL_TYPE: 5831169689Skan case ENUMERAL_TYPE: 5832169689Skan case BOOLEAN_TYPE: 5833132718Skan /* Scalar types are variably modified if their end points 5834132718Skan aren't constant. */ 5835169689Skan RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type)); 5836169689Skan RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type)); 5837169689Skan break; 5838132718Skan 5839169689Skan case RECORD_TYPE: 5840169689Skan case UNION_TYPE: 5841169689Skan case QUAL_UNION_TYPE: 5842169689Skan /* We can't see if any of the fields are variably-modified by the 5843169689Skan definition we normally use, since that would produce infinite 5844169689Skan recursion via pointers. */ 5845169689Skan /* This is variably modified if some field's type is. */ 5846169689Skan for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t)) 5847169689Skan if (TREE_CODE (t) == FIELD_DECL) 5848169689Skan { 5849169689Skan RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t)); 5850169689Skan RETURN_TRUE_IF_VAR (DECL_SIZE (t)); 5851169689Skan RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t)); 5852169689Skan 5853169689Skan if (TREE_CODE (type) == QUAL_UNION_TYPE) 5854169689Skan RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t)); 5855169689Skan } 5856169689Skan break; 5857169689Skan 5858169689Skan case ARRAY_TYPE: 5859169689Skan /* Do not call ourselves to avoid infinite recursion. This is 5860169689Skan variably modified if the element type is. */ 5861169689Skan RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type))); 5862169689Skan RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type))); 5863169689Skan break; 5864169689Skan 5865132718Skan default: 5866132718Skan break; 5867107590Sobrien } 5868107590Sobrien 5869107590Sobrien /* The current language may have other cases to check, but in general, 5870107590Sobrien all other types are not variably modified. */ 5871169689Skan return lang_hooks.tree_inlining.var_mod_type_p (type, fn); 5872169689Skan 5873169689Skan#undef RETURN_TRUE_IF_VAR 5874107590Sobrien} 5875107590Sobrien 587690075Sobrien/* Given a DECL or TYPE, return the scope in which it was declared, or 587790075Sobrien NULL_TREE if there is no containing scope. */ 587890075Sobrien 587990075Sobrientree 5880132718Skanget_containing_scope (tree t) 588190075Sobrien{ 588290075Sobrien return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t)); 588390075Sobrien} 588490075Sobrien 588518334Speter/* Return the innermost context enclosing DECL that is 588618334Speter a FUNCTION_DECL, or zero if none. */ 588718334Speter 588818334Spetertree 5889132718Skandecl_function_context (tree decl) 589018334Speter{ 589118334Speter tree context; 589218334Speter 589318334Speter if (TREE_CODE (decl) == ERROR_MARK) 589418334Speter return 0; 589518334Speter 589690075Sobrien /* C++ virtual functions use DECL_CONTEXT for the class of the vtable 589790075Sobrien where we look up the function at runtime. Such functions always take 589890075Sobrien a first argument of type 'pointer to real context'. 589990075Sobrien 590090075Sobrien C++ should really be fixed to use DECL_CONTEXT for the real context, 590190075Sobrien and use something else for the "virtual context". */ 590290075Sobrien else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl)) 590390075Sobrien context 590490075Sobrien = TYPE_MAIN_VARIANT 590590075Sobrien (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))))); 590618334Speter else 590718334Speter context = DECL_CONTEXT (decl); 590818334Speter 590918334Speter while (context && TREE_CODE (context) != FUNCTION_DECL) 591018334Speter { 591190075Sobrien if (TREE_CODE (context) == BLOCK) 591218334Speter context = BLOCK_SUPERCONTEXT (context); 591318334Speter else 591490075Sobrien context = get_containing_scope (context); 591518334Speter } 591618334Speter 591718334Speter return context; 591818334Speter} 591918334Speter 592018334Speter/* Return the innermost context enclosing DECL that is 592118334Speter a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none. 592218334Speter TYPE_DECLs and FUNCTION_DECLs are transparent to this function. */ 592318334Speter 592418334Spetertree 5925132718Skandecl_type_context (tree decl) 592618334Speter{ 592718334Speter tree context = DECL_CONTEXT (decl); 592818334Speter 592918334Speter while (context) 5930132718Skan switch (TREE_CODE (context)) 5931132718Skan { 5932132718Skan case NAMESPACE_DECL: 5933132718Skan case TRANSLATION_UNIT_DECL: 5934117395Skan return NULL_TREE; 5935117395Skan 5936132718Skan case RECORD_TYPE: 5937132718Skan case UNION_TYPE: 5938132718Skan case QUAL_UNION_TYPE: 593918334Speter return context; 5940169689Skan 5941132718Skan case TYPE_DECL: 5942132718Skan case FUNCTION_DECL: 594318334Speter context = DECL_CONTEXT (context); 5944132718Skan break; 5945169689Skan 5946132718Skan case BLOCK: 594718334Speter context = BLOCK_SUPERCONTEXT (context); 5948132718Skan break; 5949169689Skan 5950132718Skan default: 5951169689Skan gcc_unreachable (); 5952132718Skan } 595390075Sobrien 595418334Speter return NULL_TREE; 595518334Speter} 595618334Speter 595790075Sobrien/* CALL is a CALL_EXPR. Return the declaration for the function 595890075Sobrien called, or NULL_TREE if the called function cannot be 595990075Sobrien determined. */ 596050397Sobrien 596190075Sobrientree 5962132718Skanget_callee_fndecl (tree call) 596350397Sobrien{ 596490075Sobrien tree addr; 596550397Sobrien 5966169689Skan if (call == error_mark_node) 5967169689Skan return call; 5968169689Skan 596990075Sobrien /* It's invalid to call this function with anything but a 597090075Sobrien CALL_EXPR. */ 5971169689Skan gcc_assert (TREE_CODE (call) == CALL_EXPR); 597250397Sobrien 597390075Sobrien /* The first operand to the CALL is the address of the function 597490075Sobrien called. */ 597590075Sobrien addr = TREE_OPERAND (call, 0); 597690075Sobrien 597790075Sobrien STRIP_NOPS (addr); 597890075Sobrien 597990075Sobrien /* If this is a readonly function pointer, extract its initial value. */ 598090075Sobrien if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL 598190075Sobrien && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr) 598290075Sobrien && DECL_INITIAL (addr)) 598390075Sobrien addr = DECL_INITIAL (addr); 598490075Sobrien 598590075Sobrien /* If the address is just `&f' for some function `f', then we know 598690075Sobrien that `f' is being called. */ 598790075Sobrien if (TREE_CODE (addr) == ADDR_EXPR 598890075Sobrien && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL) 598990075Sobrien return TREE_OPERAND (addr, 0); 5990169689Skan 5991132718Skan /* We couldn't figure out what was being called. Maybe the front 5992132718Skan end has some idea. */ 5993169689Skan return lang_hooks.lang_get_callee_fndecl (call); 599450397Sobrien} 599550397Sobrien 599650397Sobrien/* Print debugging information about tree nodes generated during the compile, 599750397Sobrien and any language-specific information. */ 599850397Sobrien 599918334Spetervoid 6000132718Skandump_tree_statistics (void) 600118334Speter{ 600250397Sobrien#ifdef GATHER_STATISTICS 600318334Speter int i; 600418334Speter int total_nodes, total_bytes; 600550397Sobrien#endif 600618334Speter 600718334Speter fprintf (stderr, "\n??? tree nodes created\n\n"); 600818334Speter#ifdef GATHER_STATISTICS 6009132718Skan fprintf (stderr, "Kind Nodes Bytes\n"); 6010132718Skan fprintf (stderr, "---------------------------------------\n"); 601118334Speter total_nodes = total_bytes = 0; 601218334Speter for (i = 0; i < (int) all_kinds; i++) 601318334Speter { 6014132718Skan fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i], 601518334Speter tree_node_counts[i], tree_node_sizes[i]); 601618334Speter total_nodes += tree_node_counts[i]; 601718334Speter total_bytes += tree_node_sizes[i]; 601818334Speter } 6019132718Skan fprintf (stderr, "---------------------------------------\n"); 6020132718Skan fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes); 6021132718Skan fprintf (stderr, "---------------------------------------\n"); 6022169689Skan ssanames_print_statistics (); 6023169689Skan phinodes_print_statistics (); 602418334Speter#else 602518334Speter fprintf (stderr, "(No per-node statistics)\n"); 602618334Speter#endif 602790075Sobrien print_type_hash_statistics (); 6028169689Skan print_debug_expr_statistics (); 6029169689Skan print_value_expr_statistics (); 6030169689Skan print_restrict_base_statistics (); 6031169689Skan lang_hooks.print_statistics (); 603218334Speter} 603318334Speter 603450397Sobrien#define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s" 603518334Speter 6036132718Skan/* Generate a crc32 of a string. */ 6037117395Skan 6038132718Skanunsigned 6039132718Skancrc32_string (unsigned chksum, const char *string) 6040117395Skan{ 6041132718Skan do 6042132718Skan { 6043132718Skan unsigned value = *string << 24; 6044132718Skan unsigned ix; 6045169689Skan 6046132718Skan for (ix = 8; ix--; value <<= 1) 6047132718Skan { 6048132718Skan unsigned feedback; 6049169689Skan 6050132718Skan feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0; 6051132718Skan chksum <<= 1; 6052132718Skan chksum ^= feedback; 6053132718Skan } 6054132718Skan } 6055132718Skan while (*string++); 6056132718Skan return chksum; 6057117395Skan} 6058117395Skan 605990075Sobrien/* P is a string that will be used in a symbol. Mask out any characters 606090075Sobrien that are not valid in that context. */ 606190075Sobrien 606290075Sobrienvoid 6063132718Skanclean_symbol_name (char *p) 606490075Sobrien{ 606590075Sobrien for (; *p; p++) 606690075Sobrien if (! (ISALNUM (*p) 606790075Sobrien#ifndef NO_DOLLAR_IN_LABEL /* this for `$'; unlikely, but... -- kr */ 606890075Sobrien || *p == '$' 606990075Sobrien#endif 607090075Sobrien#ifndef NO_DOT_IN_LABEL /* this for `.'; unlikely, but... */ 607190075Sobrien || *p == '.' 607290075Sobrien#endif 607390075Sobrien )) 607490075Sobrien *p = '_'; 607590075Sobrien} 6076117395Skan 6077259563Spfg/* Generate a name for a special-purpose function function. 6078259563Spfg The generated name may need to be unique across the whole link. 607950397Sobrien TYPE is some string to identify the purpose of this function to the 6080259563Spfg linker or collect2; it must start with an uppercase letter, 6081259563Spfg one of: 6082259563Spfg I - for constructors 6083259563Spfg D - for destructors 6084259563Spfg N - for C++ anonymous namespaces 6085259563Spfg F - for DWARF unwind frame information. */ 608650397Sobrien 608718334Spetertree 6088259563Spfgget_file_function_name (const char *type) 608918334Speter{ 609018334Speter char *buf; 609190075Sobrien const char *p; 609290075Sobrien char *q; 609318334Speter 6094259563Spfg /* If we already have a name we know to be unique, just use that. */ 609518334Speter if (first_global_object_name) 6096259563Spfg p = first_global_object_name; 6097259563Spfg /* If the target is handling the constructors/destructors, they 6098259563Spfg will be local to this file and the name is only necessary for 6099259563Spfg debugging purposes. */ 6100259563Spfg else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors) 6101169689Skan { 6102259563Spfg const char *file = main_input_filename; 6103259563Spfg if (! file) 6104259563Spfg file = input_filename; 6105259563Spfg /* Just use the file's basename, because the full pathname 6106259563Spfg might be quite long. */ 6107259563Spfg p = strrchr (file, '/'); 6108259563Spfg if (p) 6109259563Spfg p++; 6110259563Spfg else 6111259563Spfg p = file; 6112259563Spfg p = q = ASTRDUP (p); 6113259563Spfg clean_symbol_name (q); 6114169689Skan } 611518334Speter else 611650397Sobrien { 6117259563Spfg /* Otherwise, the name must be unique across the entire link. 6118259563Spfg We don't have anything that we know to be unique to this translation 611950397Sobrien unit, so use what we do have and throw in some randomness. */ 6120132718Skan unsigned len; 612152284Sobrien const char *name = weak_global_object_name; 612252284Sobrien const char *file = main_input_filename; 612318334Speter 612450397Sobrien if (! name) 612550397Sobrien name = ""; 612650397Sobrien if (! file) 612750397Sobrien file = input_filename; 612850397Sobrien 6129132718Skan len = strlen (file); 6130132718Skan q = alloca (9 * 2 + len + 1); 6131132718Skan memcpy (q, file, len + 1); 6132132718Skan clean_symbol_name (q); 613350397Sobrien 6134132718Skan sprintf (q + len, "_%08X_%08X", crc32_string (0, name), 6135132718Skan crc32_string (0, flag_random_seed)); 6136132718Skan 613790075Sobrien p = q; 613850397Sobrien } 613950397Sobrien 6140132718Skan buf = alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p) + strlen (type)); 614150397Sobrien 614290075Sobrien /* Set up the name of the file-level functions we may need. 614390075Sobrien Use a global object (which is already required to be unique over 614418334Speter the program) rather than the file name (which imposes extra 614590075Sobrien constraints). */ 614650397Sobrien sprintf (buf, FILE_FUNCTION_FORMAT, type, p); 614718334Speter 614818334Speter return get_identifier (buf); 614918334Speter} 615018334Speter 6151169689Skan#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007) 615218334Speter 6153169689Skan/* Complain that the tree code of NODE does not match the expected 0 6154169689Skan terminated list of trailing codes. The trailing code list can be 6155169689Skan empty, for a more vague error message. FILE, LINE, and FUNCTION 6156169689Skan are of the caller. */ 615718334Speter 6158169689Skanvoid 6159169689Skantree_check_failed (const tree node, const char *file, 6160169689Skan int line, const char *function, ...) 616118334Speter{ 6162169689Skan va_list args; 6163169689Skan char *buffer; 6164169689Skan unsigned length = 0; 6165169689Skan int code; 616690075Sobrien 6167169689Skan va_start (args, function); 6168169689Skan while ((code = va_arg (args, int))) 6169169689Skan length += 4 + strlen (tree_code_name[code]); 6170169689Skan va_end (args); 6171169689Skan if (length) 617218334Speter { 6173169689Skan va_start (args, function); 6174169689Skan length += strlen ("expected "); 6175169689Skan buffer = alloca (length); 6176169689Skan length = 0; 6177169689Skan while ((code = va_arg (args, int))) 617818334Speter { 6179169689Skan const char *prefix = length ? " or " : "expected "; 6180169689Skan 6181169689Skan strcpy (buffer + length, prefix); 6182169689Skan length += strlen (prefix); 6183169689Skan strcpy (buffer + length, tree_code_name[code]); 6184169689Skan length += strlen (tree_code_name[code]); 6185169689Skan } 6186169689Skan va_end (args); 6187169689Skan } 6188169689Skan else 6189169689Skan buffer = (char *)"unexpected node"; 619090075Sobrien 6191169689Skan internal_error ("tree check: %s, have %s in %s, at %s:%d", 6192169689Skan buffer, tree_code_name[TREE_CODE (node)], 6193169689Skan function, trim_filename (file), line); 6194169689Skan} 6195169689Skan 6196169689Skan/* Complain that the tree code of NODE does match the expected 0 6197169689Skan terminated list of trailing codes. FILE, LINE, and FUNCTION are of 6198169689Skan the caller. */ 6199169689Skan 6200169689Skanvoid 6201169689Skantree_not_check_failed (const tree node, const char *file, 6202169689Skan int line, const char *function, ...) 6203169689Skan{ 6204169689Skan va_list args; 6205169689Skan char *buffer; 6206169689Skan unsigned length = 0; 6207169689Skan int code; 6208169689Skan 6209169689Skan va_start (args, function); 6210169689Skan while ((code = va_arg (args, int))) 6211169689Skan length += 4 + strlen (tree_code_name[code]); 6212169689Skan va_end (args); 6213169689Skan va_start (args, function); 6214169689Skan buffer = alloca (length); 6215169689Skan length = 0; 6216169689Skan while ((code = va_arg (args, int))) 6217169689Skan { 6218169689Skan if (length) 621918334Speter { 6220169689Skan strcpy (buffer + length, " or "); 6221169689Skan length += 4; 622218334Speter } 6223169689Skan strcpy (buffer + length, tree_code_name[code]); 6224169689Skan length += strlen (tree_code_name[code]); 622518334Speter } 6226169689Skan va_end (args); 6227169689Skan 6228169689Skan internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d", 6229169689Skan buffer, tree_code_name[TREE_CODE (node)], 6230169689Skan function, trim_filename (file), line); 623118334Speter} 623218334Speter 6233169689Skan/* Similar to tree_check_failed, except that we check for a class of tree 6234169689Skan code, given in CL. */ 623518334Speter 6236169689Skanvoid 6237169689Skantree_class_check_failed (const tree node, const enum tree_code_class cl, 6238169689Skan const char *file, int line, const char *function) 623918334Speter{ 6240169689Skan internal_error 6241169689Skan ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d", 6242169689Skan TREE_CODE_CLASS_STRING (cl), 6243169689Skan TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))), 6244169689Skan tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); 6245169689Skan} 624618334Speter 6247169689Skan/* Similar to tree_check_failed, except that instead of specifying a 6248169689Skan dozen codes, use the knowledge that they're all sequential. */ 624918334Speter 6250169689Skanvoid 6251169689Skantree_range_check_failed (const tree node, const char *file, int line, 6252169689Skan const char *function, enum tree_code c1, 6253169689Skan enum tree_code c2) 6254169689Skan{ 6255169689Skan char *buffer; 6256169689Skan unsigned length = 0; 6257169689Skan enum tree_code c; 6258169689Skan 6259169689Skan for (c = c1; c <= c2; ++c) 6260169689Skan length += 4 + strlen (tree_code_name[c]); 6261169689Skan 6262169689Skan length += strlen ("expected "); 6263169689Skan buffer = alloca (length); 6264169689Skan length = 0; 6265169689Skan 6266169689Skan for (c = c1; c <= c2; ++c) 626718334Speter { 6268169689Skan const char *prefix = length ? " or " : "expected "; 6269169689Skan 6270169689Skan strcpy (buffer + length, prefix); 6271169689Skan length += strlen (prefix); 6272169689Skan strcpy (buffer + length, tree_code_name[c]); 6273169689Skan length += strlen (tree_code_name[c]); 627418334Speter } 6275169689Skan 6276169689Skan internal_error ("tree check: %s, have %s in %s, at %s:%d", 6277169689Skan buffer, tree_code_name[TREE_CODE (node)], 6278169689Skan function, trim_filename (file), line); 627918334Speter} 628050397Sobrien 6281169689Skan 6282169689Skan/* Similar to tree_check_failed, except that we check that a tree does 6283169689Skan not have the specified code, given in CL. */ 6284169689Skan 628590075Sobrienvoid 6286169689Skantree_not_class_check_failed (const tree node, const enum tree_code_class cl, 6287169689Skan const char *file, int line, const char *function) 628850397Sobrien{ 6289169689Skan internal_error 6290169689Skan ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d", 6291169689Skan TREE_CODE_CLASS_STRING (cl), 6292169689Skan TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))), 6293169689Skan tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); 6294169689Skan} 6295169689Skan 6296169689Skan 6297169689Skan/* Similar to tree_check_failed but applied to OMP_CLAUSE codes. */ 6298169689Skan 6299169689Skanvoid 6300169689Skanomp_clause_check_failed (const tree node, const char *file, int line, 6301169689Skan const char *function, enum omp_clause_code code) 6302169689Skan{ 6303169689Skan internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d", 6304169689Skan omp_clause_code_name[code], tree_code_name[TREE_CODE (node)], 630590075Sobrien function, trim_filename (file), line); 630650397Sobrien} 630750397Sobrien 630850397Sobrien 6309169689Skan/* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes. */ 6310169689Skan 631190075Sobrienvoid 6312169689Skanomp_clause_range_check_failed (const tree node, const char *file, int line, 6313169689Skan const char *function, enum omp_clause_code c1, 6314169689Skan enum omp_clause_code c2) 631550397Sobrien{ 6316169689Skan char *buffer; 6317169689Skan unsigned length = 0; 6318169689Skan enum omp_clause_code c; 6319169689Skan 6320169689Skan for (c = c1; c <= c2; ++c) 6321169689Skan length += 4 + strlen (omp_clause_code_name[c]); 6322169689Skan 6323169689Skan length += strlen ("expected "); 6324169689Skan buffer = alloca (length); 6325169689Skan length = 0; 6326169689Skan 6327169689Skan for (c = c1; c <= c2; ++c) 6328169689Skan { 6329169689Skan const char *prefix = length ? " or " : "expected "; 6330169689Skan 6331169689Skan strcpy (buffer + length, prefix); 6332169689Skan length += strlen (prefix); 6333169689Skan strcpy (buffer + length, omp_clause_code_name[c]); 6334169689Skan length += strlen (omp_clause_code_name[c]); 6335169689Skan } 6336169689Skan 6337169689Skan internal_error ("tree check: %s, have %s in %s, at %s:%d", 6338169689Skan buffer, omp_clause_code_name[TREE_CODE (node)], 6339169689Skan function, trim_filename (file), line); 6340169689Skan} 6341169689Skan 6342169689Skan 6343169689Skan#undef DEFTREESTRUCT 6344169689Skan#define DEFTREESTRUCT(VAL, NAME) NAME, 6345169689Skan 6346169689Skanstatic const char *ts_enum_names[] = { 6347169689Skan#include "treestruct.def" 6348169689Skan}; 6349169689Skan#undef DEFTREESTRUCT 6350169689Skan 6351169689Skan#define TS_ENUM_NAME(EN) (ts_enum_names[(EN)]) 6352169689Skan 6353169689Skan/* Similar to tree_class_check_failed, except that we check for 6354169689Skan whether CODE contains the tree structure identified by EN. */ 6355169689Skan 6356169689Skanvoid 6357169689Skantree_contains_struct_check_failed (const tree node, 6358169689Skan const enum tree_node_structure_enum en, 6359169689Skan const char *file, int line, 6360169689Skan const char *function) 6361169689Skan{ 636290075Sobrien internal_error 6363169689Skan ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d", 6364169689Skan TS_ENUM_NAME(en), 636590075Sobrien tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); 636650397Sobrien} 636750397Sobrien 6368169689Skan 6369117395Skan/* Similar to above, except that the check is for the bounds of a TREE_VEC's 6370117395Skan (dynamically sized) vector. */ 6371117395Skan 6372117395Skanvoid 6373132718Skantree_vec_elt_check_failed (int idx, int len, const char *file, int line, 6374132718Skan const char *function) 6375117395Skan{ 6376117395Skan internal_error 6377117395Skan ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d", 6378117395Skan idx + 1, len, function, trim_filename (file), line); 6379117395Skan} 6380117395Skan 6381169689Skan/* Similar to above, except that the check is for the bounds of a PHI_NODE's 6382169689Skan (dynamically sized) vector. */ 6383169689Skan 6384169689Skanvoid 6385169689Skanphi_node_elt_check_failed (int idx, int len, const char *file, int line, 6386169689Skan const char *function) 6387169689Skan{ 6388169689Skan internal_error 6389169689Skan ("tree check: accessed elt %d of phi_node with %d elts in %s, at %s:%d", 6390169689Skan idx + 1, len, function, trim_filename (file), line); 6391169689Skan} 6392169689Skan 6393132718Skan/* Similar to above, except that the check is for the bounds of the operand 6394132718Skan vector of an expression node. */ 6395132718Skan 6396132718Skanvoid 6397132718Skantree_operand_check_failed (int idx, enum tree_code code, const char *file, 6398132718Skan int line, const char *function) 6399132718Skan{ 6400132718Skan internal_error 6401132718Skan ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d", 6402132718Skan idx + 1, tree_code_name[code], TREE_CODE_LENGTH (code), 6403132718Skan function, trim_filename (file), line); 6404132718Skan} 6405169689Skan 6406169689Skan/* Similar to above, except that the check is for the number of 6407169689Skan operands of an OMP_CLAUSE node. */ 6408169689Skan 6409169689Skanvoid 6410169689Skanomp_clause_operand_check_failed (int idx, tree t, const char *file, 6411169689Skan int line, const char *function) 6412169689Skan{ 6413169689Skan internal_error 6414169689Skan ("tree check: accessed operand %d of omp_clause %s with %d operands " 6415169689Skan "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)], 6416169689Skan omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function, 6417169689Skan trim_filename (file), line); 6418169689Skan} 641990075Sobrien#endif /* ENABLE_TREE_CHECKING */ 642090075Sobrien 6421169689Skan/* Create a new vector type node holding SUBPARTS units of type INNERTYPE, 6422169689Skan and mapped to the machine mode MODE. Initialize its fields and build 6423169689Skan the information necessary for debugging output. */ 642450397Sobrien 6425169689Skanstatic tree 6426169689Skanmake_vector_type (tree innertype, int nunits, enum machine_mode mode) 642750397Sobrien{ 6428169689Skan tree t; 6429169689Skan hashval_t hashcode = 0; 6430169689Skan 6431169689Skan /* Build a main variant, based on the main variant of the inner type, then 6432169689Skan use it to build the variant we return. */ 6433169689Skan if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype)) 6434169689Skan && TYPE_MAIN_VARIANT (innertype) != innertype) 6435169689Skan return build_type_attribute_qual_variant ( 6436169689Skan make_vector_type (TYPE_MAIN_VARIANT (innertype), nunits, mode), 6437169689Skan TYPE_ATTRIBUTES (innertype), 6438169689Skan TYPE_QUALS (innertype)); 6439169689Skan 6440169689Skan t = make_node (VECTOR_TYPE); 6441169689Skan TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype); 6442169689Skan SET_TYPE_VECTOR_SUBPARTS (t, nunits); 6443169689Skan TYPE_MODE (t) = mode; 6444169689Skan TYPE_READONLY (t) = TYPE_READONLY (innertype); 6445169689Skan TYPE_VOLATILE (t) = TYPE_VOLATILE (innertype); 6446169689Skan 644790075Sobrien layout_type (t); 644850397Sobrien 644990075Sobrien { 6450169689Skan tree index = build_int_cst (NULL_TREE, nunits - 1); 6451169689Skan tree array = build_array_type (innertype, build_index_type (index)); 645290075Sobrien tree rt = make_node (RECORD_TYPE); 645350397Sobrien 645490075Sobrien TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array); 645590075Sobrien DECL_CONTEXT (TYPE_FIELDS (rt)) = rt; 645690075Sobrien layout_type (rt); 645790075Sobrien TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt; 645890075Sobrien /* In dwarfout.c, type lookup uses TYPE_UID numbers. We want to output 645990075Sobrien the representation type, and we want to find that die when looking up 646090075Sobrien the vector type. This is most easily achieved by making the TYPE_UID 646190075Sobrien numbers equal. */ 646290075Sobrien TYPE_UID (rt) = TYPE_UID (t); 646390075Sobrien } 6464169689Skan 6465169689Skan hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode); 6466169689Skan hashcode = iterative_hash_host_wide_int (mode, hashcode); 6467169689Skan hashcode = iterative_hash_object (TYPE_HASH (innertype), hashcode); 6468169689Skan return type_hash_canon (hashcode, t); 646950397Sobrien} 647050397Sobrien 6471161651Skanstatic tree 6472161651Skanmake_or_reuse_type (unsigned size, int unsignedp) 6473161651Skan{ 6474161651Skan if (size == INT_TYPE_SIZE) 6475161651Skan return unsignedp ? unsigned_type_node : integer_type_node; 6476161651Skan if (size == CHAR_TYPE_SIZE) 6477161651Skan return unsignedp ? unsigned_char_type_node : signed_char_type_node; 6478161651Skan if (size == SHORT_TYPE_SIZE) 6479161651Skan return unsignedp ? short_unsigned_type_node : short_integer_type_node; 6480161651Skan if (size == LONG_TYPE_SIZE) 6481161651Skan return unsignedp ? long_unsigned_type_node : long_integer_type_node; 6482161651Skan if (size == LONG_LONG_TYPE_SIZE) 6483161651Skan return (unsignedp ? long_long_unsigned_type_node 6484161651Skan : long_long_integer_type_node); 6485161651Skan 6486161651Skan if (unsignedp) 6487161651Skan return make_unsigned_type (size); 6488161651Skan else 6489161651Skan return make_signed_type (size); 6490161651Skan} 6491161651Skan 649290075Sobrien/* Create nodes for all integer types (and error_mark_node) using the sizes 649390075Sobrien of C datatypes. The caller should call set_sizetype soon after calling 649490075Sobrien this function to select one of the types as sizetype. */ 649550397Sobrien 649690075Sobrienvoid 6497169689Skanbuild_common_tree_nodes (bool signed_char, bool signed_sizetype) 649850397Sobrien{ 649990075Sobrien error_mark_node = make_node (ERROR_MARK); 650090075Sobrien TREE_TYPE (error_mark_node) = error_mark_node; 650190075Sobrien 6502169689Skan initialize_sizetypes (signed_sizetype); 650390075Sobrien 650490075Sobrien /* Define both `signed char' and `unsigned char'. */ 650590075Sobrien signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE); 6506169689Skan TYPE_STRING_FLAG (signed_char_type_node) = 1; 650790075Sobrien unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE); 6508169689Skan TYPE_STRING_FLAG (unsigned_char_type_node) = 1; 650990075Sobrien 651090075Sobrien /* Define `char', which is like either `signed char' or `unsigned char' 651190075Sobrien but not the same as either. */ 651290075Sobrien char_type_node 651390075Sobrien = (signed_char 651490075Sobrien ? make_signed_type (CHAR_TYPE_SIZE) 651590075Sobrien : make_unsigned_type (CHAR_TYPE_SIZE)); 6516169689Skan TYPE_STRING_FLAG (char_type_node) = 1; 651790075Sobrien 651890075Sobrien short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE); 651990075Sobrien short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE); 652090075Sobrien integer_type_node = make_signed_type (INT_TYPE_SIZE); 652190075Sobrien unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE); 652290075Sobrien long_integer_type_node = make_signed_type (LONG_TYPE_SIZE); 652390075Sobrien long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE); 652490075Sobrien long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE); 652590075Sobrien long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE); 652690075Sobrien 6527132718Skan /* Define a boolean type. This type only represents boolean values but 6528132718Skan may be larger than char depending on the value of BOOL_TYPE_SIZE. 6529132718Skan Front ends which want to override this size (i.e. Java) can redefine 6530132718Skan boolean_type_node before calling build_common_tree_nodes_2. */ 6531132718Skan boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE); 6532132718Skan TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE); 6533169689Skan TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1); 6534132718Skan TYPE_PRECISION (boolean_type_node) = 1; 6535132718Skan 6536161651Skan /* Fill in the rest of the sized types. Reuse existing type nodes 6537161651Skan when possible. */ 6538161651Skan intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0); 6539161651Skan intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0); 6540161651Skan intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0); 6541161651Skan intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0); 6542161651Skan intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0); 654390075Sobrien 6544161651Skan unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1); 6545161651Skan unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1); 6546161651Skan unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1); 6547161651Skan unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1); 6548161651Skan unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1); 6549169689Skan 6550132718Skan access_public_node = get_identifier ("public"); 6551132718Skan access_protected_node = get_identifier ("protected"); 6552132718Skan access_private_node = get_identifier ("private"); 655350397Sobrien} 655452284Sobrien 655590075Sobrien/* Call this function after calling build_common_tree_nodes and set_sizetype. 655690075Sobrien It will create several other common tree nodes. */ 655752284Sobrien 655890075Sobrienvoid 6559132718Skanbuild_common_tree_nodes_2 (int short_double) 656052284Sobrien{ 656190075Sobrien /* Define these next since types below may used them. */ 6562169689Skan integer_zero_node = build_int_cst (NULL_TREE, 0); 6563169689Skan integer_one_node = build_int_cst (NULL_TREE, 1); 6564169689Skan integer_minus_one_node = build_int_cst (NULL_TREE, -1); 656590075Sobrien 656690075Sobrien size_zero_node = size_int (0); 656790075Sobrien size_one_node = size_int (1); 656890075Sobrien bitsize_zero_node = bitsize_int (0); 656990075Sobrien bitsize_one_node = bitsize_int (1); 657090075Sobrien bitsize_unit_node = bitsize_int (BITS_PER_UNIT); 657190075Sobrien 6572132718Skan boolean_false_node = TYPE_MIN_VALUE (boolean_type_node); 6573132718Skan boolean_true_node = TYPE_MAX_VALUE (boolean_type_node); 6574132718Skan 657590075Sobrien void_type_node = make_node (VOID_TYPE); 657690075Sobrien layout_type (void_type_node); 657790075Sobrien 657890075Sobrien /* We are not going to have real types in C with less than byte alignment, 657990075Sobrien so we might as well not have any types that claim to have it. */ 658090075Sobrien TYPE_ALIGN (void_type_node) = BITS_PER_UNIT; 658190075Sobrien TYPE_USER_ALIGN (void_type_node) = 0; 658290075Sobrien 6583169689Skan null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0); 658490075Sobrien layout_type (TREE_TYPE (null_pointer_node)); 658590075Sobrien 658690075Sobrien ptr_type_node = build_pointer_type (void_type_node); 658790075Sobrien const_ptr_type_node 658890075Sobrien = build_pointer_type (build_type_variant (void_type_node, 1, 0)); 6589169689Skan fileptr_type_node = ptr_type_node; 659090075Sobrien 659190075Sobrien float_type_node = make_node (REAL_TYPE); 659290075Sobrien TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE; 659390075Sobrien layout_type (float_type_node); 659490075Sobrien 659590075Sobrien double_type_node = make_node (REAL_TYPE); 659690075Sobrien if (short_double) 659790075Sobrien TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE; 659852284Sobrien else 659990075Sobrien TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE; 660090075Sobrien layout_type (double_type_node); 660190075Sobrien 660290075Sobrien long_double_type_node = make_node (REAL_TYPE); 660390075Sobrien TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE; 660490075Sobrien layout_type (long_double_type_node); 660590075Sobrien 6606132718Skan float_ptr_type_node = build_pointer_type (float_type_node); 6607132718Skan double_ptr_type_node = build_pointer_type (double_type_node); 6608132718Skan long_double_ptr_type_node = build_pointer_type (long_double_type_node); 6609132718Skan integer_ptr_type_node = build_pointer_type (integer_type_node); 6610132718Skan 6611259563Spfg /* Fixed size integer types. */ 6612259563Spfg uint32_type_node = build_nonstandard_integer_type (32, true); 6613259563Spfg uint64_type_node = build_nonstandard_integer_type (64, true); 6614259563Spfg 6615169689Skan /* Decimal float types. */ 6616169689Skan dfloat32_type_node = make_node (REAL_TYPE); 6617169689Skan TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE; 6618169689Skan layout_type (dfloat32_type_node); 6619169689Skan TYPE_MODE (dfloat32_type_node) = SDmode; 6620169689Skan dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node); 6621169689Skan 6622169689Skan dfloat64_type_node = make_node (REAL_TYPE); 6623169689Skan TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE; 6624169689Skan layout_type (dfloat64_type_node); 6625169689Skan TYPE_MODE (dfloat64_type_node) = DDmode; 6626169689Skan dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node); 6627169689Skan 6628169689Skan dfloat128_type_node = make_node (REAL_TYPE); 6629169689Skan TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE; 6630169689Skan layout_type (dfloat128_type_node); 6631169689Skan TYPE_MODE (dfloat128_type_node) = TDmode; 6632169689Skan dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node); 6633169689Skan 663490075Sobrien complex_integer_type_node = make_node (COMPLEX_TYPE); 663590075Sobrien TREE_TYPE (complex_integer_type_node) = integer_type_node; 663690075Sobrien layout_type (complex_integer_type_node); 663790075Sobrien 663890075Sobrien complex_float_type_node = make_node (COMPLEX_TYPE); 663990075Sobrien TREE_TYPE (complex_float_type_node) = float_type_node; 664090075Sobrien layout_type (complex_float_type_node); 664190075Sobrien 664290075Sobrien complex_double_type_node = make_node (COMPLEX_TYPE); 664390075Sobrien TREE_TYPE (complex_double_type_node) = double_type_node; 664490075Sobrien layout_type (complex_double_type_node); 664590075Sobrien 664690075Sobrien complex_long_double_type_node = make_node (COMPLEX_TYPE); 664790075Sobrien TREE_TYPE (complex_long_double_type_node) = long_double_type_node; 664890075Sobrien layout_type (complex_long_double_type_node); 664990075Sobrien 665090075Sobrien { 6651169689Skan tree t = targetm.build_builtin_va_list (); 665290075Sobrien 6653132718Skan /* Many back-ends define record types without setting TYPE_NAME. 665490075Sobrien If we copied the record type here, we'd keep the original 665590075Sobrien record type without a name. This breaks name mangling. So, 665690075Sobrien don't copy record types and let c_common_nodes_and_builtins() 665790075Sobrien declare the type to be __builtin_va_list. */ 665890075Sobrien if (TREE_CODE (t) != RECORD_TYPE) 6659169689Skan t = build_variant_type_copy (t); 666090075Sobrien 666190075Sobrien va_list_type_node = t; 666290075Sobrien } 6663169689Skan} 666490075Sobrien 6665169689Skan/* A subroutine of build_common_builtin_nodes. Define a builtin function. */ 666690075Sobrien 6667169689Skanstatic void 6668169689Skanlocal_define_builtin (const char *name, tree type, enum built_in_function code, 6669169689Skan const char *library_name, int ecf_flags) 6670169689Skan{ 6671169689Skan tree decl; 6672169689Skan 6673169689Skan decl = lang_hooks.builtin_function (name, type, code, BUILT_IN_NORMAL, 6674169689Skan library_name, NULL_TREE); 6675169689Skan if (ecf_flags & ECF_CONST) 6676169689Skan TREE_READONLY (decl) = 1; 6677169689Skan if (ecf_flags & ECF_PURE) 6678169689Skan DECL_IS_PURE (decl) = 1; 6679169689Skan if (ecf_flags & ECF_NORETURN) 6680169689Skan TREE_THIS_VOLATILE (decl) = 1; 6681169689Skan if (ecf_flags & ECF_NOTHROW) 6682169689Skan TREE_NOTHROW (decl) = 1; 6683169689Skan if (ecf_flags & ECF_MALLOC) 6684169689Skan DECL_IS_MALLOC (decl) = 1; 6685169689Skan 6686169689Skan built_in_decls[code] = decl; 6687169689Skan implicit_built_in_decls[code] = decl; 668852284Sobrien} 668990075Sobrien 6690169689Skan/* Call this function after instantiating all builtins that the language 6691169689Skan front end cares about. This will build the rest of the builtins that 6692169689Skan are relied upon by the tree optimizers and the middle-end. */ 6693169689Skan 6694169689Skanvoid 6695169689Skanbuild_common_builtin_nodes (void) 6696169689Skan{ 6697169689Skan tree tmp, ftype; 6698169689Skan 6699169689Skan if (built_in_decls[BUILT_IN_MEMCPY] == NULL 6700169689Skan || built_in_decls[BUILT_IN_MEMMOVE] == NULL) 6701169689Skan { 6702169689Skan tmp = tree_cons (NULL_TREE, size_type_node, void_list_node); 6703169689Skan tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp); 6704169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); 6705169689Skan ftype = build_function_type (ptr_type_node, tmp); 6706169689Skan 6707169689Skan if (built_in_decls[BUILT_IN_MEMCPY] == NULL) 6708169689Skan local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY, 6709169689Skan "memcpy", ECF_NOTHROW); 6710169689Skan if (built_in_decls[BUILT_IN_MEMMOVE] == NULL) 6711169689Skan local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE, 6712169689Skan "memmove", ECF_NOTHROW); 6713169689Skan } 6714169689Skan 6715169689Skan if (built_in_decls[BUILT_IN_MEMCMP] == NULL) 6716169689Skan { 6717169689Skan tmp = tree_cons (NULL_TREE, size_type_node, void_list_node); 6718169689Skan tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp); 6719169689Skan tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp); 6720169689Skan ftype = build_function_type (integer_type_node, tmp); 6721169689Skan local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP, 6722169689Skan "memcmp", ECF_PURE | ECF_NOTHROW); 6723169689Skan } 6724169689Skan 6725169689Skan if (built_in_decls[BUILT_IN_MEMSET] == NULL) 6726169689Skan { 6727169689Skan tmp = tree_cons (NULL_TREE, size_type_node, void_list_node); 6728169689Skan tmp = tree_cons (NULL_TREE, integer_type_node, tmp); 6729169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); 6730169689Skan ftype = build_function_type (ptr_type_node, tmp); 6731169689Skan local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET, 6732169689Skan "memset", ECF_NOTHROW); 6733169689Skan } 6734169689Skan 6735169689Skan if (built_in_decls[BUILT_IN_ALLOCA] == NULL) 6736169689Skan { 6737169689Skan tmp = tree_cons (NULL_TREE, size_type_node, void_list_node); 6738169689Skan ftype = build_function_type (ptr_type_node, tmp); 6739169689Skan local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA, 6740169689Skan "alloca", ECF_NOTHROW | ECF_MALLOC); 6741169689Skan } 6742169689Skan 6743169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6744169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); 6745169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); 6746169689Skan ftype = build_function_type (void_type_node, tmp); 6747169689Skan local_define_builtin ("__builtin_init_trampoline", ftype, 6748169689Skan BUILT_IN_INIT_TRAMPOLINE, 6749169689Skan "__builtin_init_trampoline", ECF_NOTHROW); 6750169689Skan 6751169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6752169689Skan ftype = build_function_type (ptr_type_node, tmp); 6753169689Skan local_define_builtin ("__builtin_adjust_trampoline", ftype, 6754169689Skan BUILT_IN_ADJUST_TRAMPOLINE, 6755169689Skan "__builtin_adjust_trampoline", 6756169689Skan ECF_CONST | ECF_NOTHROW); 6757169689Skan 6758169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6759169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); 6760169689Skan ftype = build_function_type (void_type_node, tmp); 6761169689Skan local_define_builtin ("__builtin_nonlocal_goto", ftype, 6762169689Skan BUILT_IN_NONLOCAL_GOTO, 6763169689Skan "__builtin_nonlocal_goto", 6764169689Skan ECF_NORETURN | ECF_NOTHROW); 6765169689Skan 6766169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6767169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, tmp); 6768169689Skan ftype = build_function_type (void_type_node, tmp); 6769169689Skan local_define_builtin ("__builtin_setjmp_setup", ftype, 6770169689Skan BUILT_IN_SETJMP_SETUP, 6771169689Skan "__builtin_setjmp_setup", ECF_NOTHROW); 6772169689Skan 6773169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6774169689Skan ftype = build_function_type (ptr_type_node, tmp); 6775169689Skan local_define_builtin ("__builtin_setjmp_dispatcher", ftype, 6776169689Skan BUILT_IN_SETJMP_DISPATCHER, 6777169689Skan "__builtin_setjmp_dispatcher", 6778169689Skan ECF_PURE | ECF_NOTHROW); 6779169689Skan 6780169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6781169689Skan ftype = build_function_type (void_type_node, tmp); 6782169689Skan local_define_builtin ("__builtin_setjmp_receiver", ftype, 6783169689Skan BUILT_IN_SETJMP_RECEIVER, 6784169689Skan "__builtin_setjmp_receiver", ECF_NOTHROW); 6785169689Skan 6786169689Skan ftype = build_function_type (ptr_type_node, void_list_node); 6787169689Skan local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE, 6788169689Skan "__builtin_stack_save", ECF_NOTHROW); 6789169689Skan 6790169689Skan tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node); 6791169689Skan ftype = build_function_type (void_type_node, tmp); 6792169689Skan local_define_builtin ("__builtin_stack_restore", ftype, 6793169689Skan BUILT_IN_STACK_RESTORE, 6794169689Skan "__builtin_stack_restore", ECF_NOTHROW); 6795169689Skan 6796169689Skan ftype = build_function_type (void_type_node, void_list_node); 6797169689Skan local_define_builtin ("__builtin_profile_func_enter", ftype, 6798169689Skan BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0); 6799169689Skan local_define_builtin ("__builtin_profile_func_exit", ftype, 6800169689Skan BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0); 6801169689Skan 6802169689Skan /* Complex multiplication and division. These are handled as builtins 6803169689Skan rather than optabs because emit_library_call_value doesn't support 6804169689Skan complex. Further, we can do slightly better with folding these 6805169689Skan beasties if the real and complex parts of the arguments are separate. */ 6806169689Skan { 6807169689Skan enum machine_mode mode; 6808169689Skan 6809169689Skan for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode) 6810169689Skan { 6811169689Skan char mode_name_buf[4], *q; 6812169689Skan const char *p; 6813169689Skan enum built_in_function mcode, dcode; 6814169689Skan tree type, inner_type; 6815169689Skan 6816169689Skan type = lang_hooks.types.type_for_mode (mode, 0); 6817169689Skan if (type == NULL) 6818169689Skan continue; 6819169689Skan inner_type = TREE_TYPE (type); 6820169689Skan 6821169689Skan tmp = tree_cons (NULL_TREE, inner_type, void_list_node); 6822169689Skan tmp = tree_cons (NULL_TREE, inner_type, tmp); 6823169689Skan tmp = tree_cons (NULL_TREE, inner_type, tmp); 6824169689Skan tmp = tree_cons (NULL_TREE, inner_type, tmp); 6825169689Skan ftype = build_function_type (type, tmp); 6826169689Skan 6827169689Skan mcode = BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT; 6828169689Skan dcode = BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT; 6829169689Skan 6830169689Skan for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++) 6831169689Skan *q = TOLOWER (*p); 6832169689Skan *q = '\0'; 6833169689Skan 6834169689Skan built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL); 6835169689Skan local_define_builtin (built_in_names[mcode], ftype, mcode, 6836169689Skan built_in_names[mcode], ECF_CONST | ECF_NOTHROW); 6837169689Skan 6838169689Skan built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL); 6839169689Skan local_define_builtin (built_in_names[dcode], ftype, dcode, 6840169689Skan built_in_names[dcode], ECF_CONST | ECF_NOTHROW); 6841169689Skan } 6842169689Skan } 6843169689Skan} 6844169689Skan 6845146895Skan/* HACK. GROSS. This is absolutely disgusting. I wish there was a 6846146895Skan better way. 6847146895Skan 6848146895Skan If we requested a pointer to a vector, build up the pointers that 6849146895Skan we stripped off while looking for the inner type. Similarly for 6850146895Skan return values from functions. 6851146895Skan 6852146895Skan The argument TYPE is the top of the chain, and BOTTOM is the 6853146895Skan new type which we will point to. */ 6854146895Skan 6855146895Skantree 6856146895Skanreconstruct_complex_type (tree type, tree bottom) 6857146895Skan{ 6858146895Skan tree inner, outer; 6859146895Skan 6860146895Skan if (POINTER_TYPE_P (type)) 6861146895Skan { 6862146895Skan inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 6863146895Skan outer = build_pointer_type (inner); 6864146895Skan } 6865146895Skan else if (TREE_CODE (type) == ARRAY_TYPE) 6866146895Skan { 6867146895Skan inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 6868146895Skan outer = build_array_type (inner, TYPE_DOMAIN (type)); 6869146895Skan } 6870146895Skan else if (TREE_CODE (type) == FUNCTION_TYPE) 6871146895Skan { 6872146895Skan inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 6873146895Skan outer = build_function_type (inner, TYPE_ARG_TYPES (type)); 6874146895Skan } 6875146895Skan else if (TREE_CODE (type) == METHOD_TYPE) 6876146895Skan { 6877169689Skan tree argtypes; 6878146895Skan inner = reconstruct_complex_type (TREE_TYPE (type), bottom); 6879169689Skan /* The build_method_type_directly() routine prepends 'this' to argument list, 6880169689Skan so we must compensate by getting rid of it. */ 6881169689Skan argtypes = TYPE_ARG_TYPES (type); 6882146895Skan outer = build_method_type_directly (TYPE_METHOD_BASETYPE (type), 6883169689Skan inner, 6884169689Skan TYPE_ARG_TYPES (type)); 6885169689Skan TYPE_ARG_TYPES (outer) = argtypes; 6886146895Skan } 6887146895Skan else 6888146895Skan return bottom; 6889146895Skan 6890169689Skan TYPE_READONLY (outer) = TYPE_READONLY (type); 6891169689Skan TYPE_VOLATILE (outer) = TYPE_VOLATILE (type); 6892146895Skan 6893146895Skan return outer; 6894146895Skan} 6895146895Skan 6896169689Skan/* Returns a vector tree node given a mode (integer, vector, or BLKmode) and 6897169689Skan the inner type. */ 6898169689Skantree 6899169689Skanbuild_vector_type_for_mode (tree innertype, enum machine_mode mode) 6900169689Skan{ 6901169689Skan int nunits; 690290075Sobrien 6903169689Skan switch (GET_MODE_CLASS (mode)) 6904169689Skan { 6905169689Skan case MODE_VECTOR_INT: 6906169689Skan case MODE_VECTOR_FLOAT: 6907169689Skan nunits = GET_MODE_NUNITS (mode); 6908169689Skan break; 6909169689Skan 6910169689Skan case MODE_INT: 6911169689Skan /* Check that there are no leftover bits. */ 6912169689Skan gcc_assert (GET_MODE_BITSIZE (mode) 6913169689Skan % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0); 6914169689Skan 6915169689Skan nunits = GET_MODE_BITSIZE (mode) 6916169689Skan / TREE_INT_CST_LOW (TYPE_SIZE (innertype)); 6917169689Skan break; 6918169689Skan 6919169689Skan default: 6920169689Skan gcc_unreachable (); 6921169689Skan } 6922169689Skan 6923169689Skan return make_vector_type (innertype, nunits, mode); 6924169689Skan} 6925169689Skan 6926169689Skan/* Similarly, but takes the inner type and number of units, which must be 6927169689Skan a power of two. */ 6928169689Skan 6929146895Skantree 6930169689Skanbuild_vector_type (tree innertype, int nunits) 693190075Sobrien{ 6932169689Skan return make_vector_type (innertype, nunits, VOIDmode); 6933169689Skan} 693490075Sobrien 693590075Sobrien 6936169689Skan/* Build RESX_EXPR with given REGION_NUMBER. */ 6937169689Skantree 6938169689Skanbuild_resx (int region_number) 6939169689Skan{ 6940169689Skan tree t; 6941169689Skan t = build1 (RESX_EXPR, void_type_node, 6942169689Skan build_int_cst (NULL_TREE, region_number)); 694390075Sobrien return t; 694490075Sobrien} 6945117395Skan 6946117395Skan/* Given an initializer INIT, return TRUE if INIT is zero or some 6947117395Skan aggregate of zeros. Otherwise return FALSE. */ 6948117395Skanbool 6949132718Skaninitializer_zerop (tree init) 6950117395Skan{ 6951169689Skan tree elt; 6952169689Skan 6953117395Skan STRIP_NOPS (init); 6954117395Skan 6955117395Skan switch (TREE_CODE (init)) 6956117395Skan { 6957117395Skan case INTEGER_CST: 6958117395Skan return integer_zerop (init); 6959169689Skan 6960117395Skan case REAL_CST: 6961169689Skan /* ??? Note that this is not correct for C4X float formats. There, 6962169689Skan a bit pattern of all zeros is 1.0; 0.0 is encoded with the most 6963169689Skan negative exponent. */ 6964117395Skan return real_zerop (init) 6965117395Skan && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init)); 6966169689Skan 6967117395Skan case COMPLEX_CST: 6968117395Skan return integer_zerop (init) 6969117395Skan || (real_zerop (init) 6970117395Skan && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init))) 6971117395Skan && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init)))); 6972169689Skan 6973169689Skan case VECTOR_CST: 6974169689Skan for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt)) 6975169689Skan if (!initializer_zerop (TREE_VALUE (elt))) 6976169689Skan return false; 6977169689Skan return true; 6978169689Skan 6979117395Skan case CONSTRUCTOR: 6980117395Skan { 6981169689Skan unsigned HOST_WIDE_INT idx; 6982132718Skan 6983169689Skan FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt) 6984169689Skan if (!initializer_zerop (elt)) 6985169689Skan return false; 6986169689Skan return true; 6987169689Skan } 6988169689Skan 6989169689Skan default: 6990169689Skan return false; 6991169689Skan } 6992169689Skan} 6993169689Skan 6994169689Skan/* Build an empty statement. */ 6995169689Skan 6996169689Skantree 6997169689Skanbuild_empty_stmt (void) 6998169689Skan{ 6999169689Skan return build1 (NOP_EXPR, void_type_node, size_zero_node); 7000169689Skan} 7001169689Skan 7002169689Skan 7003169689Skan/* Build an OpenMP clause with code CODE. */ 7004169689Skan 7005169689Skantree 7006169689Skanbuild_omp_clause (enum omp_clause_code code) 7007169689Skan{ 7008169689Skan tree t; 7009169689Skan int size, length; 7010169689Skan 7011169689Skan length = omp_clause_num_ops[code]; 7012169689Skan size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree)); 7013169689Skan 7014169689Skan t = ggc_alloc (size); 7015169689Skan memset (t, 0, size); 7016169689Skan TREE_SET_CODE (t, OMP_CLAUSE); 7017169689Skan OMP_CLAUSE_SET_CODE (t, code); 7018169689Skan 7019169689Skan#ifdef GATHER_STATISTICS 7020169689Skan tree_node_counts[(int) omp_clause_kind]++; 7021169689Skan tree_node_sizes[(int) omp_clause_kind] += size; 7022169689Skan#endif 7023169689Skan 7024169689Skan return t; 7025169689Skan} 7026169689Skan 7027169689Skan 7028169689Skan/* Returns true if it is possible to prove that the index of 7029169689Skan an array access REF (an ARRAY_REF expression) falls into the 7030169689Skan array bounds. */ 7031169689Skan 7032169689Skanbool 7033169689Skanin_array_bounds_p (tree ref) 7034169689Skan{ 7035169689Skan tree idx = TREE_OPERAND (ref, 1); 7036169689Skan tree min, max; 7037169689Skan 7038169689Skan if (TREE_CODE (idx) != INTEGER_CST) 7039169689Skan return false; 7040169689Skan 7041169689Skan min = array_ref_low_bound (ref); 7042169689Skan max = array_ref_up_bound (ref); 7043169689Skan if (!min 7044169689Skan || !max 7045169689Skan || TREE_CODE (min) != INTEGER_CST 7046169689Skan || TREE_CODE (max) != INTEGER_CST) 7047169689Skan return false; 7048169689Skan 7049169689Skan if (tree_int_cst_lt (idx, min) 7050169689Skan || tree_int_cst_lt (max, idx)) 7051169689Skan return false; 7052169689Skan 7053169689Skan return true; 7054169689Skan} 7055169689Skan 7056169689Skan/* Returns true if it is possible to prove that the range of 7057169689Skan an array access REF (an ARRAY_RANGE_REF expression) falls 7058169689Skan into the array bounds. */ 7059169689Skan 7060169689Skanbool 7061169689Skanrange_in_array_bounds_p (tree ref) 7062169689Skan{ 7063169689Skan tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref)); 7064169689Skan tree range_min, range_max, min, max; 7065169689Skan 7066169689Skan range_min = TYPE_MIN_VALUE (domain_type); 7067169689Skan range_max = TYPE_MAX_VALUE (domain_type); 7068169689Skan if (!range_min 7069169689Skan || !range_max 7070169689Skan || TREE_CODE (range_min) != INTEGER_CST 7071169689Skan || TREE_CODE (range_max) != INTEGER_CST) 7072169689Skan return false; 7073169689Skan 7074169689Skan min = array_ref_low_bound (ref); 7075169689Skan max = array_ref_up_bound (ref); 7076169689Skan if (!min 7077169689Skan || !max 7078169689Skan || TREE_CODE (min) != INTEGER_CST 7079169689Skan || TREE_CODE (max) != INTEGER_CST) 7080169689Skan return false; 7081169689Skan 7082169689Skan if (tree_int_cst_lt (range_min, min) 7083169689Skan || tree_int_cst_lt (max, range_max)) 7084169689Skan return false; 7085169689Skan 7086169689Skan return true; 7087169689Skan} 7088169689Skan 7089169689Skan/* Return true if T (assumed to be a DECL) is a global variable. */ 7090169689Skan 7091169689Skanbool 7092169689Skanis_global_var (tree t) 7093169689Skan{ 7094169689Skan if (MTAG_P (t)) 7095169689Skan return (TREE_STATIC (t) || MTAG_GLOBAL (t)); 7096169689Skan else 7097169689Skan return (TREE_STATIC (t) || DECL_EXTERNAL (t)); 7098169689Skan} 7099169689Skan 7100169689Skan/* Return true if T (assumed to be a DECL) must be assigned a memory 7101169689Skan location. */ 7102169689Skan 7103169689Skanbool 7104169689Skanneeds_to_live_in_memory (tree t) 7105169689Skan{ 7106169689Skan return (TREE_ADDRESSABLE (t) 7107169689Skan || is_global_var (t) 7108169689Skan || (TREE_CODE (t) == RESULT_DECL 7109169689Skan && aggregate_value_p (t, current_function_decl))); 7110169689Skan} 7111169689Skan 7112169689Skan/* There are situations in which a language considers record types 7113169689Skan compatible which have different field lists. Decide if two fields 7114169689Skan are compatible. It is assumed that the parent records are compatible. */ 7115169689Skan 7116169689Skanbool 7117169689Skanfields_compatible_p (tree f1, tree f2) 7118169689Skan{ 7119169689Skan if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1), 7120169689Skan DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST)) 7121169689Skan return false; 7122169689Skan 7123169689Skan if (!operand_equal_p (DECL_FIELD_OFFSET (f1), 7124169689Skan DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST)) 7125169689Skan return false; 7126169689Skan 7127169689Skan if (!lang_hooks.types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2))) 7128169689Skan return false; 7129169689Skan 7130169689Skan return true; 7131169689Skan} 7132169689Skan 7133169689Skan/* Locate within RECORD a field that is compatible with ORIG_FIELD. */ 7134169689Skan 7135169689Skantree 7136169689Skanfind_compatible_field (tree record, tree orig_field) 7137169689Skan{ 7138169689Skan tree f; 7139169689Skan 7140169689Skan for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f)) 7141169689Skan if (TREE_CODE (f) == FIELD_DECL 7142169689Skan && fields_compatible_p (f, orig_field)) 7143169689Skan return f; 7144169689Skan 7145169689Skan /* ??? Why isn't this on the main fields list? */ 7146169689Skan f = TYPE_VFIELD (record); 7147169689Skan if (f && TREE_CODE (f) == FIELD_DECL 7148169689Skan && fields_compatible_p (f, orig_field)) 7149169689Skan return f; 7150169689Skan 7151169689Skan /* ??? We should abort here, but Java appears to do Bad Things 7152169689Skan with inherited fields. */ 7153169689Skan return orig_field; 7154169689Skan} 7155169689Skan 7156169689Skan/* Return value of a constant X. */ 7157169689Skan 7158169689SkanHOST_WIDE_INT 7159169689Skanint_cst_value (tree x) 7160169689Skan{ 7161169689Skan unsigned bits = TYPE_PRECISION (TREE_TYPE (x)); 7162169689Skan unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x); 7163169689Skan bool negative = ((val >> (bits - 1)) & 1) != 0; 7164169689Skan 7165169689Skan gcc_assert (bits <= HOST_BITS_PER_WIDE_INT); 7166169689Skan 7167169689Skan if (negative) 7168169689Skan val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1; 7169169689Skan else 7170169689Skan val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1); 7171169689Skan 7172169689Skan return val; 7173169689Skan} 7174169689Skan 7175169689Skan/* Returns the greatest common divisor of A and B, which must be 7176169689Skan INTEGER_CSTs. */ 7177169689Skan 7178169689Skantree 7179169689Skantree_fold_gcd (tree a, tree b) 7180169689Skan{ 7181169689Skan tree a_mod_b; 7182169689Skan tree type = TREE_TYPE (a); 7183169689Skan 7184169689Skan gcc_assert (TREE_CODE (a) == INTEGER_CST); 7185169689Skan gcc_assert (TREE_CODE (b) == INTEGER_CST); 7186169689Skan 7187169689Skan if (integer_zerop (a)) 7188169689Skan return b; 7189169689Skan 7190169689Skan if (integer_zerop (b)) 7191169689Skan return a; 7192169689Skan 7193169689Skan if (tree_int_cst_sgn (a) == -1) 7194169689Skan a = fold_build2 (MULT_EXPR, type, a, 7195169689Skan build_int_cst (type, -1)); 7196169689Skan 7197169689Skan if (tree_int_cst_sgn (b) == -1) 7198169689Skan b = fold_build2 (MULT_EXPR, type, b, 7199169689Skan build_int_cst (type, -1)); 7200169689Skan 7201169689Skan while (1) 7202169689Skan { 7203169689Skan a_mod_b = fold_build2 (FLOOR_MOD_EXPR, type, a, b); 7204169689Skan 7205169689Skan if (!TREE_INT_CST_LOW (a_mod_b) 7206169689Skan && !TREE_INT_CST_HIGH (a_mod_b)) 7207169689Skan return b; 7208169689Skan 7209169689Skan a = b; 7210169689Skan b = a_mod_b; 7211169689Skan } 7212169689Skan} 7213169689Skan 7214169689Skan/* Returns unsigned variant of TYPE. */ 7215169689Skan 7216169689Skantree 7217169689Skanunsigned_type_for (tree type) 7218169689Skan{ 7219169689Skan if (POINTER_TYPE_P (type)) 7220169689Skan return lang_hooks.types.unsigned_type (size_type_node); 7221169689Skan return lang_hooks.types.unsigned_type (type); 7222169689Skan} 7223169689Skan 7224169689Skan/* Returns signed variant of TYPE. */ 7225169689Skan 7226169689Skantree 7227169689Skansigned_type_for (tree type) 7228169689Skan{ 7229169689Skan if (POINTER_TYPE_P (type)) 7230169689Skan return lang_hooks.types.signed_type (size_type_node); 7231169689Skan return lang_hooks.types.signed_type (type); 7232169689Skan} 7233169689Skan 7234169689Skan/* Returns the largest value obtainable by casting something in INNER type to 7235169689Skan OUTER type. */ 7236169689Skan 7237169689Skantree 7238169689Skanupper_bound_in_type (tree outer, tree inner) 7239169689Skan{ 7240169689Skan unsigned HOST_WIDE_INT lo, hi; 7241169689Skan unsigned int det = 0; 7242169689Skan unsigned oprec = TYPE_PRECISION (outer); 7243169689Skan unsigned iprec = TYPE_PRECISION (inner); 7244169689Skan unsigned prec; 7245169689Skan 7246169689Skan /* Compute a unique number for every combination. */ 7247169689Skan det |= (oprec > iprec) ? 4 : 0; 7248169689Skan det |= TYPE_UNSIGNED (outer) ? 2 : 0; 7249169689Skan det |= TYPE_UNSIGNED (inner) ? 1 : 0; 7250169689Skan 7251169689Skan /* Determine the exponent to use. */ 7252169689Skan switch (det) 7253169689Skan { 7254169689Skan case 0: 7255169689Skan case 1: 7256169689Skan /* oprec <= iprec, outer: signed, inner: don't care. */ 7257169689Skan prec = oprec - 1; 7258169689Skan break; 7259169689Skan case 2: 7260169689Skan case 3: 7261169689Skan /* oprec <= iprec, outer: unsigned, inner: don't care. */ 7262169689Skan prec = oprec; 7263169689Skan break; 7264169689Skan case 4: 7265169689Skan /* oprec > iprec, outer: signed, inner: signed. */ 7266169689Skan prec = iprec - 1; 7267169689Skan break; 7268169689Skan case 5: 7269169689Skan /* oprec > iprec, outer: signed, inner: unsigned. */ 7270169689Skan prec = iprec; 7271169689Skan break; 7272169689Skan case 6: 7273169689Skan /* oprec > iprec, outer: unsigned, inner: signed. */ 7274169689Skan prec = oprec; 7275169689Skan break; 7276169689Skan case 7: 7277169689Skan /* oprec > iprec, outer: unsigned, inner: unsigned. */ 7278169689Skan prec = iprec; 7279169689Skan break; 7280169689Skan default: 7281169689Skan gcc_unreachable (); 7282169689Skan } 7283169689Skan 7284169689Skan /* Compute 2^^prec - 1. */ 7285169689Skan if (prec <= HOST_BITS_PER_WIDE_INT) 7286169689Skan { 7287169689Skan hi = 0; 7288169689Skan lo = ((~(unsigned HOST_WIDE_INT) 0) 7289169689Skan >> (HOST_BITS_PER_WIDE_INT - prec)); 7290169689Skan } 7291169689Skan else 7292169689Skan { 7293169689Skan hi = ((~(unsigned HOST_WIDE_INT) 0) 7294169689Skan >> (2 * HOST_BITS_PER_WIDE_INT - prec)); 7295169689Skan lo = ~(unsigned HOST_WIDE_INT) 0; 7296169689Skan } 7297169689Skan 7298169689Skan return build_int_cst_wide (outer, lo, hi); 7299169689Skan} 7300169689Skan 7301169689Skan/* Returns the smallest value obtainable by casting something in INNER type to 7302169689Skan OUTER type. */ 7303169689Skan 7304169689Skantree 7305169689Skanlower_bound_in_type (tree outer, tree inner) 7306169689Skan{ 7307169689Skan unsigned HOST_WIDE_INT lo, hi; 7308169689Skan unsigned oprec = TYPE_PRECISION (outer); 7309169689Skan unsigned iprec = TYPE_PRECISION (inner); 7310169689Skan 7311169689Skan /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type 7312169689Skan and obtain 0. */ 7313169689Skan if (TYPE_UNSIGNED (outer) 7314169689Skan /* If we are widening something of an unsigned type, OUTER type 7315169689Skan contains all values of INNER type. In particular, both INNER 7316169689Skan and OUTER types have zero in common. */ 7317169689Skan || (oprec > iprec && TYPE_UNSIGNED (inner))) 7318169689Skan lo = hi = 0; 7319169689Skan else 7320169689Skan { 7321169689Skan /* If we are widening a signed type to another signed type, we 7322169689Skan want to obtain -2^^(iprec-1). If we are keeping the 7323169689Skan precision or narrowing to a signed type, we want to obtain 7324169689Skan -2^(oprec-1). */ 7325169689Skan unsigned prec = oprec > iprec ? iprec : oprec; 7326169689Skan 7327169689Skan if (prec <= HOST_BITS_PER_WIDE_INT) 7328169689Skan { 7329169689Skan hi = ~(unsigned HOST_WIDE_INT) 0; 7330169689Skan lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1); 7331169689Skan } 7332169689Skan else 7333169689Skan { 7334169689Skan hi = ((~(unsigned HOST_WIDE_INT) 0) 7335169689Skan << (prec - HOST_BITS_PER_WIDE_INT - 1)); 7336169689Skan lo = 0; 7337169689Skan } 7338169689Skan } 7339169689Skan 7340169689Skan return build_int_cst_wide (outer, lo, hi); 7341169689Skan} 7342169689Skan 7343169689Skan/* Return nonzero if two operands that are suitable for PHI nodes are 7344169689Skan necessarily equal. Specifically, both ARG0 and ARG1 must be either 7345169689Skan SSA_NAME or invariant. Note that this is strictly an optimization. 7346169689Skan That is, callers of this function can directly call operand_equal_p 7347169689Skan and get the same result, only slower. */ 7348169689Skan 7349169689Skanint 7350169689Skanoperand_equal_for_phi_arg_p (tree arg0, tree arg1) 7351169689Skan{ 7352169689Skan if (arg0 == arg1) 7353169689Skan return 1; 7354169689Skan if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME) 7355169689Skan return 0; 7356169689Skan return operand_equal_p (arg0, arg1, 0); 7357169689Skan} 7358169689Skan 7359169689Skan/* Returns number of zeros at the end of binary representation of X. 7360169689Skan 7361169689Skan ??? Use ffs if available? */ 7362169689Skan 7363169689Skantree 7364169689Skannum_ending_zeros (tree x) 7365169689Skan{ 7366169689Skan unsigned HOST_WIDE_INT fr, nfr; 7367169689Skan unsigned num, abits; 7368169689Skan tree type = TREE_TYPE (x); 7369169689Skan 7370169689Skan if (TREE_INT_CST_LOW (x) == 0) 7371169689Skan { 7372169689Skan num = HOST_BITS_PER_WIDE_INT; 7373169689Skan fr = TREE_INT_CST_HIGH (x); 7374169689Skan } 7375169689Skan else 7376169689Skan { 7377169689Skan num = 0; 7378169689Skan fr = TREE_INT_CST_LOW (x); 7379169689Skan } 7380169689Skan 7381169689Skan for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2) 7382169689Skan { 7383169689Skan nfr = fr >> abits; 7384169689Skan if (nfr << abits == fr) 7385169689Skan { 7386169689Skan num += abits; 7387169689Skan fr = nfr; 7388169689Skan } 7389169689Skan } 7390169689Skan 7391169689Skan if (num > TYPE_PRECISION (type)) 7392169689Skan num = TYPE_PRECISION (type); 7393169689Skan 7394169689Skan return build_int_cst_type (type, num); 7395169689Skan} 7396169689Skan 7397169689Skan 7398169689Skan#define WALK_SUBTREE(NODE) \ 7399169689Skan do \ 7400169689Skan { \ 7401169689Skan result = walk_tree (&(NODE), func, data, pset); \ 7402169689Skan if (result) \ 7403169689Skan return result; \ 7404169689Skan } \ 7405169689Skan while (0) 7406169689Skan 7407169689Skan/* This is a subroutine of walk_tree that walks field of TYPE that are to 7408169689Skan be walked whenever a type is seen in the tree. Rest of operands and return 7409169689Skan value are as for walk_tree. */ 7410169689Skan 7411169689Skanstatic tree 7412169689Skanwalk_type_fields (tree type, walk_tree_fn func, void *data, 7413169689Skan struct pointer_set_t *pset) 7414169689Skan{ 7415169689Skan tree result = NULL_TREE; 7416169689Skan 7417169689Skan switch (TREE_CODE (type)) 7418169689Skan { 7419169689Skan case POINTER_TYPE: 7420169689Skan case REFERENCE_TYPE: 7421169689Skan /* We have to worry about mutually recursive pointers. These can't 7422169689Skan be written in C. They can in Ada. It's pathological, but 7423169689Skan there's an ACATS test (c38102a) that checks it. Deal with this 7424169689Skan by checking if we're pointing to another pointer, that one 7425169689Skan points to another pointer, that one does too, and we have no htab. 7426169689Skan If so, get a hash table. We check three levels deep to avoid 7427169689Skan the cost of the hash table if we don't need one. */ 7428169689Skan if (POINTER_TYPE_P (TREE_TYPE (type)) 7429169689Skan && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type))) 7430169689Skan && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type)))) 7431169689Skan && !pset) 7432169689Skan { 7433169689Skan result = walk_tree_without_duplicates (&TREE_TYPE (type), 7434169689Skan func, data); 7435169689Skan if (result) 7436169689Skan return result; 7437169689Skan 7438169689Skan break; 7439169689Skan } 7440169689Skan 7441169689Skan /* ... fall through ... */ 7442169689Skan 7443169689Skan case COMPLEX_TYPE: 7444169689Skan WALK_SUBTREE (TREE_TYPE (type)); 7445169689Skan break; 7446169689Skan 7447169689Skan case METHOD_TYPE: 7448169689Skan WALK_SUBTREE (TYPE_METHOD_BASETYPE (type)); 7449169689Skan 7450169689Skan /* Fall through. */ 7451169689Skan 7452169689Skan case FUNCTION_TYPE: 7453169689Skan WALK_SUBTREE (TREE_TYPE (type)); 7454169689Skan { 7455169689Skan tree arg; 7456169689Skan 7457169689Skan /* We never want to walk into default arguments. */ 7458169689Skan for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg)) 7459169689Skan WALK_SUBTREE (TREE_VALUE (arg)); 7460169689Skan } 7461169689Skan break; 7462169689Skan 7463169689Skan case ARRAY_TYPE: 7464169689Skan /* Don't follow this nodes's type if a pointer for fear that 7465169689Skan we'll have infinite recursion. If we have a PSET, then we 7466169689Skan need not fear. */ 7467169689Skan if (pset 7468169689Skan || (!POINTER_TYPE_P (TREE_TYPE (type)) 7469169689Skan && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE)) 7470169689Skan WALK_SUBTREE (TREE_TYPE (type)); 7471169689Skan WALK_SUBTREE (TYPE_DOMAIN (type)); 7472169689Skan break; 7473169689Skan 7474169689Skan case BOOLEAN_TYPE: 7475169689Skan case ENUMERAL_TYPE: 7476169689Skan case INTEGER_TYPE: 7477169689Skan case REAL_TYPE: 7478169689Skan WALK_SUBTREE (TYPE_MIN_VALUE (type)); 7479169689Skan WALK_SUBTREE (TYPE_MAX_VALUE (type)); 7480169689Skan break; 7481169689Skan 7482169689Skan case OFFSET_TYPE: 7483169689Skan WALK_SUBTREE (TREE_TYPE (type)); 7484169689Skan WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type)); 7485169689Skan break; 7486169689Skan 7487169689Skan default: 7488169689Skan break; 7489169689Skan } 7490169689Skan 7491169689Skan return NULL_TREE; 7492169689Skan} 7493169689Skan 7494169689Skan/* Apply FUNC to all the sub-trees of TP in a pre-order traversal. FUNC is 7495169689Skan called with the DATA and the address of each sub-tree. If FUNC returns a 7496169689Skan non-NULL value, the traversal is stopped, and the value returned by FUNC 7497169689Skan is returned. If PSET is non-NULL it is used to record the nodes visited, 7498169689Skan and to avoid visiting a node more than once. */ 7499169689Skan 7500169689Skantree 7501169689Skanwalk_tree (tree *tp, walk_tree_fn func, void *data, struct pointer_set_t *pset) 7502169689Skan{ 7503169689Skan enum tree_code code; 7504169689Skan int walk_subtrees; 7505169689Skan tree result; 7506169689Skan 7507169689Skan#define WALK_SUBTREE_TAIL(NODE) \ 7508169689Skan do \ 7509169689Skan { \ 7510169689Skan tp = & (NODE); \ 7511169689Skan goto tail_recurse; \ 7512169689Skan } \ 7513169689Skan while (0) 7514169689Skan 7515169689Skan tail_recurse: 7516169689Skan /* Skip empty subtrees. */ 7517169689Skan if (!*tp) 7518169689Skan return NULL_TREE; 7519169689Skan 7520169689Skan /* Don't walk the same tree twice, if the user has requested 7521169689Skan that we avoid doing so. */ 7522169689Skan if (pset && pointer_set_insert (pset, *tp)) 7523169689Skan return NULL_TREE; 7524169689Skan 7525169689Skan /* Call the function. */ 7526169689Skan walk_subtrees = 1; 7527169689Skan result = (*func) (tp, &walk_subtrees, data); 7528169689Skan 7529169689Skan /* If we found something, return it. */ 7530169689Skan if (result) 7531169689Skan return result; 7532169689Skan 7533169689Skan code = TREE_CODE (*tp); 7534169689Skan 7535169689Skan /* Even if we didn't, FUNC may have decided that there was nothing 7536169689Skan interesting below this point in the tree. */ 7537169689Skan if (!walk_subtrees) 7538169689Skan { 7539169689Skan /* But we still need to check our siblings. */ 7540169689Skan if (code == TREE_LIST) 7541169689Skan WALK_SUBTREE_TAIL (TREE_CHAIN (*tp)); 7542169689Skan else if (code == OMP_CLAUSE) 7543169689Skan WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 7544169689Skan else 7545169689Skan return NULL_TREE; 7546169689Skan } 7547169689Skan 7548169689Skan result = lang_hooks.tree_inlining.walk_subtrees (tp, &walk_subtrees, func, 7549169689Skan data, pset); 7550169689Skan if (result || ! walk_subtrees) 7551169689Skan return result; 7552169689Skan 7553169689Skan switch (code) 7554169689Skan { 7555169689Skan case ERROR_MARK: 7556169689Skan case IDENTIFIER_NODE: 7557169689Skan case INTEGER_CST: 7558169689Skan case REAL_CST: 7559169689Skan case VECTOR_CST: 7560169689Skan case STRING_CST: 7561169689Skan case BLOCK: 7562169689Skan case PLACEHOLDER_EXPR: 7563169689Skan case SSA_NAME: 7564169689Skan case FIELD_DECL: 7565169689Skan case RESULT_DECL: 7566169689Skan /* None of these have subtrees other than those already walked 7567169689Skan above. */ 7568169689Skan break; 7569169689Skan 7570169689Skan case TREE_LIST: 7571169689Skan WALK_SUBTREE (TREE_VALUE (*tp)); 7572169689Skan WALK_SUBTREE_TAIL (TREE_CHAIN (*tp)); 7573169689Skan break; 7574169689Skan 7575169689Skan case TREE_VEC: 7576169689Skan { 7577169689Skan int len = TREE_VEC_LENGTH (*tp); 7578169689Skan 7579169689Skan if (len == 0) 7580169689Skan break; 7581169689Skan 7582169689Skan /* Walk all elements but the first. */ 7583169689Skan while (--len) 7584169689Skan WALK_SUBTREE (TREE_VEC_ELT (*tp, len)); 7585169689Skan 7586169689Skan /* Now walk the first one as a tail call. */ 7587169689Skan WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0)); 7588169689Skan } 7589169689Skan 7590169689Skan case COMPLEX_CST: 7591169689Skan WALK_SUBTREE (TREE_REALPART (*tp)); 7592169689Skan WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp)); 7593169689Skan 7594169689Skan case CONSTRUCTOR: 7595169689Skan { 7596169689Skan unsigned HOST_WIDE_INT idx; 7597169689Skan constructor_elt *ce; 7598169689Skan 7599169689Skan for (idx = 0; 7600169689Skan VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce); 7601169689Skan idx++) 7602169689Skan WALK_SUBTREE (ce->value); 7603169689Skan } 7604169689Skan break; 7605169689Skan 7606169689Skan case SAVE_EXPR: 7607169689Skan WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0)); 7608169689Skan 7609169689Skan case BIND_EXPR: 7610169689Skan { 7611169689Skan tree decl; 7612169689Skan for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl)) 7613117395Skan { 7614169689Skan /* Walk the DECL_INITIAL and DECL_SIZE. We don't want to walk 7615169689Skan into declarations that are just mentioned, rather than 7616169689Skan declared; they don't really belong to this part of the tree. 7617169689Skan And, we can see cycles: the initializer for a declaration 7618169689Skan can refer to the declaration itself. */ 7619169689Skan WALK_SUBTREE (DECL_INITIAL (decl)); 7620169689Skan WALK_SUBTREE (DECL_SIZE (decl)); 7621169689Skan WALK_SUBTREE (DECL_SIZE_UNIT (decl)); 7622169689Skan } 7623169689Skan WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp)); 7624169689Skan } 7625117395Skan 7626169689Skan case STATEMENT_LIST: 7627169689Skan { 7628169689Skan tree_stmt_iterator i; 7629169689Skan for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i)) 7630169689Skan WALK_SUBTREE (*tsi_stmt_ptr (i)); 7631169689Skan } 7632169689Skan break; 7633169689Skan 7634169689Skan case OMP_CLAUSE: 7635169689Skan switch (OMP_CLAUSE_CODE (*tp)) 7636169689Skan { 7637169689Skan case OMP_CLAUSE_PRIVATE: 7638169689Skan case OMP_CLAUSE_SHARED: 7639169689Skan case OMP_CLAUSE_FIRSTPRIVATE: 7640169689Skan case OMP_CLAUSE_LASTPRIVATE: 7641169689Skan case OMP_CLAUSE_COPYIN: 7642169689Skan case OMP_CLAUSE_COPYPRIVATE: 7643169689Skan case OMP_CLAUSE_IF: 7644169689Skan case OMP_CLAUSE_NUM_THREADS: 7645169689Skan case OMP_CLAUSE_SCHEDULE: 7646169689Skan WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0)); 7647169689Skan /* FALLTHRU */ 7648169689Skan 7649169689Skan case OMP_CLAUSE_NOWAIT: 7650169689Skan case OMP_CLAUSE_ORDERED: 7651169689Skan case OMP_CLAUSE_DEFAULT: 7652169689Skan WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 7653169689Skan 7654169689Skan case OMP_CLAUSE_REDUCTION: 7655169689Skan { 7656169689Skan int i; 7657169689Skan for (i = 0; i < 4; i++) 7658169689Skan WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i)); 7659169689Skan WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp)); 7660117395Skan } 7661169689Skan 7662169689Skan default: 7663169689Skan gcc_unreachable (); 7664169689Skan } 7665169689Skan break; 7666169689Skan 7667169689Skan case TARGET_EXPR: 7668169689Skan { 7669169689Skan int i, len; 7670169689Skan 7671169689Skan /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same. 7672169689Skan But, we only want to walk once. */ 7673169689Skan len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3; 7674169689Skan for (i = 0; i < len; ++i) 7675169689Skan WALK_SUBTREE (TREE_OPERAND (*tp, i)); 7676169689Skan WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len)); 7677117395Skan } 7678169689Skan 7679169689Skan case DECL_EXPR: 7680169689Skan /* Walk into various fields of the type that it's defining. We only 7681169689Skan want to walk into these fields of a type in this case. Note that 7682169689Skan decls get walked as part of the processing of a BIND_EXPR. 7683169689Skan 7684169689Skan ??? Precisely which fields of types that we are supposed to walk in 7685169689Skan this case vs. the normal case aren't well defined. */ 7686169689Skan if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL 7687169689Skan && TREE_CODE (TREE_TYPE (DECL_EXPR_DECL (*tp))) != ERROR_MARK) 7688169689Skan { 7689169689Skan tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp)); 7690169689Skan 7691169689Skan /* Call the function for the type. See if it returns anything or 7692169689Skan doesn't want us to continue. If we are to continue, walk both 7693169689Skan the normal fields and those for the declaration case. */ 7694169689Skan result = (*func) (type_p, &walk_subtrees, data); 7695169689Skan if (result || !walk_subtrees) 7696169689Skan return NULL_TREE; 7697169689Skan 7698169689Skan result = walk_type_fields (*type_p, func, data, pset); 7699169689Skan if (result) 7700169689Skan return result; 7701169689Skan 7702169689Skan /* If this is a record type, also walk the fields. */ 7703169689Skan if (TREE_CODE (*type_p) == RECORD_TYPE 7704169689Skan || TREE_CODE (*type_p) == UNION_TYPE 7705169689Skan || TREE_CODE (*type_p) == QUAL_UNION_TYPE) 7706169689Skan { 7707169689Skan tree field; 7708169689Skan 7709169689Skan for (field = TYPE_FIELDS (*type_p); field; 7710169689Skan field = TREE_CHAIN (field)) 7711169689Skan { 7712169689Skan /* We'd like to look at the type of the field, but we can 7713169689Skan easily get infinite recursion. So assume it's pointed 7714169689Skan to elsewhere in the tree. Also, ignore things that 7715169689Skan aren't fields. */ 7716169689Skan if (TREE_CODE (field) != FIELD_DECL) 7717169689Skan continue; 7718169689Skan 7719169689Skan WALK_SUBTREE (DECL_FIELD_OFFSET (field)); 7720169689Skan WALK_SUBTREE (DECL_SIZE (field)); 7721169689Skan WALK_SUBTREE (DECL_SIZE_UNIT (field)); 7722169689Skan if (TREE_CODE (*type_p) == QUAL_UNION_TYPE) 7723169689Skan WALK_SUBTREE (DECL_QUALIFIER (field)); 7724169689Skan } 7725169689Skan } 7726169689Skan 7727169689Skan WALK_SUBTREE (TYPE_SIZE (*type_p)); 7728169689Skan WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p)); 7729169689Skan } 7730169689Skan /* FALLTHRU */ 7731169689Skan 7732117395Skan default: 7733169689Skan if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code))) 7734169689Skan { 7735169689Skan int i, len; 7736169689Skan 7737169689Skan /* Walk over all the sub-trees of this operand. */ 7738169689Skan len = TREE_CODE_LENGTH (code); 7739169689Skan 7740169689Skan /* Go through the subtrees. We need to do this in forward order so 7741169689Skan that the scope of a FOR_EXPR is handled properly. */ 7742169689Skan if (len) 7743169689Skan { 7744169689Skan for (i = 0; i < len - 1; ++i) 7745169689Skan WALK_SUBTREE (TREE_OPERAND (*tp, i)); 7746169689Skan WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1)); 7747169689Skan } 7748169689Skan } 7749169689Skan 7750169689Skan /* If this is a type, walk the needed fields in the type. */ 7751169689Skan else if (TYPE_P (*tp)) 7752169689Skan return walk_type_fields (*tp, func, data, pset); 7753169689Skan break; 7754117395Skan } 7755169689Skan 7756169689Skan /* We didn't find what we were looking for. */ 7757169689Skan return NULL_TREE; 7758169689Skan 7759169689Skan#undef WALK_SUBTREE_TAIL 7760117395Skan} 7761169689Skan#undef WALK_SUBTREE 7762117395Skan 7763169689Skan/* Like walk_tree, but does not walk duplicate nodes more than once. */ 7764169689Skan 7765169689Skantree 7766169689Skanwalk_tree_without_duplicates (tree *tp, walk_tree_fn func, void *data) 7767169689Skan{ 7768169689Skan tree result; 7769169689Skan struct pointer_set_t *pset; 7770169689Skan 7771169689Skan pset = pointer_set_create (); 7772169689Skan result = walk_tree (tp, func, data, pset); 7773169689Skan pointer_set_destroy (pset); 7774169689Skan return result; 7775169689Skan} 7776169689Skan 7777169689Skan 7778169689Skan/* Return true if STMT is an empty statement or contains nothing but 7779169689Skan empty statements. */ 7780169689Skan 7781169689Skanbool 7782169689Skanempty_body_p (tree stmt) 7783169689Skan{ 7784169689Skan tree_stmt_iterator i; 7785169689Skan tree body; 7786169689Skan 7787169689Skan if (IS_EMPTY_STMT (stmt)) 7788169689Skan return true; 7789169689Skan else if (TREE_CODE (stmt) == BIND_EXPR) 7790169689Skan body = BIND_EXPR_BODY (stmt); 7791169689Skan else if (TREE_CODE (stmt) == STATEMENT_LIST) 7792169689Skan body = stmt; 7793169689Skan else 7794169689Skan return false; 7795169689Skan 7796169689Skan for (i = tsi_start (body); !tsi_end_p (i); tsi_next (&i)) 7797169689Skan if (!empty_body_p (tsi_stmt (i))) 7798169689Skan return false; 7799169689Skan 7800169689Skan return true; 7801169689Skan} 7802169689Skan 7803261188Spfg 7804117395Skan#include "gt-tree.h" 7805