gcc/tree.c

   1 /* Language-independent node constructors for parse phase of GNU compiler.
   2    Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* This file contains the low level primitives for operating on tree nodes,
  23    including allocation, list operations, interning of identifiers,
  24    construction of data type nodes and statement nodes,
  25    and construction of type conversion nodes.  It also contains
  26    tables index by tree code that describe how to take apart
  27    nodes of that code.
  28
  29    It is intended to be language-independent, but occasionally
  30    calls language-dependent routines defined (for C) in typecheck.c.  */
  31
  32 #include "config.h"
  33 #include "system.h"
  34 #include "coretypes.h"
  35 #include "tm.h"
  36 #include "flags.h"
  37 #include "tree.h"
  38 #include "real.h"
  39 #include "tm_p.h"
  40 #include "function.h"
  41 #include "obstack.h"
  42 #include "toplev.h"
  43 #include "ggc.h"
  44 #include "hashtab.h"
  45 #include "output.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "tree-inline.h"
  49 #include "tree-iterator.h"
  50 #include "basic-block.h"
  51 #include "tree-flow.h"
  52 #include "params.h"
  53 #include "pointer-set.h"
  54 #include "fixed-value.h"
  55 #include "tree-pass.h"
  56 #include "langhooks-def.h"
  57 #include "diagnostic.h"
  58 #include "cgraph.h"
  59 #include "timevar.h"
  60 #include "except.h"
  61 #include "debug.h"
  62
  63 /* Tree code classes.  */
  64
  65 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
  66 #define END_OF_BASE_TREE_CODES tcc_exceptional,
  67
  68 const enum tree_code_class tree_code_type[] = {
  69 #include "all-tree.def"
  70 };
  71
  72 #undef DEFTREECODE
  73 #undef END_OF_BASE_TREE_CODES
  74
  75 /* Table indexed by tree code giving number of expression
  76    operands beyond the fixed part of the node structure.
  77    Not used for types or decls.  */
  78
  79 #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
  80 #define END_OF_BASE_TREE_CODES 0,
  81
  82 const unsigned char tree_code_length[] = {
  83 #include "all-tree.def"
  84 };
  85
  86 #undef DEFTREECODE
  87 #undef END_OF_BASE_TREE_CODES
  88
  89 /* Names of tree components.
  90    Used for printing out the tree and error messages.  */
  91 #define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
  92 #define END_OF_BASE_TREE_CODES "@dummy",
  93
  94 const char *const tree_code_name[] = {
  95 #include "all-tree.def"
  96 };
  97
  98 #undef DEFTREECODE
  99 #undef END_OF_BASE_TREE_CODES
 100
 101 /* Each tree code class has an associated string representation.
 102    These must correspond to the tree_code_class entries.  */
 103
 104 const char *const tree_code_class_strings[] =
 105 {
 106   "exceptional",
 107   "constant",
 108   "type",
 109   "declaration",
 110   "reference",
 111   "comparison",
 112   "unary",
 113   "binary",
 114   "statement",
 115   "vl_exp",
 116   "expression"
 117 };
 118
 119 /* obstack.[ch] explicitly declined to prototype this.  */
 120 extern int _obstack_allocated_p (struct obstack *h, void *obj);
 121
 122 #ifdef GATHER_STATISTICS
 123 /* Statistics-gathering stuff.  */
 124
 125 int tree_node_counts[(int) all_kinds];
 126 int tree_node_sizes[(int) all_kinds];
 127
 128 /* Keep in sync with tree.h:enum tree_node_kind.  */
 129 static const char * const tree_node_kind_names[] = {
 130   "decls",
 131   "types",
 132   "blocks",
 133   "stmts",
 134   "refs",
 135   "exprs",
 136   "constants",
 137   "identifiers",
 138   "perm_tree_lists",
 139   "temp_tree_lists",
 140   "vecs",
 141   "binfos",
 142   "ssa names",
 143   "constructors",
 144   "random kinds",
 145   "lang_decl kinds",
 146   "lang_type kinds",
 147   "omp clauses",
 148 };
 149 #endif /* GATHER_STATISTICS */
 150
 151 /* Unique id for next decl created.  */
 152 static GTY(()) int next_decl_uid;
 153 /* Unique id for next type created.  */
 154 static GTY(()) int next_type_uid = 1;
 155
 156 /* Since we cannot rehash a type after it is in the table, we have to
 157    keep the hash code.  */
 158
 159 struct GTY(()) type_hash {
 160   unsigned long hash;
 161   tree type;
 162 };
 163
 164 /* Initial size of the hash table (rounded to next prime).  */
 165 #define TYPE_HASH_INITIAL_SIZE 1000
 166
 167 /* Now here is the hash table.  When recording a type, it is added to
 168    the slot whose index is the hash code.  Note that the hash table is
 169    used for several kinds of types (function types, array types and
 170    array index range types, for now).  While all these live in the
 171    same table, they are completely independent, and the hash code is
 172    computed differently for each of these.  */
 173
 174 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
 175      htab_t type_hash_table;
 176
 177 /* Hash table and temporary node for larger integer const values.  */
 178 static GTY (()) tree int_cst_node;
 179 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 180      htab_t int_cst_hash_table;
 181
 182 /* Hash table for optimization flags and target option flags.  Use the same
 183    hash table for both sets of options.  Nodes for building the current
 184    optimization and target option nodes.  The assumption is most of the time
 185    the options created will already be in the hash table, so we avoid
 186    allocating and freeing up a node repeatably.  */
 187 static GTY (()) tree cl_optimization_node;
 188 static GTY (()) tree cl_target_option_node;
 189 static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
 190      htab_t cl_option_hash_table;
 191
 192 /* General tree->tree mapping  structure for use in hash tables.  */
 193
 194
 195 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 196      htab_t debug_expr_for_decl;
 197
 198 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
 199      htab_t value_expr_for_decl;
 200
 201 static GTY ((if_marked ("tree_priority_map_marked_p"),
 202              param_is (struct tree_priority_map)))
 203   htab_t init_priority_for_decl;
 204
 205 static void set_type_quals (tree, int);
 206 static int type_hash_eq (const void *, const void *);
 207 static hashval_t type_hash_hash (const void *);
 208 static hashval_t int_cst_hash_hash (const void *);
 209 static int int_cst_hash_eq (const void *, const void *);
 210 static hashval_t cl_option_hash_hash (const void *);
 211 static int cl_option_hash_eq (const void *, const void *);
 212 static void print_type_hash_statistics (void);
 213 static void print_debug_expr_statistics (void);
 214 static void print_value_expr_statistics (void);
 215 static int type_hash_marked_p (const void *);
 216 static unsigned int type_hash_list (const_tree, hashval_t);
 217 static unsigned int attribute_hash_list (const_tree, hashval_t);
 218
 219 tree global_trees[TI_MAX];
 220 tree integer_types[itk_none];
 221
 222 unsigned char tree_contains_struct[MAX_TREE_CODES][64];
 223
 224 /* Number of operands for each OpenMP clause.  */
 225 unsigned const char omp_clause_num_ops[] =
 226 {
 227   0, /* OMP_CLAUSE_ERROR  */
 228   1, /* OMP_CLAUSE_PRIVATE  */
 229   1, /* OMP_CLAUSE_SHARED  */
 230   1, /* OMP_CLAUSE_FIRSTPRIVATE  */
 231   2, /* OMP_CLAUSE_LASTPRIVATE  */
 232   4, /* OMP_CLAUSE_REDUCTION  */
 233   1, /* OMP_CLAUSE_COPYIN  */
 234   1, /* OMP_CLAUSE_COPYPRIVATE  */
 235   1, /* OMP_CLAUSE_IF  */
 236   1, /* OMP_CLAUSE_NUM_THREADS  */
 237   1, /* OMP_CLAUSE_SCHEDULE  */
 238   0, /* OMP_CLAUSE_NOWAIT  */
 239   0, /* OMP_CLAUSE_ORDERED  */
 240   0, /* OMP_CLAUSE_DEFAULT  */
 241   3, /* OMP_CLAUSE_COLLAPSE  */
 242   0  /* OMP_CLAUSE_UNTIED   */
 243 };
 244
 245 const char * const omp_clause_code_name[] =
 246 {
 247   "error_clause",
 248   "private",
 249   "shared",
 250   "firstprivate",
 251   "lastprivate",
 252   "reduction",
 253   "copyin",
 254   "copyprivate",
 255   "if",
 256   "num_threads",
 257   "schedule",
 258   "nowait",
 259   "ordered",
 260   "default",
 261   "collapse",
 262   "untied"
 263 };
 264
 265
 266 /* Return the tree node structure used by tree code CODE.  */
 267
 268 static inline enum tree_node_structure_enum
 269 tree_node_structure_for_code (enum tree_code code)
 270 {
 271   switch (TREE_CODE_CLASS (code))
 272     {
 273     case tcc_declaration:
 274       {
 275         switch (code)
 276           {
 277           case FIELD_DECL:
 278             return TS_FIELD_DECL;
 279           case PARM_DECL:
 280             return TS_PARM_DECL;
 281           case VAR_DECL:
 282             return TS_VAR_DECL;
 283           case LABEL_DECL:
 284             return TS_LABEL_DECL;
 285           case RESULT_DECL:
 286             return TS_RESULT_DECL;
 287           case CONST_DECL:
 288             return TS_CONST_DECL;
 289           case TYPE_DECL:
 290             return TS_TYPE_DECL;
 291           case FUNCTION_DECL:
 292             return TS_FUNCTION_DECL;
 293           default:
 294             return TS_DECL_NON_COMMON;
 295           }
 296       }
 297     case tcc_type:
 298       return TS_TYPE;
 299     case tcc_reference:
 300     case tcc_comparison:
 301     case tcc_unary:
 302     case tcc_binary:
 303     case tcc_expression:
 304     case tcc_statement:
 305     case tcc_vl_exp:
 306       return TS_EXP;
 307     default:  /* tcc_constant and tcc_exceptional */
 308       break;
 309     }
 310   switch (code)
 311     {
 312       /* tcc_constant cases.  */
 313     case INTEGER_CST:           return TS_INT_CST;
 314     case REAL_CST:              return TS_REAL_CST;
 315     case FIXED_CST:             return TS_FIXED_CST;
 316     case COMPLEX_CST:           return TS_COMPLEX;
 317     case VECTOR_CST:            return TS_VECTOR;
 318     case STRING_CST:            return TS_STRING;
 319       /* tcc_exceptional cases.  */
 320     case ERROR_MARK:            return TS_COMMON;
 321     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
 322     case TREE_LIST:             return TS_LIST;
 323     case TREE_VEC:              return TS_VEC;
 324     case SSA_NAME:              return TS_SSA_NAME;
 325     case PLACEHOLDER_EXPR:      return TS_COMMON;
 326     case STATEMENT_LIST:        return TS_STATEMENT_LIST;
 327     case BLOCK:                 return TS_BLOCK;
 328     case CONSTRUCTOR:           return TS_CONSTRUCTOR;
 329     case TREE_BINFO:            return TS_BINFO;
 330     case OMP_CLAUSE:            return TS_OMP_CLAUSE;
 331     case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
 332     case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
 333
 334     default:
 335       gcc_unreachable ();
 336     }
 337 }
 338
 339
 340 /* Initialize tree_contains_struct to describe the hierarchy of tree
 341    nodes.  */
 342
 343 static void
 344 initialize_tree_contains_struct (void)
 345 {
 346   unsigned i;
 347
 348 #define MARK_TS_BASE(C)                                 \
 349   do {                                                  \
 350     tree_contains_struct[C][TS_BASE] = 1;               \
 351   } while (0)
 352
 353 #define MARK_TS_COMMON(C)                               \
 354   do {                                                  \
 355     MARK_TS_BASE (C);                                   \
 356     tree_contains_struct[C][TS_COMMON] = 1;             \
 357   } while (0)
 358
 359 #define MARK_TS_DECL_MINIMAL(C)                         \
 360   do {                                                  \
 361     MARK_TS_COMMON (C);                                 \
 362     tree_contains_struct[C][TS_DECL_MINIMAL] = 1;       \
 363   } while (0)
 364
 365 #define MARK_TS_DECL_COMMON(C)                          \
 366   do {                                                  \
 367     MARK_TS_DECL_MINIMAL (C);                           \
 368     tree_contains_struct[C][TS_DECL_COMMON] = 1;        \
 369   } while (0)
 370
 371 #define MARK_TS_DECL_WRTL(C)                            \
 372   do {                                                  \
 373     MARK_TS_DECL_COMMON (C);                            \
 374     tree_contains_struct[C][TS_DECL_WRTL] = 1;          \
 375   } while (0)
 376
 377 #define MARK_TS_DECL_WITH_VIS(C)                        \
 378   do {                                                  \
 379     MARK_TS_DECL_WRTL (C);                              \
 380     tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;      \
 381   } while (0)
 382
 383 #define MARK_TS_DECL_NON_COMMON(C)                      \
 384   do {                                                  \
 385     MARK_TS_DECL_WITH_VIS (C);                          \
 386     tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;    \
 387   } while (0)
 388
 389   for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
 390     {
 391       enum tree_code code;
 392       enum tree_node_structure_enum ts_code;
 393
 394       code = (enum tree_code) i;
 395       ts_code = tree_node_structure_for_code (code);
 396
 397       /* Mark the TS structure itself.  */
 398       tree_contains_struct[code][ts_code] = 1;
 399
 400       /* Mark all the structures that TS is derived from.  */
 401       switch (ts_code)
 402         {
 403         case TS_COMMON:
 404           MARK_TS_BASE (code);
 405           break;
 406
 407         case TS_INT_CST:
 408         case TS_REAL_CST:
 409         case TS_FIXED_CST:
 410         case TS_VECTOR:
 411         case TS_STRING:
 412         case TS_COMPLEX:
 413         case TS_IDENTIFIER:
 414         case TS_DECL_MINIMAL:
 415         case TS_TYPE:
 416         case TS_LIST:
 417         case TS_VEC:
 418         case TS_EXP:
 419         case TS_SSA_NAME:
 420         case TS_BLOCK:
 421         case TS_BINFO:
 422         case TS_STATEMENT_LIST:
 423         case TS_CONSTRUCTOR:
 424         case TS_OMP_CLAUSE:
 425         case TS_OPTIMIZATION:
 426         case TS_TARGET_OPTION:
 427           MARK_TS_COMMON (code);
 428           break;
 429
 430         case TS_DECL_COMMON:
 431           MARK_TS_DECL_MINIMAL (code);
 432           break;
 433
 434         case TS_DECL_WRTL:
 435           MARK_TS_DECL_COMMON (code);
 436           break;
 437
 438         case TS_DECL_NON_COMMON:
 439           MARK_TS_DECL_WITH_VIS (code);
 440           break;
 441
 442         case TS_DECL_WITH_VIS:
 443         case TS_PARM_DECL:
 444         case TS_LABEL_DECL:
 445         case TS_RESULT_DECL:
 446         case TS_CONST_DECL:
 447           MARK_TS_DECL_WRTL (code);
 448           break;
 449
 450         case TS_FIELD_DECL:
 451           MARK_TS_DECL_COMMON (code);
 452           break;
 453
 454         case TS_VAR_DECL:
 455           MARK_TS_DECL_WITH_VIS (code);
 456           break;
 457
 458         case TS_TYPE_DECL:
 459         case TS_FUNCTION_DECL:
 460           MARK_TS_DECL_NON_COMMON (code);
 461           break;
 462
 463         default:
 464           gcc_unreachable ();
 465         }
 466     }
 467
 468   /* Basic consistency checks for attributes used in fold.  */
 469   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
 470   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON]);
 471   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
 472   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
 473   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
 474   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
 475   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
 476   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
 477   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
 478   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
 479   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
 480   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
 481   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
 482   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
 483   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
 484   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
 485   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
 486   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
 487   gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
 488   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
 489   gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
 490   gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
 491   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
 492   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
 493   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
 494   gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
 495   gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
 496   gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
 497   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
 498   gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
 499   gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS]);
 500   gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
 501   gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
 502   gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
 503   gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
 504   gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
 505   gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
 506   gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
 507   gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
 508   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
 509   gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
 510
 511 #undef MARK_TS_BASE
 512 #undef MARK_TS_COMMON
 513 #undef MARK_TS_DECL_MINIMAL
 514 #undef MARK_TS_DECL_COMMON
 515 #undef MARK_TS_DECL_WRTL
 516 #undef MARK_TS_DECL_WITH_VIS
 517 #undef MARK_TS_DECL_NON_COMMON
 518 }
 519
 520
 521 /* Init tree.c.  */
 522
 523 void
 524 init_ttree (void)
 525 {
 526   /* Initialize the hash table of types.  */
 527   type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
 528                                      type_hash_eq, 0);
 529
 530   debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
 531                                          tree_map_eq, 0);
 532
 533   value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
 534                                          tree_map_eq, 0);
 535   init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
 536                                             tree_priority_map_eq, 0);
 537
 538   int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
 539                                         int_cst_hash_eq, NULL);
 540
 541   int_cst_node = make_node (INTEGER_CST);
 542
 543   cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
 544                                           cl_option_hash_eq, NULL);
 545
 546   cl_optimization_node = make_node (OPTIMIZATION_NODE);
 547   cl_target_option_node = make_node (TARGET_OPTION_NODE);
 548
 549   /* Initialize the tree_contains_struct array.  */
 550   initialize_tree_contains_struct ();
 551   lang_hooks.init_ts ();
 552 }
 553
 554 \f
 555 /* The name of the object as the assembler will see it (but before any
 556    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
 557    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
 558 tree
 559 decl_assembler_name (tree decl)
 560 {
 561   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 562     lang_hooks.set_decl_assembler_name (decl);
 563   return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
 564 }
 565
 566 /* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
 567
 568 bool
 569 decl_assembler_name_equal (tree decl, const_tree asmname)
 570 {
 571   tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
 572   const char *decl_str;
 573   const char *asmname_str;
 574   bool test = false;
 575
 576   if (decl_asmname == asmname)
 577     return true;
 578
 579   decl_str = IDENTIFIER_POINTER (decl_asmname);
 580   asmname_str = IDENTIFIER_POINTER (asmname);
 581
 582
 583   /* If the target assembler name was set by the user, things are trickier.
 584      We have a leading '*' to begin with.  After that, it's arguable what
 585      is the correct thing to do with -fleading-underscore.  Arguably, we've
 586      historically been doing the wrong thing in assemble_alias by always
 587      printing the leading underscore.  Since we're not changing that, make
 588      sure user_label_prefix follows the '*' before matching.  */
 589   if (decl_str[0] == '*')
 590     {
 591       size_t ulp_len = strlen (user_label_prefix);
 592
 593       decl_str ++;
 594
 595       if (ulp_len == 0)
 596         test = true;
 597       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 598         decl_str += ulp_len, test=true;
 599       else
 600         decl_str --;
 601     }
 602   if (asmname_str[0] == '*')
 603     {
 604       size_t ulp_len = strlen (user_label_prefix);
 605
 606       asmname_str ++;
 607
 608       if (ulp_len == 0)
 609         test = true;
 610       else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
 611         asmname_str += ulp_len, test=true;
 612       else
 613         asmname_str --;
 614     }
 615
 616   if (!test)
 617     return false;
 618   return strcmp (decl_str, asmname_str) == 0;
 619 }
 620
 621 /* Hash asmnames ignoring the user specified marks.  */
 622
 623 hashval_t
 624 decl_assembler_name_hash (const_tree asmname)
 625 {
 626   if (IDENTIFIER_POINTER (asmname)[0] == '*')
 627     {
 628       const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
 629       size_t ulp_len = strlen (user_label_prefix);
 630
 631       if (ulp_len == 0)
 632         ;
 633       else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
 634         decl_str += ulp_len;
 635
 636       return htab_hash_string (decl_str);
 637     }
 638
 639   return htab_hash_string (IDENTIFIER_POINTER (asmname));
 640 }
 641
 642 /* Compute the number of bytes occupied by a tree with code CODE.
 643    This function cannot be used for nodes that have variable sizes,
 644    including TREE_VEC, STRING_CST, and CALL_EXPR.  */
 645 size_t
 646 tree_code_size (enum tree_code code)
 647 {
 648   switch (TREE_CODE_CLASS (code))
 649     {
 650     case tcc_declaration:  /* A decl node */
 651       {
 652         switch (code)
 653           {
 654           case FIELD_DECL:
 655             return sizeof (struct tree_field_decl);
 656           case PARM_DECL:
 657             return sizeof (struct tree_parm_decl);
 658           case VAR_DECL:
 659             return sizeof (struct tree_var_decl);
 660           case LABEL_DECL:
 661             return sizeof (struct tree_label_decl);
 662           case RESULT_DECL:
 663             return sizeof (struct tree_result_decl);
 664           case CONST_DECL:
 665             return sizeof (struct tree_const_decl);
 666           case TYPE_DECL:
 667             return sizeof (struct tree_type_decl);
 668           case FUNCTION_DECL:
 669             return sizeof (struct tree_function_decl);
 670           default:
 671             return sizeof (struct tree_decl_non_common);
 672           }
 673       }
 674
 675     case tcc_type:  /* a type node */
 676       return sizeof (struct tree_type);
 677
 678     case tcc_reference:   /* a reference */
 679     case tcc_expression:  /* an expression */
 680     case tcc_statement:   /* an expression with side effects */
 681     case tcc_comparison:  /* a comparison expression */
 682     case tcc_unary:       /* a unary arithmetic expression */
 683     case tcc_binary:      /* a binary arithmetic expression */
 684       return (sizeof (struct tree_exp)
 685               + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
 686
 687     case tcc_constant:  /* a constant */
 688       switch (code)
 689         {
 690         case INTEGER_CST:       return sizeof (struct tree_int_cst);
 691         case REAL_CST:          return sizeof (struct tree_real_cst);
 692         case FIXED_CST:         return sizeof (struct tree_fixed_cst);
 693         case COMPLEX_CST:       return sizeof (struct tree_complex);
 694         case VECTOR_CST:        return sizeof (struct tree_vector);
 695         case STRING_CST:        gcc_unreachable ();
 696         default:
 697           return lang_hooks.tree_size (code);
 698         }
 699
 700     case tcc_exceptional:  /* something random, like an identifier.  */
 701       switch (code)
 702         {
 703         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
 704         case TREE_LIST:         return sizeof (struct tree_list);
 705
 706         case ERROR_MARK:
 707         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
 708
 709         case TREE_VEC:
 710         case OMP_CLAUSE:        gcc_unreachable ();
 711
 712         case SSA_NAME:          return sizeof (struct tree_ssa_name);
 713
 714         case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
 715         case BLOCK:             return sizeof (struct tree_block);
 716         case CONSTRUCTOR:       return sizeof (struct tree_constructor);
 717         case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
 718         case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
 719
 720         default:
 721           return lang_hooks.tree_size (code);
 722         }
 723
 724     default:
 725       gcc_unreachable ();
 726     }
 727 }
 728
 729 /* Compute the number of bytes occupied by NODE.  This routine only
 730    looks at TREE_CODE, except for those nodes that have variable sizes.  */
 731 size_t
 732 tree_size (const_tree node)
 733 {
 734   const enum tree_code code = TREE_CODE (node);
 735   switch (code)
 736     {
 737     case TREE_BINFO:
 738       return (offsetof (struct tree_binfo, base_binfos)
 739               + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
 740
 741     case TREE_VEC:
 742       return (sizeof (struct tree_vec)
 743               + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
 744
 745     case STRING_CST:
 746       return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
 747
 748     case OMP_CLAUSE:
 749       return (sizeof (struct tree_omp_clause)
 750               + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
 751                 * sizeof (tree));
 752
 753     default:
 754       if (TREE_CODE_CLASS (code) == tcc_vl_exp)
 755         return (sizeof (struct tree_exp)
 756                 + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
 757       else
 758         return tree_code_size (code);
 759     }
 760 }
 761
 762 /* Return a newly allocated node of code CODE.  For decl and type
 763    nodes, some other fields are initialized.  The rest of the node is
 764    initialized to zero.  This function cannot be used for TREE_VEC or
 765    OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
 766
 767    Achoo!  I got a code in the node.  */
 768
 769 tree
 770 make_node_stat (enum tree_code code MEM_STAT_DECL)
 771 {
 772   tree t;
 773   enum tree_code_class type = TREE_CODE_CLASS (code);
 774   size_t length = tree_code_size (code);
 775 #ifdef GATHER_STATISTICS
 776   tree_node_kind kind;
 777
 778   switch (type)
 779     {
 780     case tcc_declaration:  /* A decl node */
 781       kind = d_kind;
 782       break;
 783
 784     case tcc_type:  /* a type node */
 785       kind = t_kind;
 786       break;
 787
 788     case tcc_statement:  /* an expression with side effects */
 789       kind = s_kind;
 790       break;
 791
 792     case tcc_reference:  /* a reference */
 793       kind = r_kind;
 794       break;
 795
 796     case tcc_expression:  /* an expression */
 797     case tcc_comparison:  /* a comparison expression */
 798     case tcc_unary:  /* a unary arithmetic expression */
 799     case tcc_binary:  /* a binary arithmetic expression */
 800       kind = e_kind;
 801       break;
 802
 803     case tcc_constant:  /* a constant */
 804       kind = c_kind;
 805       break;
 806
 807     case tcc_exceptional:  /* something random, like an identifier.  */
 808       switch (code)
 809         {
 810         case IDENTIFIER_NODE:
 811           kind = id_kind;
 812           break;
 813
 814         case TREE_VEC:
 815           kind = vec_kind;
 816           break;
 817
 818         case TREE_BINFO:
 819           kind = binfo_kind;
 820           break;
 821
 822         case SSA_NAME:
 823           kind = ssa_name_kind;
 824           break;
 825
 826         case BLOCK:
 827           kind = b_kind;
 828           break;
 829
 830         case CONSTRUCTOR:
 831           kind = constr_kind;
 832           break;
 833
 834         default:
 835           kind = x_kind;
 836           break;
 837         }
 838       break;
 839
 840     default:
 841       gcc_unreachable ();
 842     }
 843
 844   tree_node_counts[(int) kind]++;
 845   tree_node_sizes[(int) kind] += length;
 846 #endif
 847
 848   if (code == IDENTIFIER_NODE)
 849     t = (tree) ggc_alloc_zone_pass_stat (length, &tree_id_zone);
 850   else
 851     t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
 852
 853   memset (t, 0, length);
 854
 855   TREE_SET_CODE (t, code);
 856
 857   switch (type)
 858     {
 859     case tcc_statement:
 860       TREE_SIDE_EFFECTS (t) = 1;
 861       break;
 862
 863     case tcc_declaration:
 864       if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
 865         {
 866           if (code == FUNCTION_DECL)
 867             {
 868               DECL_ALIGN (t) = FUNCTION_BOUNDARY;
 869               DECL_MODE (t) = FUNCTION_MODE;
 870             }
 871           else
 872             DECL_ALIGN (t) = 1;
 873         }
 874       DECL_SOURCE_LOCATION (t) = input_location;
 875       DECL_UID (t) = next_decl_uid++;
 876       if (TREE_CODE (t) == LABEL_DECL)
 877         LABEL_DECL_UID (t) = -1;
 878
 879       break;
 880
 881     case tcc_type:
 882       TYPE_UID (t) = next_type_uid++;
 883       TYPE_ALIGN (t) = BITS_PER_UNIT;
 884       TYPE_USER_ALIGN (t) = 0;
 885       TYPE_MAIN_VARIANT (t) = t;
 886       TYPE_CANONICAL (t) = t;
 887
 888       /* Default to no attributes for type, but let target change that.  */
 889       TYPE_ATTRIBUTES (t) = NULL_TREE;
 890       targetm.set_default_type_attributes (t);
 891
 892       /* We have not yet computed the alias set for this type.  */
 893       TYPE_ALIAS_SET (t) = -1;
 894       break;
 895
 896     case tcc_constant:
 897       TREE_CONSTANT (t) = 1;
 898       break;
 899
 900     case tcc_expression:
 901       switch (code)
 902         {
 903         case INIT_EXPR:
 904         case MODIFY_EXPR:
 905         case VA_ARG_EXPR:
 906         case PREDECREMENT_EXPR:
 907         case PREINCREMENT_EXPR:
 908         case POSTDECREMENT_EXPR:
 909         case POSTINCREMENT_EXPR:
 910           /* All of these have side-effects, no matter what their
 911              operands are.  */
 912           TREE_SIDE_EFFECTS (t) = 1;
 913           break;
 914
 915         default:
 916           break;
 917         }
 918       break;
 919
 920     default:
 921       /* Other classes need no special treatment.  */
 922       break;
 923     }
 924
 925   return t;
 926 }
 927 \f
 928 /* Return a new node with the same contents as NODE except that its
 929    TREE_CHAIN is zero and it has a fresh uid.  */
 930
 931 tree
 932 copy_node_stat (tree node MEM_STAT_DECL)
 933 {
 934   tree t;
 935   enum tree_code code = TREE_CODE (node);
 936   size_t length;
 937
 938   gcc_assert (code != STATEMENT_LIST);
 939
 940   length = tree_size (node);
 941   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
 942   memcpy (t, node, length);
 943
 944   TREE_CHAIN (t) = 0;
 945   TREE_ASM_WRITTEN (t) = 0;
 946   TREE_VISITED (t) = 0;
 947   t->base.ann = 0;
 948
 949   if (TREE_CODE_CLASS (code) == tcc_declaration)
 950     {
 951       DECL_UID (t) = next_decl_uid++;
 952       if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
 953           && DECL_HAS_VALUE_EXPR_P (node))
 954         {
 955           SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
 956           DECL_HAS_VALUE_EXPR_P (t) = 1;
 957         }
 958       if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
 959         {
 960           SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
 961           DECL_HAS_INIT_PRIORITY_P (t) = 1;
 962         }
 963     }
 964   else if (TREE_CODE_CLASS (code) == tcc_type)
 965     {
 966       TYPE_UID (t) = next_type_uid++;
 967       /* The following is so that the debug code for
 968          the copy is different from the original type.
 969          The two statements usually duplicate each other
 970          (because they clear fields of the same union),
 971          but the optimizer should catch that.  */
 972       TYPE_SYMTAB_POINTER (t) = 0;
 973       TYPE_SYMTAB_ADDRESS (t) = 0;
 974
 975       /* Do not copy the values cache.  */
 976       if (TYPE_CACHED_VALUES_P(t))
 977         {
 978           TYPE_CACHED_VALUES_P (t) = 0;
 979           TYPE_CACHED_VALUES (t) = NULL_TREE;
 980         }
 981     }
 982
 983   return t;
 984 }
 985
 986 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
 987    For example, this can copy a list made of TREE_LIST nodes.  */
 988
 989 tree
 990 copy_list (tree list)
 991 {
 992   tree head;
 993   tree prev, next;
 994
 995   if (list == 0)
 996     return 0;
 997
 998   head = prev = copy_node (list);
 999   next = TREE_CHAIN (list);
1000   while (next)
1001     {
1002       TREE_CHAIN (prev) = copy_node (next);
1003       prev = TREE_CHAIN (prev);
1004       next = TREE_CHAIN (next);
1005     }
1006   return head;
1007 }
1008
1009 \f
1010 /* Create an INT_CST node with a LOW value sign extended.  */
1011
1012 tree
1013 build_int_cst (tree type, HOST_WIDE_INT low)
1014 {
1015   /* Support legacy code.  */
1016   if (!type)
1017     type = integer_type_node;
1018
1019   return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
1020 }
1021
1022 /* Create an INT_CST node with a LOW value zero extended.  */
1023
1024 tree
1025 build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
1026 {
1027   return build_int_cst_wide (type, low, 0);
1028 }
1029
1030 /* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
1031    if it is negative.  This function is similar to build_int_cst, but
1032    the extra bits outside of the type precision are cleared.  Constants
1033    with these extra bits may confuse the fold so that it detects overflows
1034    even in cases when they do not occur, and in general should be avoided.
1035    We cannot however make this a default behavior of build_int_cst without
1036    more intrusive changes, since there are parts of gcc that rely on the extra
1037    precision of the integer constants.  */
1038
1039 tree
1040 build_int_cst_type (tree type, HOST_WIDE_INT low)
1041 {
1042   unsigned HOST_WIDE_INT low1;
1043   HOST_WIDE_INT hi;
1044
1045   gcc_assert (type);
1046
1047   fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
1048
1049   return build_int_cst_wide (type, low1, hi);
1050 }
1051
1052 /* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
1053    and sign extended according to the value range of TYPE.  */
1054
1055 tree
1056 build_int_cst_wide_type (tree type,
1057                          unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
1058 {
1059   fit_double_type (low, high, &low, &high, type);
1060   return build_int_cst_wide (type, low, high);
1061 }
1062
1063 /* These are the hash table functions for the hash table of INTEGER_CST
1064    nodes of a sizetype.  */
1065
1066 /* Return the hash code code X, an INTEGER_CST.  */
1067
1068 static hashval_t
1069 int_cst_hash_hash (const void *x)
1070 {
1071   const_tree const t = (const_tree) x;
1072
1073   return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1074           ^ htab_hash_pointer (TREE_TYPE (t)));
1075 }
1076
1077 /* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1078    is the same as that given by *Y, which is the same.  */
1079
1080 static int
1081 int_cst_hash_eq (const void *x, const void *y)
1082 {
1083   const_tree const xt = (const_tree) x;
1084   const_tree const yt = (const_tree) y;
1085
1086   return (TREE_TYPE (xt) == TREE_TYPE (yt)
1087           && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1088           && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1089 }
1090
1091 /* Create an INT_CST node of TYPE and value HI:LOW.
1092    The returned node is always shared.  For small integers we use a
1093    per-type vector cache, for larger ones we use a single hash table.  */
1094
1095 tree
1096 build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1097 {
1098   tree t;
1099   int ix = -1;
1100   int limit = 0;
1101
1102   gcc_assert (type);
1103
1104   switch (TREE_CODE (type))
1105     {
1106     case POINTER_TYPE:
1107     case REFERENCE_TYPE:
1108       /* Cache NULL pointer.  */
1109       if (!hi && !low)
1110         {
1111           limit = 1;
1112           ix = 0;
1113         }
1114       break;
1115
1116     case BOOLEAN_TYPE:
1117       /* Cache false or true.  */
1118       limit = 2;
1119       if (!hi && low < 2)
1120         ix = low;
1121       break;
1122
1123     case INTEGER_TYPE:
1124     case OFFSET_TYPE:
1125       if (TYPE_UNSIGNED (type))
1126         {
1127           /* Cache 0..N */
1128           limit = INTEGER_SHARE_LIMIT;
1129           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1130             ix = low;
1131         }
1132       else
1133         {
1134           /* Cache -1..N */
1135           limit = INTEGER_SHARE_LIMIT + 1;
1136           if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1137             ix = low + 1;
1138           else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1139             ix = 0;
1140         }
1141       break;
1142
1143     case ENUMERAL_TYPE:
1144       break;
1145
1146     default:
1147       gcc_unreachable ();
1148     }
1149
1150   if (ix >= 0)
1151     {
1152       /* Look for it in the type's vector of small shared ints.  */
1153       if (!TYPE_CACHED_VALUES_P (type))
1154         {
1155           TYPE_CACHED_VALUES_P (type) = 1;
1156           TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1157         }
1158
1159       t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1160       if (t)
1161         {
1162           /* Make sure no one is clobbering the shared constant.  */
1163           gcc_assert (TREE_TYPE (t) == type);
1164           gcc_assert (TREE_INT_CST_LOW (t) == low);
1165           gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1166         }
1167       else
1168         {
1169           /* Create a new shared int.  */
1170           t = make_node (INTEGER_CST);
1171
1172           TREE_INT_CST_LOW (t) = low;
1173           TREE_INT_CST_HIGH (t) = hi;
1174           TREE_TYPE (t) = type;
1175
1176           TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1177         }
1178     }
1179   else
1180     {
1181       /* Use the cache of larger shared ints.  */
1182       void **slot;
1183
1184       TREE_INT_CST_LOW (int_cst_node) = low;
1185       TREE_INT_CST_HIGH (int_cst_node) = hi;
1186       TREE_TYPE (int_cst_node) = type;
1187
1188       slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1189       t = (tree) *slot;
1190       if (!t)
1191         {
1192           /* Insert this one into the hash table.  */
1193           t = int_cst_node;
1194           *slot = t;
1195           /* Make a new node for next time round.  */
1196           int_cst_node = make_node (INTEGER_CST);
1197         }
1198     }
1199
1200   return t;
1201 }
1202
1203 /* Builds an integer constant in TYPE such that lowest BITS bits are ones
1204    and the rest are zeros.  */
1205
1206 tree
1207 build_low_bits_mask (tree type, unsigned bits)
1208 {
1209   unsigned HOST_WIDE_INT low;
1210   HOST_WIDE_INT high;
1211   unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
1212
1213   gcc_assert (bits <= TYPE_PRECISION (type));
1214
1215   if (bits == TYPE_PRECISION (type)
1216       && !TYPE_UNSIGNED (type))
1217     {
1218       /* Sign extended all-ones mask.  */
1219       low = all_ones;
1220       high = -1;
1221     }
1222   else if (bits <= HOST_BITS_PER_WIDE_INT)
1223     {
1224       low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
1225       high = 0;
1226     }
1227   else
1228     {
1229       bits -= HOST_BITS_PER_WIDE_INT;
1230       low = all_ones;
1231       high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
1232     }
1233
1234   return build_int_cst_wide (type, low, high);
1235 }
1236
1237 /* Checks that X is integer constant that can be expressed in (unsigned)
1238    HOST_WIDE_INT without loss of precision.  */
1239
1240 bool
1241 cst_and_fits_in_hwi (const_tree x)
1242 {
1243   if (TREE_CODE (x) != INTEGER_CST)
1244     return false;
1245
1246   if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1247     return false;
1248
1249   return (TREE_INT_CST_HIGH (x) == 0
1250           || TREE_INT_CST_HIGH (x) == -1);
1251 }
1252
1253 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1254    are in a list pointed to by VALS.  */
1255
1256 tree
1257 build_vector (tree type, tree vals)
1258 {
1259   tree v = make_node (VECTOR_CST);
1260   int over = 0;
1261   tree link;
1262
1263   TREE_VECTOR_CST_ELTS (v) = vals;
1264   TREE_TYPE (v) = type;
1265
1266   /* Iterate through elements and check for overflow.  */
1267   for (link = vals; link; link = TREE_CHAIN (link))
1268     {
1269       tree value = TREE_VALUE (link);
1270
1271       /* Don't crash if we get an address constant.  */
1272       if (!CONSTANT_CLASS_P (value))
1273         continue;
1274
1275       over |= TREE_OVERFLOW (value);
1276     }
1277
1278   TREE_OVERFLOW (v) = over;
1279   return v;
1280 }
1281
1282 /* Return a new VECTOR_CST node whose type is TYPE and whose values
1283    are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1284
1285 tree
1286 build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1287 {
1288   tree list = NULL_TREE;
1289   unsigned HOST_WIDE_INT idx;
1290   tree value;
1291
1292   FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1293     list = tree_cons (NULL_TREE, value, list);
1294   return build_vector (type, nreverse (list));
1295 }
1296
1297 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1298    are in the VEC pointed to by VALS.  */
1299 tree
1300 build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1301 {
1302   tree c = make_node (CONSTRUCTOR);
1303   TREE_TYPE (c) = type;
1304   CONSTRUCTOR_ELTS (c) = vals;
1305   return c;
1306 }
1307
1308 /* Build a CONSTRUCTOR node made of a single initializer, with the specified
1309    INDEX and VALUE.  */
1310 tree
1311 build_constructor_single (tree type, tree index, tree value)
1312 {
1313   VEC(constructor_elt,gc) *v;
1314   constructor_elt *elt;
1315   tree t;
1316
1317   v = VEC_alloc (constructor_elt, gc, 1);
1318   elt = VEC_quick_push (constructor_elt, v, NULL);
1319   elt->index = index;
1320   elt->value = value;
1321
1322   t = build_constructor (type, v);
1323   TREE_CONSTANT (t) = TREE_CONSTANT (value);
1324   return t;
1325 }
1326
1327
1328 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1329    are in a list pointed to by VALS.  */
1330 tree
1331 build_constructor_from_list (tree type, tree vals)
1332 {
1333   tree t, val;
1334   VEC(constructor_elt,gc) *v = NULL;
1335   bool constant_p = true;
1336
1337   if (vals)
1338     {
1339       v = VEC_alloc (constructor_elt, gc, list_length (vals));
1340       for (t = vals; t; t = TREE_CHAIN (t))
1341         {
1342           constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
1343           val = TREE_VALUE (t);
1344           elt->index = TREE_PURPOSE (t);
1345           elt->value = val;
1346           if (!TREE_CONSTANT (val))
1347             constant_p = false;
1348         }
1349     }
1350
1351   t = build_constructor (type, v);
1352   TREE_CONSTANT (t) = constant_p;
1353   return t;
1354 }
1355
1356 /* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1357
1358 tree
1359 build_fixed (tree type, FIXED_VALUE_TYPE f)
1360 {
1361   tree v;
1362   FIXED_VALUE_TYPE *fp;
1363
1364   v = make_node (FIXED_CST);
1365   fp = GGC_NEW (FIXED_VALUE_TYPE);
1366   memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1367
1368   TREE_TYPE (v) = type;
1369   TREE_FIXED_CST_PTR (v) = fp;
1370   return v;
1371 }
1372
1373 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
1374
1375 tree
1376 build_real (tree type, REAL_VALUE_TYPE d)
1377 {
1378   tree v;
1379   REAL_VALUE_TYPE *dp;
1380   int overflow = 0;
1381
1382   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1383      Consider doing it via real_convert now.  */
1384
1385   v = make_node (REAL_CST);
1386   dp = GGC_NEW (REAL_VALUE_TYPE);
1387   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1388
1389   TREE_TYPE (v) = type;
1390   TREE_REAL_CST_PTR (v) = dp;
1391   TREE_OVERFLOW (v) = overflow;
1392   return v;
1393 }
1394
1395 /* Return a new REAL_CST node whose type is TYPE
1396    and whose value is the integer value of the INTEGER_CST node I.  */
1397
1398 REAL_VALUE_TYPE
1399 real_value_from_int_cst (const_tree type, const_tree i)
1400 {
1401   REAL_VALUE_TYPE d;
1402
1403   /* Clear all bits of the real value type so that we can later do
1404      bitwise comparisons to see if two values are the same.  */
1405   memset (&d, 0, sizeof d);
1406
1407   real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1408                      TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1409                      TYPE_UNSIGNED (TREE_TYPE (i)));
1410   return d;
1411 }
1412
1413 /* Given a tree representing an integer constant I, return a tree
1414    representing the same value as a floating-point constant of type TYPE.  */
1415
1416 tree
1417 build_real_from_int_cst (tree type, const_tree i)
1418 {
1419   tree v;
1420   int overflow = TREE_OVERFLOW (i);
1421
1422   v = build_real (type, real_value_from_int_cst (type, i));
1423
1424   TREE_OVERFLOW (v) |= overflow;
1425   return v;
1426 }
1427
1428 /* Return a newly constructed STRING_CST node whose value is
1429    the LEN characters at STR.
1430    The TREE_TYPE is not initialized.  */
1431
1432 tree
1433 build_string (int len, const char *str)
1434 {
1435   tree s;
1436   size_t length;
1437
1438   /* Do not waste bytes provided by padding of struct tree_string.  */
1439   length = len + offsetof (struct tree_string, str) + 1;
1440
1441 #ifdef GATHER_STATISTICS
1442   tree_node_counts[(int) c_kind]++;
1443   tree_node_sizes[(int) c_kind] += length;
1444 #endif
1445
1446   s = ggc_alloc_tree (length);
1447
1448   memset (s, 0, sizeof (struct tree_common));
1449   TREE_SET_CODE (s, STRING_CST);
1450   TREE_CONSTANT (s) = 1;
1451   TREE_STRING_LENGTH (s) = len;
1452   memcpy (s->string.str, str, len);
1453   s->string.str[len] = '\0';
1454
1455   return s;
1456 }
1457
1458 /* Return a newly constructed COMPLEX_CST node whose value is
1459    specified by the real and imaginary parts REAL and IMAG.
1460    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1461    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1462
1463 tree
1464 build_complex (tree type, tree real, tree imag)
1465 {
1466   tree t = make_node (COMPLEX_CST);
1467
1468   TREE_REALPART (t) = real;
1469   TREE_IMAGPART (t) = imag;
1470   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1471   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1472   return t;
1473 }
1474
1475 /* Return a constant of arithmetic type TYPE which is the
1476    multiplicative identity of the set TYPE.  */
1477
1478 tree
1479 build_one_cst (tree type)
1480 {
1481   switch (TREE_CODE (type))
1482     {
1483     case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1484     case POINTER_TYPE: case REFERENCE_TYPE:
1485     case OFFSET_TYPE:
1486       return build_int_cst (type, 1);
1487
1488     case REAL_TYPE:
1489       return build_real (type, dconst1);
1490
1491     case FIXED_POINT_TYPE:
1492       /* We can only generate 1 for accum types.  */
1493       gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1494       return build_fixed (type, FCONST1(TYPE_MODE (type)));
1495
1496     case VECTOR_TYPE:
1497       {
1498         tree scalar, cst;
1499         int i;
1500
1501         scalar = build_one_cst (TREE_TYPE (type));
1502
1503         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1504         cst = NULL_TREE;
1505         for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1506           cst = tree_cons (NULL_TREE, scalar, cst);
1507
1508         return build_vector (type, cst);
1509       }
1510
1511     case COMPLEX_TYPE:
1512       return build_complex (type,
1513                             build_one_cst (TREE_TYPE (type)),
1514                             fold_convert (TREE_TYPE (type), integer_zero_node));
1515
1516     default:
1517       gcc_unreachable ();
1518     }
1519 }
1520
1521 /* Build a BINFO with LEN language slots.  */
1522
1523 tree
1524 make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1525 {
1526   tree t;
1527   size_t length = (offsetof (struct tree_binfo, base_binfos)
1528                    + VEC_embedded_size (tree, base_binfos));
1529
1530 #ifdef GATHER_STATISTICS
1531   tree_node_counts[(int) binfo_kind]++;
1532   tree_node_sizes[(int) binfo_kind] += length;
1533 #endif
1534
1535   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1536
1537   memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1538
1539   TREE_SET_CODE (t, TREE_BINFO);
1540
1541   VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1542
1543   return t;
1544 }
1545
1546
1547 /* Build a newly constructed TREE_VEC node of length LEN.  */
1548
1549 tree
1550 make_tree_vec_stat (int len MEM_STAT_DECL)
1551 {
1552   tree t;
1553   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1554
1555 #ifdef GATHER_STATISTICS
1556   tree_node_counts[(int) vec_kind]++;
1557   tree_node_sizes[(int) vec_kind] += length;
1558 #endif
1559
1560   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1561
1562   memset (t, 0, length);
1563
1564   TREE_SET_CODE (t, TREE_VEC);
1565   TREE_VEC_LENGTH (t) = len;
1566
1567   return t;
1568 }
1569 \f
1570 /* Return 1 if EXPR is the integer constant zero or a complex constant
1571    of zero.  */
1572
1573 int
1574 integer_zerop (const_tree expr)
1575 {
1576   STRIP_NOPS (expr);
1577
1578   return ((TREE_CODE (expr) == INTEGER_CST
1579            && TREE_INT_CST_LOW (expr) == 0
1580            && TREE_INT_CST_HIGH (expr) == 0)
1581           || (TREE_CODE (expr) == COMPLEX_CST
1582               && integer_zerop (TREE_REALPART (expr))
1583               && integer_zerop (TREE_IMAGPART (expr))));
1584 }
1585
1586 /* Return 1 if EXPR is the integer constant one or the corresponding
1587    complex constant.  */
1588
1589 int
1590 integer_onep (const_tree expr)
1591 {
1592   STRIP_NOPS (expr);
1593
1594   return ((TREE_CODE (expr) == INTEGER_CST
1595            && TREE_INT_CST_LOW (expr) == 1
1596            && TREE_INT_CST_HIGH (expr) == 0)
1597           || (TREE_CODE (expr) == COMPLEX_CST
1598               && integer_onep (TREE_REALPART (expr))
1599               && integer_zerop (TREE_IMAGPART (expr))));
1600 }
1601
1602 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
1603    it contains.  Likewise for the corresponding complex constant.  */
1604
1605 int
1606 integer_all_onesp (const_tree expr)
1607 {
1608   int prec;
1609   int uns;
1610
1611   STRIP_NOPS (expr);
1612
1613   if (TREE_CODE (expr) == COMPLEX_CST
1614       && integer_all_onesp (TREE_REALPART (expr))
1615       && integer_zerop (TREE_IMAGPART (expr)))
1616     return 1;
1617
1618   else if (TREE_CODE (expr) != INTEGER_CST)
1619     return 0;
1620
1621   uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1622   if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1623       && TREE_INT_CST_HIGH (expr) == -1)
1624     return 1;
1625   if (!uns)
1626     return 0;
1627
1628   /* Note that using TYPE_PRECISION here is wrong.  We care about the
1629      actual bits, not the (arbitrary) range of the type.  */
1630   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1631   if (prec >= HOST_BITS_PER_WIDE_INT)
1632     {
1633       HOST_WIDE_INT high_value;
1634       int shift_amount;
1635
1636       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1637
1638       /* Can not handle precisions greater than twice the host int size.  */
1639       gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1640       if (shift_amount == HOST_BITS_PER_WIDE_INT)
1641         /* Shifting by the host word size is undefined according to the ANSI
1642            standard, so we must handle this as a special case.  */
1643         high_value = -1;
1644       else
1645         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1646
1647       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1648               && TREE_INT_CST_HIGH (expr) == high_value);
1649     }
1650   else
1651     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1652 }
1653
1654 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1655    one bit on).  */
1656
1657 int
1658 integer_pow2p (const_tree expr)
1659 {
1660   int prec;
1661   HOST_WIDE_INT high, low;
1662
1663   STRIP_NOPS (expr);
1664
1665   if (TREE_CODE (expr) == COMPLEX_CST
1666       && integer_pow2p (TREE_REALPART (expr))
1667       && integer_zerop (TREE_IMAGPART (expr)))
1668     return 1;
1669
1670   if (TREE_CODE (expr) != INTEGER_CST)
1671     return 0;
1672
1673   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1674           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1675   high = TREE_INT_CST_HIGH (expr);
1676   low = TREE_INT_CST_LOW (expr);
1677
1678   /* First clear all bits that are beyond the type's precision in case
1679      we've been sign extended.  */
1680
1681   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1682     ;
1683   else if (prec > HOST_BITS_PER_WIDE_INT)
1684     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1685   else
1686     {
1687       high = 0;
1688       if (prec < HOST_BITS_PER_WIDE_INT)
1689         low &= ~((HOST_WIDE_INT) (-1) << prec);
1690     }
1691
1692   if (high == 0 && low == 0)
1693     return 0;
1694
1695   return ((high == 0 && (low & (low - 1)) == 0)
1696           || (low == 0 && (high & (high - 1)) == 0));
1697 }
1698
1699 /* Return 1 if EXPR is an integer constant other than zero or a
1700    complex constant other than zero.  */
1701
1702 int
1703 integer_nonzerop (const_tree expr)
1704 {
1705   STRIP_NOPS (expr);
1706
1707   return ((TREE_CODE (expr) == INTEGER_CST
1708            && (TREE_INT_CST_LOW (expr) != 0
1709                || TREE_INT_CST_HIGH (expr) != 0))
1710           || (TREE_CODE (expr) == COMPLEX_CST
1711               && (integer_nonzerop (TREE_REALPART (expr))
1712                   || integer_nonzerop (TREE_IMAGPART (expr)))));
1713 }
1714
1715 /* Return 1 if EXPR is the fixed-point constant zero.  */
1716
1717 int
1718 fixed_zerop (const_tree expr)
1719 {
1720   return (TREE_CODE (expr) == FIXED_CST
1721           && double_int_zero_p (TREE_FIXED_CST (expr).data));
1722 }
1723
1724 /* Return the power of two represented by a tree node known to be a
1725    power of two.  */
1726
1727 int
1728 tree_log2 (const_tree expr)
1729 {
1730   int prec;
1731   HOST_WIDE_INT high, low;
1732
1733   STRIP_NOPS (expr);
1734
1735   if (TREE_CODE (expr) == COMPLEX_CST)
1736     return tree_log2 (TREE_REALPART (expr));
1737
1738   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1739           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1740
1741   high = TREE_INT_CST_HIGH (expr);
1742   low = TREE_INT_CST_LOW (expr);
1743
1744   /* First clear all bits that are beyond the type's precision in case
1745      we've been sign extended.  */
1746
1747   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1748     ;
1749   else if (prec > HOST_BITS_PER_WIDE_INT)
1750     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1751   else
1752     {
1753       high = 0;
1754       if (prec < HOST_BITS_PER_WIDE_INT)
1755         low &= ~((HOST_WIDE_INT) (-1) << prec);
1756     }
1757
1758   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1759           : exact_log2 (low));
1760 }
1761
1762 /* Similar, but return the largest integer Y such that 2 ** Y is less
1763    than or equal to EXPR.  */
1764
1765 int
1766 tree_floor_log2 (const_tree expr)
1767 {
1768   int prec;
1769   HOST_WIDE_INT high, low;
1770
1771   STRIP_NOPS (expr);
1772
1773   if (TREE_CODE (expr) == COMPLEX_CST)
1774     return tree_log2 (TREE_REALPART (expr));
1775
1776   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
1777           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
1778
1779   high = TREE_INT_CST_HIGH (expr);
1780   low = TREE_INT_CST_LOW (expr);
1781
1782   /* First clear all bits that are beyond the type's precision in case
1783      we've been sign extended.  Ignore if type's precision hasn't been set
1784      since what we are doing is setting it.  */
1785
1786   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1787     ;
1788   else if (prec > HOST_BITS_PER_WIDE_INT)
1789     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1790   else
1791     {
1792       high = 0;
1793       if (prec < HOST_BITS_PER_WIDE_INT)
1794         low &= ~((HOST_WIDE_INT) (-1) << prec);
1795     }
1796
1797   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1798           : floor_log2 (low));
1799 }
1800
1801 /* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1802    decimal float constants, so don't return 1 for them.  */
1803
1804 int
1805 real_zerop (const_tree expr)
1806 {
1807   STRIP_NOPS (expr);
1808
1809   return ((TREE_CODE (expr) == REAL_CST
1810            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1811            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1812           || (TREE_CODE (expr) == COMPLEX_CST
1813               && real_zerop (TREE_REALPART (expr))
1814               && real_zerop (TREE_IMAGPART (expr))));
1815 }
1816
1817 /* Return 1 if EXPR is the real constant one in real or complex form.
1818    Trailing zeroes matter for decimal float constants, so don't return
1819    1 for them.  */
1820
1821 int
1822 real_onep (const_tree expr)
1823 {
1824   STRIP_NOPS (expr);
1825
1826   return ((TREE_CODE (expr) == REAL_CST
1827            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1828            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1829           || (TREE_CODE (expr) == COMPLEX_CST
1830               && real_onep (TREE_REALPART (expr))
1831               && real_zerop (TREE_IMAGPART (expr))));
1832 }
1833
1834 /* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1835    for decimal float constants, so don't return 1 for them.  */
1836
1837 int
1838 real_twop (const_tree expr)
1839 {
1840   STRIP_NOPS (expr);
1841
1842   return ((TREE_CODE (expr) == REAL_CST
1843            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1844            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1845           || (TREE_CODE (expr) == COMPLEX_CST
1846               && real_twop (TREE_REALPART (expr))
1847               && real_zerop (TREE_IMAGPART (expr))));
1848 }
1849
1850 /* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1851    matter for decimal float constants, so don't return 1 for them.  */
1852
1853 int
1854 real_minus_onep (const_tree expr)
1855 {
1856   STRIP_NOPS (expr);
1857
1858   return ((TREE_CODE (expr) == REAL_CST
1859            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1860            && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1861           || (TREE_CODE (expr) == COMPLEX_CST
1862               && real_minus_onep (TREE_REALPART (expr))
1863               && real_zerop (TREE_IMAGPART (expr))));
1864 }
1865
1866 /* Nonzero if EXP is a constant or a cast of a constant.  */
1867
1868 int
1869 really_constant_p (const_tree exp)
1870 {
1871   /* This is not quite the same as STRIP_NOPS.  It does more.  */
1872   while (CONVERT_EXPR_P (exp)
1873          || TREE_CODE (exp) == NON_LVALUE_EXPR)
1874     exp = TREE_OPERAND (exp, 0);
1875   return TREE_CONSTANT (exp);
1876 }
1877 \f
1878 /* Return first list element whose TREE_VALUE is ELEM.
1879    Return 0 if ELEM is not in LIST.  */
1880
1881 tree
1882 value_member (tree elem, tree list)
1883 {
1884   while (list)
1885     {
1886       if (elem == TREE_VALUE (list))
1887         return list;
1888       list = TREE_CHAIN (list);
1889     }
1890   return NULL_TREE;
1891 }
1892
1893 /* Return first list element whose TREE_PURPOSE is ELEM.
1894    Return 0 if ELEM is not in LIST.  */
1895
1896 tree
1897 purpose_member (const_tree elem, tree list)
1898 {
1899   while (list)
1900     {
1901       if (elem == TREE_PURPOSE (list))
1902         return list;
1903       list = TREE_CHAIN (list);
1904     }
1905   return NULL_TREE;
1906 }
1907
1908 /* Return nonzero if ELEM is part of the chain CHAIN.  */
1909
1910 int
1911 chain_member (const_tree elem, const_tree chain)
1912 {
1913   while (chain)
1914     {
1915       if (elem == chain)
1916         return 1;
1917       chain = TREE_CHAIN (chain);
1918     }
1919
1920   return 0;
1921 }
1922
1923 /* Return the length of a chain of nodes chained through TREE_CHAIN.
1924    We expect a null pointer to mark the end of the chain.
1925    This is the Lisp primitive `length'.  */
1926
1927 int
1928 list_length (const_tree t)
1929 {
1930   const_tree p = t;
1931 #ifdef ENABLE_TREE_CHECKING
1932   const_tree q = t;
1933 #endif
1934   int len = 0;
1935
1936   while (p)
1937     {
1938       p = TREE_CHAIN (p);
1939 #ifdef ENABLE_TREE_CHECKING
1940       if (len % 2)
1941         q = TREE_CHAIN (q);
1942       gcc_assert (p != q);
1943 #endif
1944       len++;
1945     }
1946
1947   return len;
1948 }
1949
1950 /* Returns the number of FIELD_DECLs in TYPE.  */
1951
1952 int
1953 fields_length (const_tree type)
1954 {
1955   tree t = TYPE_FIELDS (type);
1956   int count = 0;
1957
1958   for (; t; t = TREE_CHAIN (t))
1959     if (TREE_CODE (t) == FIELD_DECL)
1960       ++count;
1961
1962   return count;
1963 }
1964
1965 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1966    by modifying the last node in chain 1 to point to chain 2.
1967    This is the Lisp primitive `nconc'.  */
1968
1969 tree
1970 chainon (tree op1, tree op2)
1971 {
1972   tree t1;
1973
1974   if (!op1)
1975     return op2;
1976   if (!op2)
1977     return op1;
1978
1979   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1980     continue;
1981   TREE_CHAIN (t1) = op2;
1982
1983 #ifdef ENABLE_TREE_CHECKING
1984   {
1985     tree t2;
1986     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1987       gcc_assert (t2 != t1);
1988   }
1989 #endif
1990
1991   return op1;
1992 }
1993
1994 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
1995
1996 tree
1997 tree_last (tree chain)
1998 {
1999   tree next;
2000   if (chain)
2001     while ((next = TREE_CHAIN (chain)))
2002       chain = next;
2003   return chain;
2004 }
2005
2006 /* Reverse the order of elements in the chain T,
2007    and return the new head of the chain (old last element).  */
2008
2009 tree
2010 nreverse (tree t)
2011 {
2012   tree prev = 0, decl, next;
2013   for (decl = t; decl; decl = next)
2014     {
2015       next = TREE_CHAIN (decl);
2016       TREE_CHAIN (decl) = prev;
2017       prev = decl;
2018     }
2019   return prev;
2020 }
2021 \f
2022 /* Return a newly created TREE_LIST node whose
2023    purpose and value fields are PARM and VALUE.  */
2024
2025 tree
2026 build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2027 {
2028   tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2029   TREE_PURPOSE (t) = parm;
2030   TREE_VALUE (t) = value;
2031   return t;
2032 }
2033
2034 /* Build a chain of TREE_LIST nodes from a vector.  */
2035
2036 tree
2037 build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2038 {
2039   tree ret = NULL_TREE;
2040   tree *pp = &ret;
2041   unsigned int i;
2042   tree t;
2043   for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
2044     {
2045       *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2046       pp = &TREE_CHAIN (*pp);
2047     }
2048   return ret;
2049 }
2050
2051 /* Return a newly created TREE_LIST node whose
2052    purpose and value fields are PURPOSE and VALUE
2053    and whose TREE_CHAIN is CHAIN.  */
2054
2055 tree
2056 tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2057 {
2058   tree node;
2059
2060   node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
2061
2062   memset (node, 0, sizeof (struct tree_common));
2063
2064 #ifdef GATHER_STATISTICS
2065   tree_node_counts[(int) x_kind]++;
2066   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2067 #endif
2068
2069   TREE_SET_CODE (node, TREE_LIST);
2070   TREE_CHAIN (node) = chain;
2071   TREE_PURPOSE (node) = purpose;
2072   TREE_VALUE (node) = value;
2073   return node;
2074 }
2075
2076 /* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
2077
2078 tree
2079 ctor_to_list (tree ctor)
2080 {
2081   tree list = NULL_TREE;
2082   tree *p = &list;
2083   unsigned ix;
2084   tree purpose, val;
2085
2086   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
2087     {
2088       *p = build_tree_list (purpose, val);
2089       p = &TREE_CHAIN (*p);
2090     }
2091
2092   return list;
2093 }
2094
2095 /* Return the values of the elements of a CONSTRUCTOR as a vector of
2096    trees.  */
2097
2098 VEC(tree,gc) *
2099 ctor_to_vec (tree ctor)
2100 {
2101   VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2102   unsigned int ix;
2103   tree val;
2104
2105   FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2106     VEC_quick_push (tree, vec, val);
2107
2108   return vec;
2109 }
2110 \f
2111 /* Return the size nominally occupied by an object of type TYPE
2112    when it resides in memory.  The value is measured in units of bytes,
2113    and its data type is that normally used for type sizes
2114    (which is the first type created by make_signed_type or
2115    make_unsigned_type).  */
2116
2117 tree
2118 size_in_bytes (const_tree type)
2119 {
2120   tree t;
2121
2122   if (type == error_mark_node)
2123     return integer_zero_node;
2124
2125   type = TYPE_MAIN_VARIANT (type);
2126   t = TYPE_SIZE_UNIT (type);
2127
2128   if (t == 0)
2129     {
2130       lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2131       return size_zero_node;
2132     }
2133
2134   return t;
2135 }
2136
2137 /* Return the size of TYPE (in bytes) as a wide integer
2138    or return -1 if the size can vary or is larger than an integer.  */
2139
2140 HOST_WIDE_INT
2141 int_size_in_bytes (const_tree type)
2142 {
2143   tree t;
2144
2145   if (type == error_mark_node)
2146     return 0;
2147
2148   type = TYPE_MAIN_VARIANT (type);
2149   t = TYPE_SIZE_UNIT (type);
2150   if (t == 0
2151       || TREE_CODE (t) != INTEGER_CST
2152       || TREE_INT_CST_HIGH (t) != 0
2153       /* If the result would appear negative, it's too big to represent.  */
2154       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2155     return -1;
2156
2157   return TREE_INT_CST_LOW (t);
2158 }
2159
2160 /* Return the maximum size of TYPE (in bytes) as a wide integer
2161    or return -1 if the size can vary or is larger than an integer.  */
2162
2163 HOST_WIDE_INT
2164 max_int_size_in_bytes (const_tree type)
2165 {
2166   HOST_WIDE_INT size = -1;
2167   tree size_tree;
2168
2169   /* If this is an array type, check for a possible MAX_SIZE attached.  */
2170
2171   if (TREE_CODE (type) == ARRAY_TYPE)
2172     {
2173       size_tree = TYPE_ARRAY_MAX_SIZE (type);
2174
2175       if (size_tree && host_integerp (size_tree, 1))
2176         size = tree_low_cst (size_tree, 1);
2177     }
2178
2179   /* If we still haven't been able to get a size, see if the language
2180      can compute a maximum size.  */
2181
2182   if (size == -1)
2183     {
2184       size_tree = lang_hooks.types.max_size (type);
2185
2186       if (size_tree && host_integerp (size_tree, 1))
2187         size = tree_low_cst (size_tree, 1);
2188     }
2189
2190   return size;
2191 }
2192
2193 /* Returns a tree for the size of EXP in bytes.  */
2194
2195 tree
2196 tree_expr_size (const_tree exp)
2197 {
2198   if (DECL_P (exp)
2199       && DECL_SIZE_UNIT (exp) != 0)
2200     return DECL_SIZE_UNIT (exp);
2201   else
2202     return size_in_bytes (TREE_TYPE (exp));
2203 }
2204 \f
2205 /* Return the bit position of FIELD, in bits from the start of the record.
2206    This is a tree of type bitsizetype.  */
2207
2208 tree
2209 bit_position (const_tree field)
2210 {
2211   return bit_from_pos (DECL_FIELD_OFFSET (field),
2212                        DECL_FIELD_BIT_OFFSET (field));
2213 }
2214
2215 /* Likewise, but return as an integer.  It must be representable in
2216    that way (since it could be a signed value, we don't have the
2217    option of returning -1 like int_size_in_byte can.  */
2218
2219 HOST_WIDE_INT
2220 int_bit_position (const_tree field)
2221 {
2222   return tree_low_cst (bit_position (field), 0);
2223 }
2224 \f
2225 /* Return the byte position of FIELD, in bytes from the start of the record.
2226    This is a tree of type sizetype.  */
2227
2228 tree
2229 byte_position (const_tree field)
2230 {
2231   return byte_from_pos (DECL_FIELD_OFFSET (field),
2232                         DECL_FIELD_BIT_OFFSET (field));
2233 }
2234
2235 /* Likewise, but return as an integer.  It must be representable in
2236    that way (since it could be a signed value, we don't have the
2237    option of returning -1 like int_size_in_byte can.  */
2238
2239 HOST_WIDE_INT
2240 int_byte_position (const_tree field)
2241 {
2242   return tree_low_cst (byte_position (field), 0);
2243 }
2244 \f
2245 /* Return the strictest alignment, in bits, that T is known to have.  */
2246
2247 unsigned int
2248 expr_align (const_tree t)
2249 {
2250   unsigned int align0, align1;
2251
2252   switch (TREE_CODE (t))
2253     {
2254     CASE_CONVERT:  case NON_LVALUE_EXPR:
2255       /* If we have conversions, we know that the alignment of the
2256          object must meet each of the alignments of the types.  */
2257       align0 = expr_align (TREE_OPERAND (t, 0));
2258       align1 = TYPE_ALIGN (TREE_TYPE (t));
2259       return MAX (align0, align1);
2260
2261     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2262     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2263     case CLEANUP_POINT_EXPR:
2264       /* These don't change the alignment of an object.  */
2265       return expr_align (TREE_OPERAND (t, 0));
2266
2267     case COND_EXPR:
2268       /* The best we can do is say that the alignment is the least aligned
2269          of the two arms.  */
2270       align0 = expr_align (TREE_OPERAND (t, 1));
2271       align1 = expr_align (TREE_OPERAND (t, 2));
2272       return MIN (align0, align1);
2273
2274       /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2275          meaningfully, it's always 1.  */
2276     case LABEL_DECL:     case CONST_DECL:
2277     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2278     case FUNCTION_DECL:
2279       gcc_assert (DECL_ALIGN (t) != 0);
2280       return DECL_ALIGN (t);
2281
2282     default:
2283       break;
2284     }
2285
2286   /* Otherwise take the alignment from that of the type.  */
2287   return TYPE_ALIGN (TREE_TYPE (t));
2288 }
2289 \f
2290 /* Return, as a tree node, the number of elements for TYPE (which is an
2291    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2292
2293 tree
2294 array_type_nelts (const_tree type)
2295 {
2296   tree index_type, min, max;
2297
2298   /* If they did it with unspecified bounds, then we should have already
2299      given an error about it before we got here.  */
2300   if (! TYPE_DOMAIN (type))
2301     return error_mark_node;
2302
2303   index_type = TYPE_DOMAIN (type);
2304   min = TYPE_MIN_VALUE (index_type);
2305   max = TYPE_MAX_VALUE (index_type);
2306
2307   return (integer_zerop (min)
2308           ? max
2309           : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2310 }
2311 \f
2312 /* If arg is static -- a reference to an object in static storage -- then
2313    return the object.  This is not the same as the C meaning of `static'.
2314    If arg isn't static, return NULL.  */
2315
2316 tree
2317 staticp (tree arg)
2318 {
2319   switch (TREE_CODE (arg))
2320     {
2321     case FUNCTION_DECL:
2322       /* Nested functions are static, even though taking their address will
2323          involve a trampoline as we unnest the nested function and create
2324          the trampoline on the tree level.  */
2325       return arg;
2326
2327     case VAR_DECL:
2328       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2329               && ! DECL_THREAD_LOCAL_P (arg)
2330               && ! DECL_DLLIMPORT_P (arg)
2331               ? arg : NULL);
2332
2333     case CONST_DECL:
2334       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2335               ? arg : NULL);
2336
2337     case CONSTRUCTOR:
2338       return TREE_STATIC (arg) ? arg : NULL;
2339
2340     case LABEL_DECL:
2341     case STRING_CST:
2342       return arg;
2343
2344     case COMPONENT_REF:
2345       /* If the thing being referenced is not a field, then it is
2346          something language specific.  */
2347       gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2348
2349       /* If we are referencing a bitfield, we can't evaluate an
2350          ADDR_EXPR at compile time and so it isn't a constant.  */
2351       if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2352         return NULL;
2353
2354       return staticp (TREE_OPERAND (arg, 0));
2355
2356     case BIT_FIELD_REF:
2357       return NULL;
2358
2359     case MISALIGNED_INDIRECT_REF:
2360     case ALIGN_INDIRECT_REF:
2361     case INDIRECT_REF:
2362       return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2363
2364     case ARRAY_REF:
2365     case ARRAY_RANGE_REF:
2366       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2367           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2368         return staticp (TREE_OPERAND (arg, 0));
2369       else
2370         return NULL;
2371
2372     case COMPOUND_LITERAL_EXPR:
2373       return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2374
2375     default:
2376       return NULL;
2377     }
2378 }
2379
2380 \f
2381
2382
2383 /* Return whether OP is a DECL whose address is function-invariant.  */
2384
2385 bool
2386 decl_address_invariant_p (const_tree op)
2387 {
2388   /* The conditions below are slightly less strict than the one in
2389      staticp.  */
2390
2391   switch (TREE_CODE (op))
2392     {
2393     case PARM_DECL:
2394     case RESULT_DECL:
2395     case LABEL_DECL:
2396     case FUNCTION_DECL:
2397       return true;
2398
2399     case VAR_DECL:
2400       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2401            && !DECL_DLLIMPORT_P (op))
2402           || DECL_THREAD_LOCAL_P (op)
2403           || DECL_CONTEXT (op) == current_function_decl
2404           || decl_function_context (op) == current_function_decl)
2405         return true;
2406       break;
2407
2408     case CONST_DECL:
2409       if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2410           || decl_function_context (op) == current_function_decl)
2411         return true;
2412       break;
2413
2414     default:
2415       break;
2416     }
2417
2418   return false;
2419 }
2420
2421 /* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2422
2423 bool
2424 decl_address_ip_invariant_p (const_tree op)
2425 {
2426   /* The conditions below are slightly less strict than the one in
2427      staticp.  */
2428
2429   switch (TREE_CODE (op))
2430     {
2431     case LABEL_DECL:
2432     case FUNCTION_DECL:
2433     case STRING_CST:
2434       return true;
2435
2436     case VAR_DECL:
2437       if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2438            && !DECL_DLLIMPORT_P (op))
2439           || DECL_THREAD_LOCAL_P (op))
2440         return true;
2441       break;
2442
2443     case CONST_DECL:
2444       if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2445         return true;
2446       break;
2447
2448     default:
2449       break;
2450     }
2451
2452   return false;
2453 }
2454
2455
2456 /* Return true if T is function-invariant (internal function, does
2457    not handle arithmetic; that's handled in skip_simple_arithmetic and
2458    tree_invariant_p).  */
2459
2460 static bool tree_invariant_p (tree t);
2461
2462 static bool
2463 tree_invariant_p_1 (tree t)
2464 {
2465   tree op;
2466
2467   if (TREE_CONSTANT (t)
2468       || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2469     return true;
2470
2471   switch (TREE_CODE (t))
2472     {
2473     case SAVE_EXPR:
2474       return true;
2475
2476     case ADDR_EXPR:
2477       op = TREE_OPERAND (t, 0);
2478       while (handled_component_p (op))
2479         {
2480           switch (TREE_CODE (op))
2481             {
2482             case ARRAY_REF:
2483             case ARRAY_RANGE_REF:
2484               if (!tree_invariant_p (TREE_OPERAND (op, 1))
2485                   || TREE_OPERAND (op, 2) != NULL_TREE
2486                   || TREE_OPERAND (op, 3) != NULL_TREE)
2487                 return false;
2488               break;
2489
2490             case COMPONENT_REF:
2491               if (TREE_OPERAND (op, 2) != NULL_TREE)
2492                 return false;
2493               break;
2494
2495             default:;
2496             }
2497           op = TREE_OPERAND (op, 0);
2498         }
2499
2500       return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2501
2502     default:
2503       break;
2504     }
2505
2506   return false;
2507 }
2508
2509 /* Return true if T is function-invariant.  */
2510
2511 static bool
2512 tree_invariant_p (tree t)
2513 {
2514   tree inner = skip_simple_arithmetic (t);
2515   return tree_invariant_p_1 (inner);
2516 }
2517
2518 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
2519    Do this to any expression which may be used in more than one place,
2520    but must be evaluated only once.
2521
2522    Normally, expand_expr would reevaluate the expression each time.
2523    Calling save_expr produces something that is evaluated and recorded
2524    the first time expand_expr is called on it.  Subsequent calls to
2525    expand_expr just reuse the recorded value.
2526
2527    The call to expand_expr that generates code that actually computes
2528    the value is the first call *at compile time*.  Subsequent calls
2529    *at compile time* generate code to use the saved value.
2530    This produces correct result provided that *at run time* control
2531    always flows through the insns made by the first expand_expr
2532    before reaching the other places where the save_expr was evaluated.
2533    You, the caller of save_expr, must make sure this is so.
2534
2535    Constants, and certain read-only nodes, are returned with no
2536    SAVE_EXPR because that is safe.  Expressions containing placeholders
2537    are not touched; see tree.def for an explanation of what these
2538    are used for.  */
2539
2540 tree
2541 save_expr (tree expr)
2542 {
2543   tree t = fold (expr);
2544   tree inner;
2545
2546   /* If the tree evaluates to a constant, then we don't want to hide that
2547      fact (i.e. this allows further folding, and direct checks for constants).
2548      However, a read-only object that has side effects cannot be bypassed.
2549      Since it is no problem to reevaluate literals, we just return the
2550      literal node.  */
2551   inner = skip_simple_arithmetic (t);
2552   if (TREE_CODE (inner) == ERROR_MARK)
2553     return inner;
2554
2555   if (tree_invariant_p_1 (inner))
2556     return t;
2557
2558   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2559      it means that the size or offset of some field of an object depends on
2560      the value within another field.
2561
2562      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2563      and some variable since it would then need to be both evaluated once and
2564      evaluated more than once.  Front-ends must assure this case cannot
2565      happen by surrounding any such subexpressions in their own SAVE_EXPR
2566      and forcing evaluation at the proper time.  */
2567   if (contains_placeholder_p (inner))
2568     return t;
2569
2570   t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2571   SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2572
2573   /* This expression might be placed ahead of a jump to ensure that the
2574      value was computed on both sides of the jump.  So make sure it isn't
2575      eliminated as dead.  */
2576   TREE_SIDE_EFFECTS (t) = 1;
2577   return t;
2578 }
2579
2580 /* Look inside EXPR and into any simple arithmetic operations.  Return
2581    the innermost non-arithmetic node.  */
2582
2583 tree
2584 skip_simple_arithmetic (tree expr)
2585 {
2586   tree inner;
2587
2588   /* We don't care about whether this can be used as an lvalue in this
2589      context.  */
2590   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2591     expr = TREE_OPERAND (expr, 0);
2592
2593   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2594      a constant, it will be more efficient to not make another SAVE_EXPR since
2595      it will allow better simplification and GCSE will be able to merge the
2596      computations if they actually occur.  */
2597   inner = expr;
2598   while (1)
2599     {
2600       if (UNARY_CLASS_P (inner))
2601         inner = TREE_OPERAND (inner, 0);
2602       else if (BINARY_CLASS_P (inner))
2603         {
2604           if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2605             inner = TREE_OPERAND (inner, 0);
2606           else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2607             inner = TREE_OPERAND (inner, 1);
2608           else
2609             break;
2610         }
2611       else
2612         break;
2613     }
2614
2615   return inner;
2616 }
2617
2618
2619 /* Return which tree structure is used by T.  */
2620
2621 enum tree_node_structure_enum
2622 tree_node_structure (const_tree t)
2623 {
2624   const enum tree_code code = TREE_CODE (t);
2625   return tree_node_structure_for_code (code);
2626 }
2627
2628 /* Set various status flags when building a CALL_EXPR object T.  */
2629
2630 static void
2631 process_call_operands (tree t)
2632 {
2633   bool side_effects = TREE_SIDE_EFFECTS (t);
2634   bool read_only = false;
2635   int i = call_expr_flags (t);
2636
2637   /* Calls have side-effects, except those to const or pure functions.  */
2638   if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2639     side_effects = true;
2640   /* Propagate TREE_READONLY of arguments for const functions.  */
2641   if (i & ECF_CONST)
2642     read_only = true;
2643
2644   if (!side_effects || read_only)
2645     for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2646       {
2647         tree op = TREE_OPERAND (t, i);
2648         if (op && TREE_SIDE_EFFECTS (op))
2649           side_effects = true;
2650         if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2651           read_only = false;
2652       }
2653
2654   TREE_SIDE_EFFECTS (t) = side_effects;
2655   TREE_READONLY (t) = read_only;
2656 }
2657 \f
2658 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2659    or offset that depends on a field within a record.  */
2660
2661 bool
2662 contains_placeholder_p (const_tree exp)
2663 {
2664   enum tree_code code;
2665
2666   if (!exp)
2667     return 0;
2668
2669   code = TREE_CODE (exp);
2670   if (code == PLACEHOLDER_EXPR)
2671     return 1;
2672
2673   switch (TREE_CODE_CLASS (code))
2674     {
2675     case tcc_reference:
2676       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2677          position computations since they will be converted into a
2678          WITH_RECORD_EXPR involving the reference, which will assume
2679          here will be valid.  */
2680       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2681
2682     case tcc_exceptional:
2683       if (code == TREE_LIST)
2684         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2685                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2686       break;
2687
2688     case tcc_unary:
2689     case tcc_binary:
2690     case tcc_comparison:
2691     case tcc_expression:
2692       switch (code)
2693         {
2694         case COMPOUND_EXPR:
2695           /* Ignoring the first operand isn't quite right, but works best.  */
2696           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2697
2698         case COND_EXPR:
2699           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2700                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2701                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2702
2703         case SAVE_EXPR:
2704           /* The save_expr function never wraps anything containing
2705              a PLACEHOLDER_EXPR. */
2706           return 0;
2707
2708         default:
2709           break;
2710         }
2711
2712       switch (TREE_CODE_LENGTH (code))
2713         {
2714         case 1:
2715           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2716         case 2:
2717           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2718                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2719         default:
2720           return 0;
2721         }
2722
2723     case tcc_vl_exp:
2724       switch (code)
2725         {
2726         case CALL_EXPR:
2727           {
2728             const_tree arg;
2729             const_call_expr_arg_iterator iter;
2730             FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2731               if (CONTAINS_PLACEHOLDER_P (arg))
2732                 return 1;
2733             return 0;
2734           }
2735         default:
2736           return 0;
2737         }
2738
2739     default:
2740       return 0;
2741     }
2742   return 0;
2743 }
2744
2745 /* Return true if any part of the computation of TYPE involves a
2746    PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2747    (for QUAL_UNION_TYPE) and field positions.  */
2748
2749 static bool
2750 type_contains_placeholder_1 (const_tree type)
2751 {
2752   /* If the size contains a placeholder or the parent type (component type in
2753      the case of arrays) type involves a placeholder, this type does.  */
2754   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2755       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2756       || (TREE_TYPE (type) != 0
2757           && type_contains_placeholder_p (TREE_TYPE (type))))
2758     return true;
2759
2760   /* Now do type-specific checks.  Note that the last part of the check above
2761      greatly limits what we have to do below.  */
2762   switch (TREE_CODE (type))
2763     {
2764     case VOID_TYPE:
2765     case COMPLEX_TYPE:
2766     case ENUMERAL_TYPE:
2767     case BOOLEAN_TYPE:
2768     case POINTER_TYPE:
2769     case OFFSET_TYPE:
2770     case REFERENCE_TYPE:
2771     case METHOD_TYPE:
2772     case FUNCTION_TYPE:
2773     case VECTOR_TYPE:
2774       return false;
2775
2776     case INTEGER_TYPE:
2777     case REAL_TYPE:
2778     case FIXED_POINT_TYPE:
2779       /* Here we just check the bounds.  */
2780       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2781               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2782
2783     case ARRAY_TYPE:
2784       /* We're already checked the component type (TREE_TYPE), so just check
2785          the index type.  */
2786       return type_contains_placeholder_p (TYPE_DOMAIN (type));
2787
2788     case RECORD_TYPE:
2789     case UNION_TYPE:
2790     case QUAL_UNION_TYPE:
2791       {
2792         tree field;
2793
2794         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2795           if (TREE_CODE (field) == FIELD_DECL
2796               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2797                   || (TREE_CODE (type) == QUAL_UNION_TYPE
2798                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2799                   || type_contains_placeholder_p (TREE_TYPE (field))))
2800             return true;
2801
2802         return false;
2803       }
2804
2805     default:
2806       gcc_unreachable ();
2807     }
2808 }
2809
2810 bool
2811 type_contains_placeholder_p (tree type)
2812 {
2813   bool result;
2814
2815   /* If the contains_placeholder_bits field has been initialized,
2816      then we know the answer.  */
2817   if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2818     return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2819
2820   /* Indicate that we've seen this type node, and the answer is false.
2821      This is what we want to return if we run into recursion via fields.  */
2822   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2823
2824   /* Compute the real value.  */
2825   result = type_contains_placeholder_1 (type);
2826
2827   /* Store the real value.  */
2828   TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2829
2830   return result;
2831 }
2832 \f
2833 /* Push tree EXP onto vector QUEUE if it is not already present.  */
2834
2835 static void
2836 push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2837 {
2838   unsigned int i;
2839   tree iter;
2840
2841   for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
2842     if (simple_cst_equal (iter, exp) == 1)
2843       break;
2844
2845   if (!iter)
2846     VEC_safe_push (tree, heap, *queue, exp);
2847 }
2848
2849 /* Given a tree EXP, find all occurences of references to fields
2850    in a PLACEHOLDER_EXPR and place them in vector REFS without
2851    duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2852    we assume here that EXP contains only arithmetic expressions
2853    or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2854    argument list.  */
2855
2856 void
2857 find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2858 {
2859   enum tree_code code = TREE_CODE (exp);
2860   tree inner;
2861   int i;
2862
2863   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2864   if (code == TREE_LIST)
2865     {
2866       FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2867       FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2868     }
2869   else if (code == COMPONENT_REF)
2870     {
2871       for (inner = TREE_OPERAND (exp, 0);
2872            REFERENCE_CLASS_P (inner);
2873            inner = TREE_OPERAND (inner, 0))
2874         ;
2875
2876       if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2877         push_without_duplicates (exp, refs);
2878       else
2879         FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2880    }
2881   else
2882     switch (TREE_CODE_CLASS (code))
2883       {
2884       case tcc_constant:
2885         break;
2886
2887       case tcc_declaration:
2888         /* Variables allocated to static storage can stay.  */
2889         if (!TREE_STATIC (exp))
2890           push_without_duplicates (exp, refs);
2891         break;
2892
2893       case tcc_expression:
2894         /* This is the pattern built in ada/make_aligning_type.  */
2895         if (code == ADDR_EXPR
2896             && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2897           {
2898             push_without_duplicates (exp, refs);
2899             break;
2900           }
2901
2902         /* Fall through...  */
2903
2904       case tcc_exceptional:
2905       case tcc_unary:
2906       case tcc_binary:
2907       case tcc_comparison:
2908       case tcc_reference:
2909         for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2910           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2911         break;
2912
2913       case tcc_vl_exp:
2914         for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2915           FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2916         break;
2917
2918       default:
2919         gcc_unreachable ();
2920       }
2921 }
2922
2923 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2924    return a tree with all occurrences of references to F in a
2925    PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
2926    CONST_DECLs.  Note that we assume here that EXP contains only
2927    arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
2928    occurring only in their argument list.  */
2929
2930 tree
2931 substitute_in_expr (tree exp, tree f, tree r)
2932 {
2933   enum tree_code code = TREE_CODE (exp);
2934   tree op0, op1, op2, op3;
2935   tree new_tree;
2936
2937   /* We handle TREE_LIST and COMPONENT_REF separately.  */
2938   if (code == TREE_LIST)
2939     {
2940       op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2941       op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2942       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2943         return exp;
2944
2945       return tree_cons (TREE_PURPOSE (exp), op1, op0);
2946     }
2947   else if (code == COMPONENT_REF)
2948     {
2949       tree inner;
2950
2951       /* If this expression is getting a value from a PLACEHOLDER_EXPR
2952          and it is the right field, replace it with R.  */
2953       for (inner = TREE_OPERAND (exp, 0);
2954            REFERENCE_CLASS_P (inner);
2955            inner = TREE_OPERAND (inner, 0))
2956         ;
2957
2958       /* The field.  */
2959       op1 = TREE_OPERAND (exp, 1);
2960
2961       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
2962         return r;
2963
2964       /* If this expression hasn't been completed let, leave it alone.  */
2965       if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
2966         return exp;
2967
2968       op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
2969       if (op0 == TREE_OPERAND (exp, 0))
2970         return exp;
2971
2972       new_tree
2973         = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
2974    }
2975   else
2976     switch (TREE_CODE_CLASS (code))
2977       {
2978       case tcc_constant:
2979         return exp;
2980
2981       case tcc_declaration:
2982         if (exp == f)
2983           return r;
2984         else
2985           return exp;
2986
2987       case tcc_expression:
2988         if (exp == f)
2989           return r;
2990
2991         /* Fall through...  */
2992
2993       case tcc_exceptional:
2994       case tcc_unary:
2995       case tcc_binary:
2996       case tcc_comparison:
2997       case tcc_reference:
2998         switch (TREE_CODE_LENGTH (code))
2999           {
3000           case 0:
3001             return exp;
3002
3003           case 1:
3004             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3005             if (op0 == TREE_OPERAND (exp, 0))
3006               return exp;
3007
3008             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3009             break;
3010
3011           case 2:
3012             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3013             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3014
3015             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3016               return exp;
3017
3018             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3019             break;
3020
3021           case 3:
3022             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3023             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3024             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3025
3026             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3027                 && op2 == TREE_OPERAND (exp, 2))
3028               return exp;
3029
3030             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3031             break;
3032
3033           case 4:
3034             op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3035             op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3036             op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3037             op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3038
3039             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3040                 && op2 == TREE_OPERAND (exp, 2)
3041                 && op3 == TREE_OPERAND (exp, 3))
3042               return exp;
3043
3044             new_tree
3045               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3046             break;
3047
3048           default:
3049             gcc_unreachable ();
3050           }
3051         break;
3052
3053       case tcc_vl_exp:
3054         {
3055           int i;
3056
3057           new_tree = NULL_TREE;
3058
3059           /* If we are trying to replace F with a constant, inline back
3060              functions which do nothing else than computing a value from
3061              the arguments they are passed.  This makes it possible to
3062              fold partially or entirely the replacement expression.  */
3063           if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3064             {
3065               tree t = maybe_inline_call_in_expr (exp);
3066               if (t)
3067                 return SUBSTITUTE_IN_EXPR (t, f, r);
3068             }
3069
3070           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3071             {
3072               tree op = TREE_OPERAND (exp, i);
3073               tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3074               if (new_op != op)
3075                 {
3076                   if (!new_tree)
3077                     new_tree = copy_node (exp);
3078                   TREE_OPERAND (new_tree, i) = new_op;
3079                 }
3080             }
3081
3082           if (new_tree)
3083             {
3084               new_tree = fold (new_tree);
3085               if (TREE_CODE (new_tree) == CALL_EXPR)
3086                 process_call_operands (new_tree);
3087             }
3088           else
3089             return exp;
3090         }
3091         break;
3092
3093       default:
3094         gcc_unreachable ();
3095       }
3096
3097   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3098   return new_tree;
3099 }
3100
3101 /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3102    for it within OBJ, a tree that is an object or a chain of references.  */
3103
3104 tree
3105 substitute_placeholder_in_expr (tree exp, tree obj)
3106 {
3107   enum tree_code code = TREE_CODE (exp);
3108   tree op0, op1, op2, op3;
3109   tree new_tree;
3110
3111   /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3112      in the chain of OBJ.  */
3113   if (code == PLACEHOLDER_EXPR)
3114     {
3115       tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3116       tree elt;
3117
3118       for (elt = obj; elt != 0;
3119            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3120                    || TREE_CODE (elt) == COND_EXPR)
3121                   ? TREE_OPERAND (elt, 1)
3122                   : (REFERENCE_CLASS_P (elt)
3123                      || UNARY_CLASS_P (elt)
3124                      || BINARY_CLASS_P (elt)
3125                      || VL_EXP_CLASS_P (elt)
3126                      || EXPRESSION_CLASS_P (elt))
3127                   ? TREE_OPERAND (elt, 0) : 0))
3128         if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3129           return elt;
3130
3131       for (elt = obj; elt != 0;
3132            elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3133                    || TREE_CODE (elt) == COND_EXPR)
3134                   ? TREE_OPERAND (elt, 1)
3135                   : (REFERENCE_CLASS_P (elt)
3136                      || UNARY_CLASS_P (elt)
3137                      || BINARY_CLASS_P (elt)
3138                      || VL_EXP_CLASS_P (elt)
3139                      || EXPRESSION_CLASS_P (elt))
3140                   ? TREE_OPERAND (elt, 0) : 0))
3141         if (POINTER_TYPE_P (TREE_TYPE (elt))
3142             && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3143                 == need_type))
3144           return fold_build1 (INDIRECT_REF, need_type, elt);
3145
3146       /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3147          survives until RTL generation, there will be an error.  */
3148       return exp;
3149     }
3150
3151   /* TREE_LIST is special because we need to look at TREE_VALUE
3152      and TREE_CHAIN, not TREE_OPERANDS.  */
3153   else if (code == TREE_LIST)
3154     {
3155       op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3156       op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3157       if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3158         return exp;
3159
3160       return tree_cons (TREE_PURPOSE (exp), op1, op0);
3161     }
3162   else
3163     switch (TREE_CODE_CLASS (code))
3164       {
3165       case tcc_constant:
3166       case tcc_declaration:
3167         return exp;
3168
3169       case tcc_exceptional:
3170       case tcc_unary:
3171       case tcc_binary:
3172       case tcc_comparison:
3173       case tcc_expression:
3174       case tcc_reference:
3175       case tcc_statement:
3176         switch (TREE_CODE_LENGTH (code))
3177           {
3178           case 0:
3179             return exp;
3180
3181           case 1:
3182             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3183             if (op0 == TREE_OPERAND (exp, 0))
3184               return exp;
3185
3186             new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3187             break;
3188
3189           case 2:
3190             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3191             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3192
3193             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3194               return exp;
3195
3196             new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3197             break;
3198
3199           case 3:
3200             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3201             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3202             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3203
3204             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3205                 && op2 == TREE_OPERAND (exp, 2))
3206               return exp;
3207
3208             new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3209             break;
3210
3211           case 4:
3212             op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3213             op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3214             op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3215             op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3216
3217             if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3218                 && op2 == TREE_OPERAND (exp, 2)
3219                 && op3 == TREE_OPERAND (exp, 3))
3220               return exp;
3221
3222             new_tree
3223               = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3224             break;
3225
3226           default:
3227             gcc_unreachable ();
3228           }
3229         break;
3230
3231       case tcc_vl_exp:
3232         {
3233           int i;
3234
3235           new_tree = NULL_TREE;
3236
3237           for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3238             {
3239               tree op = TREE_OPERAND (exp, i);
3240               tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3241               if (new_op != op)
3242                 {
3243                   if (!new_tree)
3244                     new_tree = copy_node (exp);
3245                   TREE_OPERAND (new_tree, i) = new_op;
3246                 }
3247             }
3248
3249           if (new_tree)
3250             {
3251               new_tree = fold (new_tree);
3252               if (TREE_CODE (new_tree) == CALL_EXPR)
3253                 process_call_operands (new_tree);
3254             }
3255           else
3256             return exp;
3257         }
3258         break;
3259
3260       default:
3261         gcc_unreachable ();
3262       }
3263
3264   TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3265   return new_tree;
3266 }
3267 \f
3268 /* Stabilize a reference so that we can use it any number of times
3269    without causing its operands to be evaluated more than once.
3270    Returns the stabilized reference.  This works by means of save_expr,
3271    so see the caveats in the comments about save_expr.
3272
3273    Also allows conversion expressions whose operands are references.
3274    Any other kind of expression is returned unchanged.  */
3275
3276 tree
3277 stabilize_reference (tree ref)
3278 {
3279   tree result;
3280   enum tree_code code = TREE_CODE (ref);
3281
3282   switch (code)
3283     {
3284     case VAR_DECL:
3285     case PARM_DECL:
3286     case RESULT_DECL:
3287       /* No action is needed in this case.  */
3288       return ref;
3289
3290     CASE_CONVERT:
3291     case FLOAT_EXPR:
3292     case FIX_TRUNC_EXPR:
3293       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3294       break;
3295
3296     case INDIRECT_REF:
3297       result = build_nt (INDIRECT_REF,
3298                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3299       break;
3300
3301     case COMPONENT_REF:
3302       result = build_nt (COMPONENT_REF,
3303                          stabilize_reference (TREE_OPERAND (ref, 0)),
3304                          TREE_OPERAND (ref, 1), NULL_TREE);
3305       break;
3306
3307     case BIT_FIELD_REF:
3308       result = build_nt (BIT_FIELD_REF,
3309                          stabilize_reference (TREE_OPERAND (ref, 0)),
3310                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3311                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3312       break;
3313
3314     case ARRAY_REF:
3315       result = build_nt (ARRAY_REF,
3316                          stabilize_reference (TREE_OPERAND (ref, 0)),
3317                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3318                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3319       break;
3320
3321     case ARRAY_RANGE_REF:
3322       result = build_nt (ARRAY_RANGE_REF,
3323                          stabilize_reference (TREE_OPERAND (ref, 0)),
3324                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3325                          TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3326       break;
3327
3328     case COMPOUND_EXPR:
3329       /* We cannot wrap the first expression in a SAVE_EXPR, as then
3330          it wouldn't be ignored.  This matters when dealing with
3331          volatiles.  */
3332       return stabilize_reference_1 (ref);
3333
3334       /* If arg isn't a kind of lvalue we recognize, make no change.
3335          Caller should recognize the error for an invalid lvalue.  */
3336     default:
3337       return ref;
3338
3339     case ERROR_MARK:
3340       return error_mark_node;
3341     }
3342
3343   TREE_TYPE (result) = TREE_TYPE (ref);
3344   TREE_READONLY (result) = TREE_READONLY (ref);
3345   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3346   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3347
3348   return result;
3349 }
3350
3351 /* Subroutine of stabilize_reference; this is called for subtrees of
3352    references.  Any expression with side-effects must be put in a SAVE_EXPR
3353    to ensure that it is only evaluated once.
3354
3355    We don't put SAVE_EXPR nodes around everything, because assigning very
3356    simple expressions to temporaries causes us to miss good opportunities
3357    for optimizations.  Among other things, the opportunity to fold in the
3358    addition of a constant into an addressing mode often gets lost, e.g.
3359    "y[i+1] += x;".  In general, we take the approach that we should not make
3360    an assignment unless we are forced into it - i.e., that any non-side effect
3361    operator should be allowed, and that cse should take care of coalescing
3362    multiple utterances of the same expression should that prove fruitful.  */
3363
3364 tree
3365 stabilize_reference_1 (tree e)
3366 {
3367   tree result;
3368   enum tree_code code = TREE_CODE (e);
3369
3370   /* We cannot ignore const expressions because it might be a reference
3371      to a const array but whose index contains side-effects.  But we can
3372      ignore things that are actual constant or that already have been
3373      handled by this function.  */
3374
3375   if (tree_invariant_p (e))
3376     return e;
3377
3378   switch (TREE_CODE_CLASS (code))
3379     {
3380     case tcc_exceptional:
3381     case tcc_type:
3382     case tcc_declaration:
3383     case tcc_comparison:
3384     case tcc_statement:
3385     case tcc_expression:
3386     case tcc_reference:
3387     case tcc_vl_exp:
3388       /* If the expression has side-effects, then encase it in a SAVE_EXPR
3389          so that it will only be evaluated once.  */
3390       /* The reference (r) and comparison (<) classes could be handled as
3391          below, but it is generally faster to only evaluate them once.  */
3392       if (TREE_SIDE_EFFECTS (e))
3393         return save_expr (e);
3394       return e;
3395
3396     case tcc_constant:
3397       /* Constants need no processing.  In fact, we should never reach
3398          here.  */
3399       return e;
3400
3401     case tcc_binary:
3402       /* Division is slow and tends to be compiled with jumps,
3403          especially the division by powers of 2 that is often
3404          found inside of an array reference.  So do it just once.  */
3405       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3406           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3407           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3408           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3409         return save_expr (e);
3410       /* Recursively stabilize each operand.  */
3411       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3412                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
3413       break;
3414
3415     case tcc_unary:
3416       /* Recursively stabilize each operand.  */
3417       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3418       break;
3419
3420     default:
3421       gcc_unreachable ();
3422     }
3423
3424   TREE_TYPE (result) = TREE_TYPE (e);
3425   TREE_READONLY (result) = TREE_READONLY (e);
3426   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3427   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3428
3429   return result;
3430 }
3431 \f
3432 /* Low-level constructors for expressions.  */
3433
3434 /* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3435    and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3436
3437 void
3438 recompute_tree_invariant_for_addr_expr (tree t)
3439 {
3440   tree node;
3441   bool tc = true, se = false;
3442
3443   /* We started out assuming this address is both invariant and constant, but
3444      does not have side effects.  Now go down any handled components and see if
3445      any of them involve offsets that are either non-constant or non-invariant.
3446      Also check for side-effects.
3447
3448      ??? Note that this code makes no attempt to deal with the case where
3449      taking the address of something causes a copy due to misalignment.  */
3450
3451 #define UPDATE_FLAGS(NODE)  \
3452 do { tree _node = (NODE); \
3453      if (_node && !TREE_CONSTANT (_node)) tc = false; \
3454      if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3455
3456   for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3457        node = TREE_OPERAND (node, 0))
3458     {
3459       /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3460          array reference (probably made temporarily by the G++ front end),
3461          so ignore all the operands.  */
3462       if ((TREE_CODE (node) == ARRAY_REF
3463            || TREE_CODE (node) == ARRAY_RANGE_REF)
3464           && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3465         {
3466           UPDATE_FLAGS (TREE_OPERAND (node, 1));
3467           if (TREE_OPERAND (node, 2))
3468             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3469           if (TREE_OPERAND (node, 3))
3470             UPDATE_FLAGS (TREE_OPERAND (node, 3));
3471         }
3472       /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3473          FIELD_DECL, apparently.  The G++ front end can put something else
3474          there, at least temporarily.  */
3475       else if (TREE_CODE (node) == COMPONENT_REF
3476                && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3477         {
3478           if (TREE_OPERAND (node, 2))
3479             UPDATE_FLAGS (TREE_OPERAND (node, 2));
3480         }
3481       else if (TREE_CODE (node) == BIT_FIELD_REF)
3482         UPDATE_FLAGS (TREE_OPERAND (node, 2));
3483     }
3484
3485   node = lang_hooks.expr_to_decl (node, &tc, &se);
3486
3487   /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3488      the address, since &(*a)->b is a form of addition.  If it's a constant, the
3489      address is constant too.  If it's a decl, its address is constant if the
3490      decl is static.  Everything else is not constant and, furthermore,
3491      taking the address of a volatile variable is not volatile.  */
3492   if (TREE_CODE (node) == INDIRECT_REF)
3493     UPDATE_FLAGS (TREE_OPERAND (node, 0));
3494   else if (CONSTANT_CLASS_P (node))
3495     ;
3496   else if (DECL_P (node))
3497     tc &= (staticp (node) != NULL_TREE);
3498   else
3499     {
3500       tc = false;
3501       se |= TREE_SIDE_EFFECTS (node);
3502     }
3503
3504
3505   TREE_CONSTANT (t) = tc;
3506   TREE_SIDE_EFFECTS (t) = se;
3507 #undef UPDATE_FLAGS
3508 }
3509
3510 /* Build an expression of code CODE, data type TYPE, and operands as
3511    specified.  Expressions and reference nodes can be created this way.
3512    Constants, decls, types and misc nodes cannot be.
3513
3514    We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3515    enough for all extant tree codes.  */
3516
3517 tree
3518 build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3519 {
3520   tree t;
3521
3522   gcc_assert (TREE_CODE_LENGTH (code) == 0);
3523
3524   t = make_node_stat (code PASS_MEM_STAT);
3525   TREE_TYPE (t) = tt;
3526
3527   return t;
3528 }
3529
3530 tree
3531 build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3532 {
3533   int length = sizeof (struct tree_exp);
3534 #ifdef GATHER_STATISTICS
3535   tree_node_kind kind;
3536 #endif
3537   tree t;
3538
3539 #ifdef GATHER_STATISTICS
3540   switch (TREE_CODE_CLASS (code))
3541     {
3542     case tcc_statement:  /* an expression with side effects */
3543       kind = s_kind;
3544       break;
3545     case tcc_reference:  /* a reference */
3546       kind = r_kind;
3547       break;
3548     default:
3549       kind = e_kind;
3550       break;
3551     }
3552
3553   tree_node_counts[(int) kind]++;
3554   tree_node_sizes[(int) kind] += length;
3555 #endif
3556
3557   gcc_assert (TREE_CODE_LENGTH (code) == 1);
3558
3559   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
3560
3561   memset (t, 0, sizeof (struct tree_common));
3562
3563   TREE_SET_CODE (t, code);
3564
3565   TREE_TYPE (t) = type;
3566   SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3567   TREE_OPERAND (t, 0) = node;
3568   TREE_BLOCK (t) = NULL_TREE;
3569   if (node && !TYPE_P (node))
3570     {
3571       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3572       TREE_READONLY (t) = TREE_READONLY (node);
3573     }
3574
3575   if (TREE_CODE_CLASS (code) == tcc_statement)
3576     TREE_SIDE_EFFECTS (t) = 1;
3577   else switch (code)
3578     {
3579     case VA_ARG_EXPR:
3580       /* All of these have side-effects, no matter what their
3581          operands are.  */
3582       TREE_SIDE_EFFECTS (t) = 1;
3583       TREE_READONLY (t) = 0;
3584       break;
3585
3586     case MISALIGNED_INDIRECT_REF:
3587     case ALIGN_INDIRECT_REF:
3588     case INDIRECT_REF:
3589       /* Whether a dereference is readonly has nothing to do with whether
3590          its operand is readonly.  */
3591       TREE_READONLY (t) = 0;
3592       break;
3593
3594     case ADDR_EXPR:
3595       if (node)
3596         recompute_tree_invariant_for_addr_expr (t);
3597       break;
3598
3599     default:
3600       if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3601           && node && !TYPE_P (node)
3602           && TREE_CONSTANT (node))
3603         TREE_CONSTANT (t) = 1;
3604       if (TREE_CODE_CLASS (code) == tcc_reference
3605           && node && TREE_THIS_VOLATILE (node))
3606         TREE_THIS_VOLATILE (t) = 1;
3607       break;
3608     }
3609
3610   return t;
3611 }
3612
3613 #define PROCESS_ARG(N)                          \
3614   do {                                          \
3615     TREE_OPERAND (t, N) = arg##N;               \
3616     if (arg##N &&!TYPE_P (arg##N))              \
3617       {                                         \
3618         if (TREE_SIDE_EFFECTS (arg##N))         \
3619           side_effects = 1;                     \
3620         if (!TREE_READONLY (arg##N)             \
3621             && !CONSTANT_CLASS_P (arg##N))      \
3622           read_only = 0;                        \
3623         if (!TREE_CONSTANT (arg##N))            \
3624           constant = 0;                         \
3625       }                                         \
3626   } while (0)
3627
3628 tree
3629 build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3630 {
3631   bool constant, read_only, side_effects;
3632   tree t;
3633
3634   gcc_assert (TREE_CODE_LENGTH (code) == 2);
3635
3636   if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3637       && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3638       /* When sizetype precision doesn't match that of pointers
3639          we need to be able to build explicit extensions or truncations
3640          of the offset argument.  */
3641       && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3642     gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3643                 && TREE_CODE (arg1) == INTEGER_CST);
3644
3645   if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3646     gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3647                 && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3648                 && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3649
3650   t = make_node_stat (code PASS_MEM_STAT);
3651   TREE_TYPE (t) = tt;
3652
3653   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3654      result based on those same flags for the arguments.  But if the
3655      arguments aren't really even `tree' expressions, we shouldn't be trying
3656      to do this.  */
3657
3658   /* Expressions without side effects may be constant if their
3659      arguments are as well.  */
3660   constant = (TREE_CODE_CLASS (code) == tcc_comparison
3661               || TREE_CODE_CLASS (code) == tcc_binary);
3662   read_only = 1;
3663   side_effects = TREE_SIDE_EFFECTS (t);
3664
3665   PROCESS_ARG(0);
3666   PROCESS_ARG(1);
3667
3668   TREE_READONLY (t) = read_only;
3669   TREE_CONSTANT (t) = constant;
3670   TREE_SIDE_EFFECTS (t) = side_effects;
3671   TREE_THIS_VOLATILE (t)
3672     = (TREE_CODE_CLASS (code) == tcc_reference
3673        && arg0 && TREE_THIS_VOLATILE (arg0));
3674
3675   return t;
3676 }
3677
3678
3679 tree
3680 build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3681              tree arg2 MEM_STAT_DECL)
3682 {
3683   bool constant, read_only, side_effects;
3684   tree t;
3685
3686   gcc_assert (TREE_CODE_LENGTH (code) == 3);
3687   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3688
3689   t = make_node_stat (code PASS_MEM_STAT);
3690   TREE_TYPE (t) = tt;
3691
3692   read_only = 1;
3693
3694   /* As a special exception, if COND_EXPR has NULL branches, we
3695      assume that it is a gimple statement and always consider
3696      it to have side effects.  */
3697   if (code == COND_EXPR
3698       && tt == void_type_node
3699       && arg1 == NULL_TREE
3700       && arg2 == NULL_TREE)
3701     side_effects = true;
3702   else
3703     side_effects = TREE_SIDE_EFFECTS (t);
3704
3705   PROCESS_ARG(0);
3706   PROCESS_ARG(1);
3707   PROCESS_ARG(2);
3708
3709   if (code == COND_EXPR)
3710     TREE_READONLY (t) = read_only;
3711
3712   TREE_SIDE_EFFECTS (t) = side_effects;
3713   TREE_THIS_VOLATILE (t)
3714     = (TREE_CODE_CLASS (code) == tcc_reference
3715        && arg0 && TREE_THIS_VOLATILE (arg0));
3716
3717   return t;
3718 }
3719
3720 tree
3721 build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3722              tree arg2, tree arg3 MEM_STAT_DECL)
3723 {
3724   bool constant, read_only, side_effects;
3725   tree t;
3726
3727   gcc_assert (TREE_CODE_LENGTH (code) == 4);
3728
3729   t = make_node_stat (code PASS_MEM_STAT);
3730   TREE_TYPE (t) = tt;
3731
3732   side_effects = TREE_SIDE_EFFECTS (t);
3733
3734   PROCESS_ARG(0);
3735   PROCESS_ARG(1);
3736   PROCESS_ARG(2);
3737   PROCESS_ARG(3);
3738
3739   TREE_SIDE_EFFECTS (t) = side_effects;
3740   TREE_THIS_VOLATILE (t)
3741     = (TREE_CODE_CLASS (code) == tcc_reference
3742        && arg0 && TREE_THIS_VOLATILE (arg0));
3743
3744   return t;
3745 }
3746
3747 tree
3748 build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3749              tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3750 {
3751   bool constant, read_only, side_effects;
3752   tree t;
3753
3754   gcc_assert (TREE_CODE_LENGTH (code) == 5);
3755
3756   t = make_node_stat (code PASS_MEM_STAT);
3757   TREE_TYPE (t) = tt;
3758
3759   side_effects = TREE_SIDE_EFFECTS (t);
3760
3761   PROCESS_ARG(0);
3762   PROCESS_ARG(1);
3763   PROCESS_ARG(2);
3764   PROCESS_ARG(3);
3765   PROCESS_ARG(4);
3766
3767   TREE_SIDE_EFFECTS (t) = side_effects;
3768   TREE_THIS_VOLATILE (t)
3769     = (TREE_CODE_CLASS (code) == tcc_reference
3770        && arg0 && TREE_THIS_VOLATILE (arg0));
3771
3772   return t;
3773 }
3774
3775 tree
3776 build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3777              tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
3778 {
3779   bool constant, read_only, side_effects;
3780   tree t;
3781
3782   gcc_assert (code == TARGET_MEM_REF);
3783
3784   t = make_node_stat (code PASS_MEM_STAT);
3785   TREE_TYPE (t) = tt;
3786
3787   side_effects = TREE_SIDE_EFFECTS (t);
3788
3789   PROCESS_ARG(0);
3790   PROCESS_ARG(1);
3791   PROCESS_ARG(2);
3792   PROCESS_ARG(3);
3793   PROCESS_ARG(4);
3794   PROCESS_ARG(5);
3795
3796   TREE_SIDE_EFFECTS (t) = side_effects;
3797   TREE_THIS_VOLATILE (t) = 0;
3798
3799   return t;
3800 }
3801
3802 /* Similar except don't specify the TREE_TYPE
3803    and leave the TREE_SIDE_EFFECTS as 0.
3804    It is permissible for arguments to be null,
3805    or even garbage if their values do not matter.  */
3806
3807 tree
3808 build_nt (enum tree_code code, ...)
3809 {
3810   tree t;
3811   int length;
3812   int i;
3813   va_list p;
3814
3815   gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3816
3817   va_start (p, code);
3818
3819   t = make_node (code);
3820   length = TREE_CODE_LENGTH (code);
3821
3822   for (i = 0; i < length; i++)
3823     TREE_OPERAND (t, i) = va_arg (p, tree);
3824
3825   va_end (p);
3826   return t;
3827 }
3828
3829 /* Similar to build_nt, but for creating a CALL_EXPR object with
3830    ARGLIST passed as a list.  */
3831
3832 tree
3833 build_nt_call_list (tree fn, tree arglist)
3834 {
3835   tree t;
3836   int i;
3837
3838   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
3839   CALL_EXPR_FN (t) = fn;
3840   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
3841   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
3842     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
3843   return t;
3844 }
3845
3846 /* Similar to build_nt, but for creating a CALL_EXPR object with a
3847    tree VEC.  */
3848
3849 tree
3850 build_nt_call_vec (tree fn, VEC(tree,gc) *args)
3851 {
3852   tree ret, t;
3853   unsigned int ix;
3854
3855   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
3856   CALL_EXPR_FN (ret) = fn;
3857   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3858   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
3859     CALL_EXPR_ARG (ret, ix) = t;
3860   return ret;
3861 }
3862 \f
3863 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3864    We do NOT enter this node in any sort of symbol table.
3865
3866    LOC is the location of the decl.
3867
3868    layout_decl is used to set up the decl's storage layout.
3869    Other slots are initialized to 0 or null pointers.  */
3870
3871 tree
3872 build_decl_stat (location_t loc, enum tree_code code, tree name,
3873                  tree type MEM_STAT_DECL)
3874 {
3875   tree t;
3876
3877   t = make_node_stat (code PASS_MEM_STAT);
3878   DECL_SOURCE_LOCATION (t) = loc;
3879
3880 /*  if (type == error_mark_node)
3881     type = integer_type_node; */
3882 /* That is not done, deliberately, so that having error_mark_node
3883    as the type can suppress useless errors in the use of this variable.  */
3884
3885   DECL_NAME (t) = name;
3886   TREE_TYPE (t) = type;
3887
3888   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3889     layout_decl (t, 0);
3890
3891   return t;
3892 }
3893
3894 /* Builds and returns function declaration with NAME and TYPE.  */
3895
3896 tree
3897 build_fn_decl (const char *name, tree type)
3898 {
3899   tree id = get_identifier (name);
3900   tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
3901
3902   DECL_EXTERNAL (decl) = 1;
3903   TREE_PUBLIC (decl) = 1;
3904   DECL_ARTIFICIAL (decl) = 1;
3905   TREE_NOTHROW (decl) = 1;
3906
3907   return decl;
3908 }
3909
3910 \f
3911 /* BLOCK nodes are used to represent the structure of binding contours
3912    and declarations, once those contours have been exited and their contents
3913    compiled.  This information is used for outputting debugging info.  */
3914
3915 tree
3916 build_block (tree vars, tree subblocks, tree supercontext, tree chain)
3917 {
3918   tree block = make_node (BLOCK);
3919
3920   BLOCK_VARS (block) = vars;
3921   BLOCK_SUBBLOCKS (block) = subblocks;
3922   BLOCK_SUPERCONTEXT (block) = supercontext;
3923   BLOCK_CHAIN (block) = chain;
3924   return block;
3925 }
3926
3927 expanded_location
3928 expand_location (source_location loc)
3929 {
3930   expanded_location xloc;
3931   if (loc == 0)
3932     {
3933       xloc.file = NULL;
3934       xloc.line = 0;
3935       xloc.column = 0;
3936       xloc.sysp = 0;
3937     }
3938   else
3939     {
3940       const struct line_map *map = linemap_lookup (line_table, loc);
3941       xloc.file = map->to_file;
3942       xloc.line = SOURCE_LINE (map, loc);
3943       xloc.column = SOURCE_COLUMN (map, loc);
3944       xloc.sysp = map->sysp != 0;
3945     };
3946   return xloc;
3947 }
3948
3949 \f
3950 /* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
3951
3952    LOC is the location to use in tree T.  */
3953
3954 void
3955 protected_set_expr_location (tree t, location_t loc)
3956 {
3957   if (t && CAN_HAVE_LOCATION_P (t))
3958     SET_EXPR_LOCATION (t, loc);
3959 }
3960 \f
3961 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
3962    is ATTRIBUTE.  */
3963
3964 tree
3965 build_decl_attribute_variant (tree ddecl, tree attribute)
3966 {
3967   DECL_ATTRIBUTES (ddecl) = attribute;
3968   return ddecl;
3969 }
3970
3971 /* Borrowed from hashtab.c iterative_hash implementation.  */
3972 #define mix(a,b,c) \
3973 { \
3974   a -= b; a -= c; a ^= (c>>13); \
3975   b -= c; b -= a; b ^= (a<< 8); \
3976   c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
3977   a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
3978   b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
3979   c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
3980   a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
3981   b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
3982   c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
3983 }
3984
3985
3986 /* Produce good hash value combining VAL and VAL2.  */
3987 hashval_t
3988 iterative_hash_hashval_t (hashval_t val, hashval_t val2)
3989 {
3990   /* the golden ratio; an arbitrary value.  */
3991   hashval_t a = 0x9e3779b9;
3992
3993   mix (a, val, val2);
3994   return val2;
3995 }
3996
3997 /* Produce good hash value combining VAL and VAL2.  */
3998 hashval_t
3999 iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4000 {
4001   if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4002     return iterative_hash_hashval_t (val, val2);
4003   else
4004     {
4005       hashval_t a = (hashval_t) val;
4006       /* Avoid warnings about shifting of more than the width of the type on
4007          hosts that won't execute this path.  */
4008       int zero = 0;
4009       hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4010       mix (a, b, val2);
4011       if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4012         {
4013           hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4014           hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4015           mix (a, b, val2);
4016         }
4017       return val2;
4018     }
4019 }
4020
4021 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4022    is ATTRIBUTE and its qualifiers are QUALS.
4023
4024    Record such modified types already made so we don't make duplicates.  */
4025
4026 static tree
4027 build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4028 {
4029   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4030     {
4031       hashval_t hashcode = 0;
4032       tree ntype;
4033       enum tree_code code = TREE_CODE (ttype);
4034
4035       /* Building a distinct copy of a tagged type is inappropriate; it
4036          causes breakage in code that expects there to be a one-to-one
4037          relationship between a struct and its fields.
4038          build_duplicate_type is another solution (as used in
4039          handle_transparent_union_attribute), but that doesn't play well
4040          with the stronger C++ type identity model.  */
4041       if (TREE_CODE (ttype) == RECORD_TYPE
4042           || TREE_CODE (ttype) == UNION_TYPE
4043           || TREE_CODE (ttype) == QUAL_UNION_TYPE
4044           || TREE_CODE (ttype) == ENUMERAL_TYPE)
4045         {
4046           warning (OPT_Wattributes,
4047                    "ignoring attributes applied to %qT after definition",
4048                    TYPE_MAIN_VARIANT (ttype));
4049           return build_qualified_type (ttype, quals);
4050         }
4051
4052       ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4053       ntype = build_distinct_type_copy (ttype);
4054
4055       TYPE_ATTRIBUTES (ntype) = attribute;
4056
4057       hashcode = iterative_hash_object (code, hashcode);
4058       if (TREE_TYPE (ntype))
4059         hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4060                                           hashcode);
4061       hashcode = attribute_hash_list (attribute, hashcode);
4062
4063       switch (TREE_CODE (ntype))
4064         {
4065         case FUNCTION_TYPE:
4066           hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4067           break;
4068         case ARRAY_TYPE:
4069           if (TYPE_DOMAIN (ntype))
4070             hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4071                                               hashcode);
4072           break;
4073         case INTEGER_TYPE:
4074           hashcode = iterative_hash_object
4075             (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4076           hashcode = iterative_hash_object
4077             (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4078           break;
4079         case REAL_TYPE:
4080         case FIXED_POINT_TYPE:
4081           {
4082             unsigned int precision = TYPE_PRECISION (ntype);
4083             hashcode = iterative_hash_object (precision, hashcode);
4084           }
4085           break;
4086         default:
4087           break;
4088         }
4089
4090       ntype = type_hash_canon (hashcode, ntype);
4091
4092       /* If the target-dependent attributes make NTYPE different from
4093          its canonical type, we will need to use structural equality
4094          checks for this type. */
4095       if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4096           || !targetm.comp_type_attributes (ntype, ttype))
4097         SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4098       else if (TYPE_CANONICAL (ntype) == ntype)
4099         TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4100
4101       ttype = build_qualified_type (ntype, quals);
4102     }
4103   else if (TYPE_QUALS (ttype) != quals)
4104     ttype = build_qualified_type (ttype, quals);
4105
4106   return ttype;
4107 }
4108
4109
4110 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4111    is ATTRIBUTE.
4112
4113    Record such modified types already made so we don't make duplicates.  */
4114
4115 tree
4116 build_type_attribute_variant (tree ttype, tree attribute)
4117 {
4118   return build_type_attribute_qual_variant (ttype, attribute,
4119                                             TYPE_QUALS (ttype));
4120 }
4121
4122 /* Reset all language specific information still present in TYPE.  */
4123
4124 static void
4125 free_lang_data_in_type (tree type)
4126 {
4127   gcc_assert (TYPE_P (type));
4128
4129   /* Fill in the alias-set.  We need to at least track zeroness here
4130      for correctness.  */
4131   if (lang_hooks.get_alias_set (type) == 0)
4132     TYPE_ALIAS_SET (type) = 0;
4133
4134   /* Give the FE a chance to remove its own data first.  */
4135   lang_hooks.free_lang_data (type);
4136
4137   TREE_LANG_FLAG_0 (type) = 0;
4138   TREE_LANG_FLAG_1 (type) = 0;
4139   TREE_LANG_FLAG_2 (type) = 0;
4140   TREE_LANG_FLAG_3 (type) = 0;
4141   TREE_LANG_FLAG_4 (type) = 0;
4142   TREE_LANG_FLAG_5 (type) = 0;
4143   TREE_LANG_FLAG_6 (type) = 0;
4144
4145   if (TREE_CODE (type) == FUNCTION_TYPE)
4146     {
4147       /* Remove the const and volatile qualifiers from arguments.  The
4148          C++ front end removes them, but the C front end does not,
4149          leading to false ODR violation errors when merging two
4150          instances of the same function signature compiled by
4151          different front ends.  */
4152       tree p;
4153
4154       for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4155         {
4156           tree arg_type = TREE_VALUE (p);
4157
4158           if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4159             {
4160               int quals = TYPE_QUALS (arg_type)
4161                           & ~TYPE_QUAL_CONST
4162                           & ~TYPE_QUAL_VOLATILE;
4163               TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4164               free_lang_data_in_type (TREE_VALUE (p));
4165             }
4166         }
4167     }
4168
4169   /* Remove members that are not actually FIELD_DECLs from the field
4170      list of an aggregate.  These occur in C++.  */
4171   if (TREE_CODE (type) == RECORD_TYPE
4172       || TREE_CODE (type) == UNION_TYPE
4173       || TREE_CODE (type) == QUAL_UNION_TYPE)
4174     {
4175       tree prev, member;
4176
4177       /* Note that TYPE_FIELDS can be shared across distinct
4178          TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
4179          to be removed, we cannot set its TREE_CHAIN to NULL.
4180          Otherwise, we would not be able to find all the other fields
4181          in the other instances of this TREE_TYPE.
4182
4183          This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
4184       prev = NULL_TREE;
4185       member = TYPE_FIELDS (type);
4186       while (member)
4187         {
4188           if (TREE_CODE (member) == FIELD_DECL)
4189             {
4190               if (prev)
4191                 TREE_CHAIN (prev) = member;
4192               else
4193                 TYPE_FIELDS (type) = member;
4194               prev = member;
4195             }
4196
4197           member = TREE_CHAIN (member);
4198         }
4199
4200       if (prev)
4201         TREE_CHAIN (prev) = NULL_TREE;
4202       else
4203         TYPE_FIELDS (type) = NULL_TREE;
4204
4205       TYPE_METHODS (type) = NULL_TREE;
4206       if (TYPE_BINFO (type))
4207         {
4208           tree binfo = TYPE_BINFO (type);
4209
4210           if (BINFO_VIRTUALS (binfo))
4211             {
4212               /* If the virtual function table for BINFO contains
4213                  entries, these may be useful for folding OBJ_TYPE_REF
4214                  expressions (see gimple_fold_obj_type_ref).  In that
4215                  case, we only clear the unused fields in the BINFO
4216                  structure.  */
4217               BINFO_OFFSET (binfo) = NULL_TREE;
4218               BINFO_VTABLE (binfo) = NULL_TREE;
4219               BINFO_VPTR_FIELD (binfo) = NULL_TREE;
4220               BINFO_BASE_ACCESSES (binfo) = NULL;
4221               BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4222               BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4223               BINFO_VPTR_FIELD (binfo) = NULL_TREE;
4224             }
4225           else
4226             {
4227               /* Otherwise, get rid of the whole binfo data.  */
4228               TYPE_BINFO (type) = NULL_TREE;
4229             }
4230         }
4231     }
4232   else
4233     {
4234       /* For non-aggregate types, clear out the language slot (which
4235          overloads TYPE_BINFO).  */
4236       TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4237     }
4238
4239   TYPE_CONTEXT (type) = NULL_TREE;
4240   TYPE_STUB_DECL (type) = NULL_TREE;
4241 }
4242
4243
4244 /* Return true if DECL may need an assembler name to be set.  */
4245
4246 static inline bool
4247 need_assembler_name_p (tree decl)
4248 {
4249   /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
4250   if (TREE_CODE (decl) != FUNCTION_DECL
4251       && TREE_CODE (decl) != VAR_DECL)
4252     return false;
4253
4254   /* If DECL already has its assembler name set, it does not need a
4255      new one.  */
4256   if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4257       || DECL_ASSEMBLER_NAME_SET_P (decl))
4258     return false;
4259
4260   /* For VAR_DECLs, only static, public and external symbols need an
4261      assembler name.  */
4262   if (TREE_CODE (decl) == VAR_DECL
4263       && !TREE_STATIC (decl)
4264       && !TREE_PUBLIC (decl)
4265       && !DECL_EXTERNAL (decl))
4266     return false;
4267
4268   /* Do not set assembler name on builtins.  Allow RTL expansion to
4269      decide whether to expand inline or via a regular call.  */
4270   if (TREE_CODE (decl) == FUNCTION_DECL
4271       && DECL_BUILT_IN (decl)
4272       && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4273     return false;
4274
4275   /* For FUNCTION_DECLs, only used functions and functions
4276      represented in the callgraph need an assembler name.  */
4277   if (TREE_CODE (decl) == FUNCTION_DECL
4278       && cgraph_node_for_decl (decl) == NULL
4279       && !TREE_USED (decl))
4280     return false;
4281
4282   return true;
4283 }
4284
4285
4286 /* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
4287    variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
4288    in BLOCK that is not in LOCALS is removed.  */
4289
4290 static void
4291 free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
4292 {
4293   tree *tp, t;
4294
4295   tp = &BLOCK_VARS (block);
4296   while (*tp)
4297     {
4298       if (!pointer_set_contains (locals, *tp))
4299         *tp = TREE_CHAIN (*tp);
4300       else
4301         tp = &TREE_CHAIN (*tp);
4302     }
4303
4304   for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4305     free_lang_data_in_block (fn, t, locals);
4306 }
4307
4308
4309 /* Reset all language specific information still present in symbol
4310    DECL.  */
4311
4312 static void
4313 free_lang_data_in_decl (tree decl)
4314 {
4315   gcc_assert (DECL_P (decl));
4316
4317   /* Give the FE a chance to remove its own data first.  */
4318   lang_hooks.free_lang_data (decl);
4319
4320   TREE_LANG_FLAG_0 (decl) = 0;
4321   TREE_LANG_FLAG_1 (decl) = 0;
4322   TREE_LANG_FLAG_2 (decl) = 0;
4323   TREE_LANG_FLAG_3 (decl) = 0;
4324   TREE_LANG_FLAG_4 (decl) = 0;
4325   TREE_LANG_FLAG_5 (decl) = 0;
4326   TREE_LANG_FLAG_6 (decl) = 0;
4327
4328   /* Identifiers need not have a type.  */
4329   if (DECL_NAME (decl))
4330     TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4331
4332   if (TREE_CODE (decl) == CONST_DECL)
4333     DECL_CONTEXT (decl) = NULL_TREE;
4334
4335   /* Ignore any intervening types, because we are going to clear their
4336      TYPE_CONTEXT fields.  */
4337   if (TREE_CODE (decl) != FIELD_DECL)
4338     DECL_CONTEXT (decl) = decl_function_context (decl);
4339
4340   if (DECL_CONTEXT (decl)
4341       && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
4342     DECL_CONTEXT (decl) = NULL_TREE;
4343
4344  if (TREE_CODE (decl) == VAR_DECL)
4345    {
4346      tree context = DECL_CONTEXT (decl);
4347
4348      if (context)
4349        {
4350          enum tree_code code = TREE_CODE (context);
4351          if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
4352            {
4353              /* Do not clear the decl context here, that will promote
4354                 all vars to global ones.  */
4355              DECL_INITIAL (decl) = NULL_TREE;
4356            }
4357
4358          if (TREE_STATIC (decl))
4359            DECL_CONTEXT (decl) = NULL_TREE;
4360        }
4361    }
4362
4363   if (TREE_CODE (decl) == PARM_DECL
4364       || TREE_CODE (decl) == FIELD_DECL
4365       || TREE_CODE (decl) == RESULT_DECL)
4366     {
4367       tree unit_size = DECL_SIZE_UNIT (decl);
4368       tree size = DECL_SIZE (decl);
4369       if ((unit_size && TREE_CODE (unit_size) != INTEGER_CST)
4370           || (size && TREE_CODE (size) != INTEGER_CST))
4371         {
4372           DECL_SIZE_UNIT (decl) = NULL_TREE;
4373           DECL_SIZE (decl) = NULL_TREE;
4374         }
4375
4376       if (TREE_CODE (decl) == FIELD_DECL
4377           && DECL_FIELD_OFFSET (decl)
4378           && TREE_CODE (DECL_FIELD_OFFSET (decl)) != INTEGER_CST)
4379         DECL_FIELD_OFFSET (decl) = NULL_TREE;
4380     }
4381   else if (TREE_CODE (decl) == FUNCTION_DECL)
4382     {
4383       if (gimple_has_body_p (decl))
4384         {
4385           tree t;
4386           struct pointer_set_t *locals;
4387
4388           /* If DECL has a gimple body, then the context for its
4389              arguments must be DECL.  Otherwise, it doesn't really
4390              matter, as we will not be emitting any code for DECL.  In
4391              general, there may be other instances of DECL created by
4392              the front end and since PARM_DECLs are generally shared,
4393              their DECL_CONTEXT changes as the replicas of DECL are
4394              created.  The only time where DECL_CONTEXT is important
4395              is for the FUNCTION_DECLs that have a gimple body (since
4396              the PARM_DECL will be used in the function's body).  */
4397           for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4398             DECL_CONTEXT (t) = decl;
4399
4400           /* Collect all the symbols declared in DECL.  */
4401           locals = pointer_set_create ();
4402           t = DECL_STRUCT_FUNCTION (decl)->local_decls;
4403           for (; t; t = TREE_CHAIN (t))
4404             {
4405               pointer_set_insert (locals, TREE_VALUE (t));
4406
4407               /* All the local symbols should have DECL as their
4408                  context.  */
4409               DECL_CONTEXT (TREE_VALUE (t)) = decl;
4410             }
4411
4412           /* Get rid of any decl not in local_decls.  */
4413           free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
4414
4415           pointer_set_destroy (locals);
4416         }
4417
4418       /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4419          At this point, it is not needed anymore.  */
4420       DECL_SAVED_TREE (decl) = NULL_TREE;
4421     }
4422   else if (TREE_CODE (decl) == VAR_DECL)
4423     {
4424       tree expr = DECL_DEBUG_EXPR (decl);
4425       if (expr
4426           && TREE_CODE (expr) == VAR_DECL
4427           && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
4428         SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
4429
4430       if (DECL_EXTERNAL (decl))
4431         DECL_INITIAL (decl) = NULL_TREE;
4432     }
4433   else if (TREE_CODE (decl) == TYPE_DECL)
4434     {
4435       DECL_INITIAL (decl) = NULL_TREE;
4436
4437       /* DECL_CONTEXT is overloaded as DECL_FIELD_CONTEXT for
4438          FIELD_DECLs, which should be preserved.  Otherwise,
4439          we shouldn't be concerned with source-level lexical
4440          nesting beyond this point. */
4441       DECL_CONTEXT (decl) = NULL_TREE;
4442     }
4443 }
4444
4445
4446 /* Data used when collecting DECLs and TYPEs for language data removal.  */
4447
4448 struct free_lang_data_d
4449 {
4450   /* Worklist to avoid excessive recursion.  */
4451   VEC(tree,heap) *worklist;
4452
4453   /* Set of traversed objects.  Used to avoid duplicate visits.  */
4454   struct pointer_set_t *pset;
4455
4456   /* Array of symbols to process with free_lang_data_in_decl.  */
4457   VEC(tree,heap) *decls;
4458
4459   /* Array of types to process with free_lang_data_in_type.  */
4460   VEC(tree,heap) *types;
4461 };
4462
4463
4464 /* Save all language fields needed to generate proper debug information
4465    for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
4466
4467 static void
4468 save_debug_info_for_decl (tree t)
4469 {
4470   /*struct saved_debug_info_d *sdi;*/
4471
4472   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
4473
4474   /* FIXME.  Partial implementation for saving debug info removed.  */
4475 }
4476
4477
4478 /* Save all language fields needed to generate proper debug information
4479    for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
4480
4481 static void
4482 save_debug_info_for_type (tree t)
4483 {
4484   /*struct saved_debug_info_d *sdi;*/
4485
4486   gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
4487
4488   /* FIXME.  Partial implementation for saving debug info removed.  */
4489 }
4490
4491
4492 /* Add type or decl T to one of the list of tree nodes that need their
4493    language data removed.  The lists are held inside FLD.  */
4494
4495 static void
4496 add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
4497 {
4498   if (DECL_P (t))
4499     {
4500       VEC_safe_push (tree, heap, fld->decls, t);
4501       if (debug_info_level > DINFO_LEVEL_TERSE)
4502         save_debug_info_for_decl (t);
4503     }
4504   else if (TYPE_P (t))
4505     {
4506       VEC_safe_push (tree, heap, fld->types, t);
4507       if (debug_info_level > DINFO_LEVEL_TERSE)
4508         save_debug_info_for_type (t);
4509     }
4510   else
4511     gcc_unreachable ();
4512 }
4513
4514 #define PUSH(t) \
4515     if (t && !pointer_set_contains (fld->pset, t)) \
4516       VEC_safe_push (tree, heap, fld->worklist, (t))
4517
4518 /* Operand callback helper for free_lang_data_in_node.  *TP is the
4519    subtree operand being considered.  */
4520
4521 static tree
4522 find_decls_types_r (tree *tp, int *ws ATTRIBUTE_UNUSED, void *data)
4523 {
4524   tree t = *tp;
4525   struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
4526
4527   if (TREE_CODE (t) == TREE_LIST)
4528     return NULL_TREE;
4529
4530   if (DECL_P (t))
4531     {
4532       /* Note that walk_tree does not traverse every possible field in
4533          decls, so we have to do our own traversals here.  */
4534       add_tree_to_fld_list (t, fld);
4535
4536       PUSH (DECL_NAME (t));
4537       PUSH (DECL_CONTEXT (t));
4538       PUSH (DECL_SIZE (t));
4539       PUSH (DECL_SIZE_UNIT (t));
4540       PUSH (DECL_INITIAL(t));
4541       PUSH (DECL_ATTRIBUTES (t));
4542       PUSH (DECL_ABSTRACT_ORIGIN (t));
4543
4544       if (TREE_CODE (t) == FUNCTION_DECL)
4545         {
4546           PUSH (DECL_ARGUMENTS (t));
4547           PUSH (DECL_RESULT (t));
4548         }
4549       else if (TREE_CODE (t) == TYPE_DECL)
4550         {
4551           PUSH (DECL_ARGUMENT_FLD (t));
4552           PUSH (DECL_VINDEX (t));
4553         }
4554       else if (TREE_CODE (t) == FIELD_DECL)
4555         {
4556           PUSH (DECL_FIELD_OFFSET (t));
4557           PUSH (DECL_BIT_FIELD_TYPE (t));
4558           PUSH (DECL_QUALIFIER (t));
4559           PUSH (DECL_FIELD_BIT_OFFSET (t));
4560           PUSH (DECL_FCONTEXT (t));
4561         }
4562       else if (TREE_CODE (t) == VAR_DECL)
4563         {
4564           PUSH (DECL_SECTION_NAME (t));
4565           PUSH (DECL_COMDAT_GROUP (t));
4566         }
4567
4568       PUSH (TREE_CHAIN (t));
4569       *ws = 0;
4570     }
4571   else if (TYPE_P (t))
4572     {
4573       /* Note that walk_tree does not traverse every possible field in
4574          types, so we have to do our own traversals here.  */
4575       add_tree_to_fld_list (t, fld);
4576
4577       PUSH (TYPE_CACHED_VALUES (t));
4578       PUSH (TYPE_SIZE (t));
4579       PUSH (TYPE_SIZE_UNIT (t));
4580       PUSH (TYPE_ATTRIBUTES (t));
4581       PUSH (TYPE_POINTER_TO (t));
4582       PUSH (TYPE_REFERENCE_TO (t));
4583       PUSH (TYPE_NAME (t));
4584       PUSH (TYPE_MINVAL (t));
4585       PUSH (TYPE_MAXVAL (t));
4586       PUSH (TYPE_MAIN_VARIANT (t));
4587       PUSH (TYPE_NEXT_VARIANT (t));
4588       PUSH (TYPE_CONTEXT (t));
4589       PUSH (TYPE_CANONICAL (t));
4590
4591       if (RECORD_OR_UNION_TYPE_P (t)
4592           && TYPE_BINFO (t))
4593         {
4594           unsigned i;
4595           tree tem;
4596           for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
4597                                    i, tem); ++i)
4598             PUSH (TREE_TYPE (tem));
4599         }
4600
4601       PUSH (TREE_CHAIN (t));
4602       *ws = 0;
4603     }
4604
4605   PUSH (TREE_TYPE (t));
4606
4607   return NULL_TREE;
4608 }
4609
4610 #undef PUSH
4611
4612 /* Find decls and types in T.  */
4613
4614 static void
4615 find_decls_types (tree t, struct free_lang_data_d *fld)
4616 {
4617   while (1)
4618     {
4619       if (!pointer_set_contains (fld->pset, t))
4620         walk_tree (&t, find_decls_types_r, fld, fld->pset);
4621       if (VEC_empty (tree, fld->worklist))
4622         break;
4623       t = VEC_pop (tree, fld->worklist);
4624     }
4625 }
4626
4627 /* Translate all the types in LIST with the corresponding runtime
4628    types.  */
4629
4630 static tree
4631 get_eh_types_for_runtime (tree list)
4632 {
4633   tree head, prev;
4634
4635   if (list == NULL_TREE)
4636     return NULL_TREE;
4637
4638   head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4639   prev = head;
4640   list = TREE_CHAIN (list);
4641   while (list)
4642     {
4643       tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4644       TREE_CHAIN (prev) = n;
4645       prev = TREE_CHAIN (prev);
4646       list = TREE_CHAIN (list);
4647     }
4648
4649   return head;
4650 }
4651
4652
4653 /* Find decls and types referenced in EH region R and store them in
4654    FLD->DECLS and FLD->TYPES.  */
4655
4656 static void
4657 find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
4658 {
4659   if (r == NULL)
4660     return;
4661
4662   /* The types referenced in R must first be changed to the EH types
4663      used at runtime.  This removes references to FE types in the
4664      region.  */
4665   if (r->type == ERT_CATCH)
4666     {
4667       tree list = r->u.eh_catch.type_list;
4668       r->u.eh_catch.type_list = get_eh_types_for_runtime (list);
4669       find_decls_types (r->u.eh_catch.type_list, fld);
4670     }
4671   else if (r->type == ERT_ALLOWED_EXCEPTIONS)
4672     {
4673       tree list = r->u.allowed.type_list;
4674       r->u.allowed.type_list = get_eh_types_for_runtime (list);
4675       find_decls_types (r->u.allowed.type_list, fld);
4676     }
4677 }
4678
4679
4680 /* Find decls and types referenced in cgraph node N and store them in
4681    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4682    look for *every* kind of DECL and TYPE node reachable from N,
4683    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4684    NAMESPACE_DECLs, etc).  */
4685
4686 static void
4687 find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
4688 {
4689   basic_block bb;
4690   struct function *fn;
4691   tree t;
4692
4693   find_decls_types (n->decl, fld);
4694
4695   if (!gimple_has_body_p (n->decl))
4696     return;
4697
4698   gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
4699
4700   fn = DECL_STRUCT_FUNCTION (n->decl);
4701
4702   /* Traverse locals. */
4703   for (t = fn->local_decls; t; t = TREE_CHAIN (t))
4704     find_decls_types (TREE_VALUE (t), fld);
4705
4706   /* Traverse EH regions in FN.  */
4707   if (fn->eh->region_array)
4708     {
4709       unsigned i;
4710       eh_region r;
4711
4712       for (i = 0; VEC_iterate (eh_region, fn->eh->region_array, i, r); i++)
4713         find_decls_types_in_eh_region (r, fld);
4714     }
4715
4716   /* Traverse every statement in FN.  */
4717   FOR_EACH_BB_FN (bb, fn)
4718     {
4719       gimple_stmt_iterator si;
4720       unsigned i;
4721
4722       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4723         {
4724           gimple phi = gsi_stmt (si);
4725
4726           for (i = 0; i < gimple_phi_num_args (phi); i++)
4727             {
4728               tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
4729               find_decls_types (*arg_p, fld);
4730             }
4731         }
4732
4733       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
4734         {
4735           gimple stmt = gsi_stmt (si);
4736
4737           for (i = 0; i < gimple_num_ops (stmt); i++)
4738             {
4739               tree arg = gimple_op (stmt, i);
4740               find_decls_types (arg, fld);
4741             }
4742         }
4743     }
4744 }
4745
4746
4747 /* Find decls and types referenced in varpool node N and store them in
4748    FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4749    look for *every* kind of DECL and TYPE node reachable from N,
4750    including those embedded inside types and decls (i.e,, TYPE_DECLs,
4751    NAMESPACE_DECLs, etc).  */
4752
4753 static void
4754 find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
4755 {
4756   find_decls_types (v->decl, fld);
4757 }
4758
4759
4760 /* Free language specific information for every operand and expression
4761    in every node of the call graph.  This process operates in three stages:
4762
4763    1- Every callgraph node and varpool node is traversed looking for
4764       decls and types embedded in them.  This is a more exhaustive
4765       search than that done by find_referenced_vars, because it will
4766       also collect individual fields, decls embedded in types, etc.
4767
4768    2- All the decls found are sent to free_lang_data_in_decl.
4769
4770    3- All the types found are sent to free_lang_data_in_type.
4771
4772    The ordering between decls and types is important because
4773    free_lang_data_in_decl sets assembler names, which includes
4774    mangling.  So types cannot be freed up until assembler names have
4775    been set up.  */
4776
4777 static void
4778 free_lang_data_in_cgraph (void)
4779 {
4780   struct cgraph_node *n;
4781   struct varpool_node *v;
4782   struct free_lang_data_d fld;
4783   tree t;
4784   unsigned i;
4785   alias_pair *p;
4786
4787   /* Initialize sets and arrays to store referenced decls and types.  */
4788   fld.pset = pointer_set_create ();
4789   fld.worklist = NULL;
4790   fld.decls = VEC_alloc (tree, heap, 100);
4791   fld.types = VEC_alloc (tree, heap, 100);
4792
4793   /* Find decls and types in the body of every function in the callgraph.  */
4794   for (n = cgraph_nodes; n; n = n->next)
4795     find_decls_types_in_node (n, &fld);
4796
4797   for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4798     find_decls_types (p->decl, &fld);
4799
4800   /* Find decls and types in every varpool symbol.  */
4801   for (v = varpool_nodes_queue; v; v = v->next_needed)
4802     find_decls_types_in_var (v, &fld);
4803
4804   /* Set the assembler name on every decl found.  We need to do this
4805      now because free_lang_data_in_decl will invalidate data needed
4806      for mangling.  This breaks mangling on interdependent decls.  */
4807   for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
4808     if (need_assembler_name_p (t))
4809       {
4810         /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
4811            diagnostics that use input_location to show locus
4812            information.  The problem here is that, at this point,
4813            input_location is generally anchored to the end of the file
4814            (since the parser is long gone), so we don't have a good
4815            position to pin it to.
4816
4817            To alleviate this problem, this uses the location of T's
4818            declaration.  Examples of this are
4819            testsuite/g++.dg/template/cond2.C and
4820            testsuite/g++.dg/template/pr35240.C.  */
4821         location_t saved_location = input_location;
4822         input_location = DECL_SOURCE_LOCATION (t);
4823
4824         decl_assembler_name (t);
4825
4826         input_location = saved_location;
4827       }
4828
4829   /* Traverse every decl found freeing its language data.  */
4830   for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
4831     free_lang_data_in_decl (t);
4832
4833   /* Traverse every type found freeing its language data.  */
4834   for (i = 0; VEC_iterate (tree, fld.types, i, t); i++)
4835     free_lang_data_in_type (t);
4836
4837   pointer_set_destroy (fld.pset);
4838   VEC_free (tree, heap, fld.worklist);
4839   VEC_free (tree, heap, fld.decls);
4840   VEC_free (tree, heap, fld.types);
4841 }
4842
4843
4844 /* Free resources that are used by FE but are not needed once they are done. */
4845
4846 static unsigned
4847 free_lang_data (void)
4848 {
4849   /* Traverse the IL resetting language specific information for
4850      operands, expressions, etc.  */
4851   free_lang_data_in_cgraph ();
4852
4853   /* Create gimple variants for common types.  */
4854   ptrdiff_type_node = integer_type_node;
4855   fileptr_type_node = ptr_type_node;
4856   if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
4857       || (TYPE_MODE (boolean_type_node)
4858           != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
4859       || TYPE_PRECISION (boolean_type_node) != 1
4860       || !TYPE_UNSIGNED (boolean_type_node))
4861     {
4862       boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
4863       TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
4864       TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
4865       TYPE_PRECISION (boolean_type_node) = 1;
4866       boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
4867       boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
4868     }
4869
4870   /* Unify char_type_node with its properly signed variant.  */
4871   if (TYPE_UNSIGNED (char_type_node))
4872     unsigned_char_type_node = char_type_node;
4873   else
4874     signed_char_type_node = char_type_node;
4875
4876   /* Reset some langhooks.  */
4877   lang_hooks.callgraph.analyze_expr = NULL;
4878   lang_hooks.types_compatible_p = NULL;
4879   lang_hooks.dwarf_name = lhd_dwarf_name;
4880   lang_hooks.decl_printable_name = gimple_decl_printable_name;
4881   lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
4882   lang_hooks.fold_obj_type_ref = gimple_fold_obj_type_ref;
4883
4884   /* Reset diagnostic machinery.  */
4885   diagnostic_starter (global_dc) = default_diagnostic_starter;
4886   diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
4887   diagnostic_format_decoder (global_dc) = default_tree_printer;
4888
4889   return 0;
4890 }
4891
4892
4893 /* Gate function for free_lang_data.  */
4894
4895 static bool
4896 gate_free_lang_data (void)
4897 {
4898   /* FIXME.  Remove after save_debug_info is working.  */
4899   return !flag_gtoggle && debug_info_level <= DINFO_LEVEL_TERSE;
4900 }
4901
4902
4903 struct simple_ipa_opt_pass pass_ipa_free_lang_data =
4904 {
4905  {
4906   SIMPLE_IPA_PASS,
4907   NULL,                                 /* name */
4908   gate_free_lang_data,                  /* gate */
4909   free_lang_data,                       /* execute */
4910   NULL,                                 /* sub */
4911   NULL,                                 /* next */
4912   0,                                    /* static_pass_number */
4913   TV_IPA_FREE_LANG_DATA,                /* tv_id */
4914   0,                                    /* properties_required */
4915   0,                                    /* properties_provided */
4916   0,                                    /* properties_destroyed */
4917   0,                                    /* todo_flags_start */
4918   TODO_ggc_collect                      /* todo_flags_finish */
4919  }
4920 };
4921
4922 /* Return nonzero if IDENT is a valid name for attribute ATTR,
4923    or zero if not.
4924
4925    We try both `text' and `__text__', ATTR may be either one.  */
4926 /* ??? It might be a reasonable simplification to require ATTR to be only
4927    `text'.  One might then also require attribute lists to be stored in
4928    their canonicalized form.  */
4929
4930 static int
4931 is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident)
4932 {
4933   int ident_len;
4934   const char *p;
4935
4936   if (TREE_CODE (ident) != IDENTIFIER_NODE)
4937     return 0;
4938
4939   p = IDENTIFIER_POINTER (ident);
4940   ident_len = IDENTIFIER_LENGTH (ident);
4941
4942   if (ident_len == attr_len
4943       && strcmp (attr, p) == 0)
4944     return 1;
4945
4946   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
4947   if (attr[0] == '_')
4948     {
4949       gcc_assert (attr[1] == '_');
4950       gcc_assert (attr[attr_len - 2] == '_');
4951       gcc_assert (attr[attr_len - 1] == '_');
4952       if (ident_len == attr_len - 4
4953           && strncmp (attr + 2, p, attr_len - 4) == 0)
4954         return 1;
4955     }
4956   else
4957     {
4958       if (ident_len == attr_len + 4
4959           && p[0] == '_' && p[1] == '_'
4960           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
4961           && strncmp (attr, p + 2, attr_len) == 0)
4962         return 1;
4963     }
4964
4965   return 0;
4966 }
4967
4968 /* Return nonzero if IDENT is a valid name for attribute ATTR,
4969    or zero if not.
4970
4971    We try both `text' and `__text__', ATTR may be either one.  */
4972
4973 int
4974 is_attribute_p (const char *attr, const_tree ident)
4975 {
4976   return is_attribute_with_length_p (attr, strlen (attr), ident);
4977 }
4978
4979 /* Given an attribute name and a list of attributes, return a pointer to the
4980    attribute's list element if the attribute is part of the list, or NULL_TREE
4981    if not found.  If the attribute appears more than once, this only
4982    returns the first occurrence; the TREE_CHAIN of the return value should
4983    be passed back in if further occurrences are wanted.  */
4984
4985 tree
4986 lookup_attribute (const char *attr_name, tree list)
4987 {
4988   tree l;
4989   size_t attr_len = strlen (attr_name);
4990
4991   for (l = list; l; l = TREE_CHAIN (l))
4992     {
4993       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
4994       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
4995         return l;
4996     }
4997   return NULL_TREE;
4998 }
4999
5000 /* Remove any instances of attribute ATTR_NAME in LIST and return the
5001    modified list.  */
5002
5003 tree
5004 remove_attribute (const char *attr_name, tree list)
5005 {
5006   tree *p;
5007   size_t attr_len = strlen (attr_name);
5008
5009   for (p = &list; *p; )
5010     {
5011       tree l = *p;
5012       gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5013       if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5014         *p = TREE_CHAIN (l);
5015       else
5016         p = &TREE_CHAIN (l);
5017     }
5018
5019   return list;
5020 }
5021
5022 /* Return an attribute list that is the union of a1 and a2.  */
5023
5024 tree
5025 merge_attributes (tree a1, tree a2)
5026 {
5027   tree attributes;
5028
5029   /* Either one unset?  Take the set one.  */
5030
5031   if ((attributes = a1) == 0)
5032     attributes = a2;
5033
5034   /* One that completely contains the other?  Take it.  */
5035
5036   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5037     {
5038       if (attribute_list_contained (a2, a1))
5039         attributes = a2;
5040       else
5041         {
5042           /* Pick the longest list, and hang on the other list.  */
5043
5044           if (list_length (a1) < list_length (a2))
5045             attributes = a2, a2 = a1;
5046
5047           for (; a2 != 0; a2 = TREE_CHAIN (a2))
5048             {
5049               tree a;
5050               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5051                                          attributes);
5052                    a != NULL_TREE;
5053                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5054                                          TREE_CHAIN (a)))
5055                 {
5056                   if (TREE_VALUE (a) != NULL
5057                       && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
5058                       && TREE_VALUE (a2) != NULL
5059                       && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
5060                     {
5061                       if (simple_cst_list_equal (TREE_VALUE (a),
5062                                                  TREE_VALUE (a2)) == 1)
5063                         break;
5064                     }
5065                   else if (simple_cst_equal (TREE_VALUE (a),
5066                                              TREE_VALUE (a2)) == 1)
5067                     break;
5068                 }
5069               if (a == NULL_TREE)
5070                 {
5071                   a1 = copy_node (a2);
5072                   TREE_CHAIN (a1) = attributes;
5073                   attributes = a1;
5074                 }
5075             }
5076         }
5077     }
5078   return attributes;
5079 }
5080
5081 /* Given types T1 and T2, merge their attributes and return
5082   the result.  */
5083
5084 tree
5085 merge_type_attributes (tree t1, tree t2)
5086 {
5087   return merge_attributes (TYPE_ATTRIBUTES (t1),
5088                            TYPE_ATTRIBUTES (t2));
5089 }
5090
5091 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
5092    the result.  */
5093
5094 tree
5095 merge_decl_attributes (tree olddecl, tree newdecl)
5096 {
5097   return merge_attributes (DECL_ATTRIBUTES (olddecl),
5098                            DECL_ATTRIBUTES (newdecl));
5099 }
5100
5101 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5102
5103 /* Specialization of merge_decl_attributes for various Windows targets.
5104
5105    This handles the following situation:
5106
5107      __declspec (dllimport) int foo;
5108      int foo;
5109
5110    The second instance of `foo' nullifies the dllimport.  */
5111
5112 tree
5113 merge_dllimport_decl_attributes (tree old, tree new_tree)
5114 {
5115   tree a;
5116   int delete_dllimport_p = 1;
5117
5118   /* What we need to do here is remove from `old' dllimport if it doesn't
5119      appear in `new'.  dllimport behaves like extern: if a declaration is
5120      marked dllimport and a definition appears later, then the object
5121      is not dllimport'd.  We also remove a `new' dllimport if the old list
5122      contains dllexport:  dllexport always overrides dllimport, regardless
5123      of the order of declaration.  */
5124   if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5125     delete_dllimport_p = 0;
5126   else if (DECL_DLLIMPORT_P (new_tree)
5127            && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5128     {
5129       DECL_DLLIMPORT_P (new_tree) = 0;
5130       warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5131               "dllimport ignored", new_tree);
5132     }
5133   else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5134     {
5135       /* Warn about overriding a symbol that has already been used, e.g.:
5136            extern int __attribute__ ((dllimport)) foo;
5137            int* bar () {return &foo;}
5138            int foo;
5139       */
5140       if (TREE_USED (old))
5141         {
5142           warning (0, "%q+D redeclared without dllimport attribute "
5143                    "after being referenced with dll linkage", new_tree);
5144           /* If we have used a variable's address with dllimport linkage,
5145               keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5146               decl may already have had TREE_CONSTANT computed.
5147               We still remove the attribute so that assembler code refers
5148               to '&foo rather than '_imp__foo'.  */
5149           if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5150             DECL_DLLIMPORT_P (new_tree) = 1;
5151         }
5152
5153       /* Let an inline definition silently override the external reference,
5154          but otherwise warn about attribute inconsistency.  */
5155       else if (TREE_CODE (new_tree) == VAR_DECL
5156                || !DECL_DECLARED_INLINE_P (new_tree))
5157         warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5158                   "previous dllimport ignored", new_tree);
5159     }
5160   else
5161     delete_dllimport_p = 0;
5162
5163   a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5164
5165   if (delete_dllimport_p)
5166     {
5167       tree prev, t;
5168       const size_t attr_len = strlen ("dllimport");
5169
5170       /* Scan the list for dllimport and delete it.  */
5171       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
5172         {
5173           if (is_attribute_with_length_p ("dllimport", attr_len,
5174                                           TREE_PURPOSE (t)))
5175             {
5176               if (prev == NULL_TREE)
5177                 a = TREE_CHAIN (a);
5178               else
5179                 TREE_CHAIN (prev) = TREE_CHAIN (t);
5180               break;
5181             }
5182         }
5183     }
5184
5185   return a;
5186 }
5187
5188 /* Handle a "dllimport" or "dllexport" attribute; arguments as in
5189    struct attribute_spec.handler.  */
5190
5191 tree
5192 handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5193                       bool *no_add_attrs)
5194 {
5195   tree node = *pnode;
5196   bool is_dllimport;
5197
5198   /* These attributes may apply to structure and union types being created,
5199      but otherwise should pass to the declaration involved.  */
5200   if (!DECL_P (node))
5201     {
5202       if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5203                    | (int) ATTR_FLAG_ARRAY_NEXT))
5204         {
5205           *no_add_attrs = true;
5206           return tree_cons (name, args, NULL_TREE);
5207         }
5208       if (TREE_CODE (node) == RECORD_TYPE
5209           || TREE_CODE (node) == UNION_TYPE)
5210         {
5211           node = TYPE_NAME (node);
5212           if (!node)
5213             return NULL_TREE;
5214         }
5215       else
5216         {
5217           warning (OPT_Wattributes, "%qE attribute ignored",
5218                    name);
5219           *no_add_attrs = true;
5220           return NULL_TREE;
5221         }
5222     }
5223
5224   if (TREE_CODE (node) != FUNCTION_DECL
5225       && TREE_CODE (node) != VAR_DECL
5226       && TREE_CODE (node) != TYPE_DECL)
5227     {
5228       *no_add_attrs = true;
5229       warning (OPT_Wattributes, "%qE attribute ignored",
5230                name);
5231       return NULL_TREE;
5232     }
5233
5234   if (TREE_CODE (node) == TYPE_DECL
5235       && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5236       && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5237     {
5238       *no_add_attrs = true;
5239       warning (OPT_Wattributes, "%qE attribute ignored",
5240                name);
5241       return NULL_TREE;
5242     }
5243
5244   is_dllimport = is_attribute_p ("dllimport", name);
5245
5246   /* Report error on dllimport ambiguities seen now before they cause
5247      any damage.  */
5248   if (is_dllimport)
5249     {
5250       /* Honor any target-specific overrides. */
5251       if (!targetm.valid_dllimport_attribute_p (node))
5252         *no_add_attrs = true;
5253
5254      else if (TREE_CODE (node) == FUNCTION_DECL
5255                 && DECL_DECLARED_INLINE_P (node))
5256         {
5257           warning (OPT_Wattributes, "inline function %q+D declared as "
5258                   " dllimport: attribute ignored", node);
5259           *no_add_attrs = true;
5260         }
5261       /* Like MS, treat definition of dllimported variables and
5262          non-inlined functions on declaration as syntax errors. */
5263      else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
5264         {
5265           error ("function %q+D definition is marked dllimport", node);
5266           *no_add_attrs = true;
5267         }
5268
5269      else if (TREE_CODE (node) == VAR_DECL)
5270         {
5271           if (DECL_INITIAL (node))
5272             {
5273               error ("variable %q+D definition is marked dllimport",
5274                      node);
5275               *no_add_attrs = true;
5276             }
5277
5278           /* `extern' needn't be specified with dllimport.
5279              Specify `extern' now and hope for the best.  Sigh.  */
5280           DECL_EXTERNAL (node) = 1;
5281           /* Also, implicitly give dllimport'd variables declared within
5282              a function global scope, unless declared static.  */
5283           if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
5284             TREE_PUBLIC (node) = 1;
5285         }
5286
5287       if (*no_add_attrs == false)
5288         DECL_DLLIMPORT_P (node) = 1;
5289     }
5290   else if (TREE_CODE (node) == FUNCTION_DECL
5291            && DECL_DECLARED_INLINE_P (node))
5292     /* An exported function, even if inline, must be emitted.  */
5293     DECL_EXTERNAL (node) = 0;
5294
5295   /*  Report error if symbol is not accessible at global scope.  */
5296   if (!TREE_PUBLIC (node)
5297       && (TREE_CODE (node) == VAR_DECL
5298           || TREE_CODE (node) == FUNCTION_DECL))
5299     {
5300       error ("external linkage required for symbol %q+D because of "
5301              "%qE attribute", node, name);
5302       *no_add_attrs = true;
5303     }
5304
5305   /* A dllexport'd entity must have default visibility so that other
5306      program units (shared libraries or the main executable) can see
5307      it.  A dllimport'd entity must have default visibility so that
5308      the linker knows that undefined references within this program
5309      unit can be resolved by the dynamic linker.  */
5310   if (!*no_add_attrs)
5311     {
5312       if (DECL_VISIBILITY_SPECIFIED (node)
5313           && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
5314         error ("%qE implies default visibility, but %qD has already "
5315                "been declared with a different visibility",
5316                name, node);
5317       DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
5318       DECL_VISIBILITY_SPECIFIED (node) = 1;
5319     }
5320
5321   return NULL_TREE;
5322 }
5323
5324 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
5325 \f
5326 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5327    of the various TYPE_QUAL values.  */
5328
5329 static void
5330 set_type_quals (tree type, int type_quals)
5331 {
5332   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5333   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5334   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5335 }
5336
5337 /* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
5338
5339 bool
5340 check_qualified_type (const_tree cand, const_tree base, int type_quals)
5341 {
5342   return (TYPE_QUALS (cand) == type_quals
5343           && TYPE_NAME (cand) == TYPE_NAME (base)
5344           /* Apparently this is needed for Objective-C.  */
5345           && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5346           && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5347                                    TYPE_ATTRIBUTES (base)));
5348 }
5349
5350 /* Return a version of the TYPE, qualified as indicated by the
5351    TYPE_QUALS, if one exists.  If no qualified version exists yet,
5352    return NULL_TREE.  */
5353
5354 tree
5355 get_qualified_type (tree type, int type_quals)
5356 {
5357   tree t;
5358
5359   if (TYPE_QUALS (type) == type_quals)
5360     return type;
5361
5362   /* Search the chain of variants to see if there is already one there just
5363      like the one we need to have.  If so, use that existing one.  We must
5364      preserve the TYPE_NAME, since there is code that depends on this.  */
5365   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5366     if (check_qualified_type (t, type, type_quals))
5367       return t;
5368
5369   return NULL_TREE;
5370 }
5371
5372 /* Like get_qualified_type, but creates the type if it does not
5373    exist.  This function never returns NULL_TREE.  */
5374
5375 tree
5376 build_qualified_type (tree type, int type_quals)
5377 {
5378   tree t;
5379
5380   /* See if we already have the appropriate qualified variant.  */
5381   t = get_qualified_type (type, type_quals);
5382
5383   /* If not, build it.  */
5384   if (!t)
5385     {
5386       t = build_variant_type_copy (type);
5387       set_type_quals (t, type_quals);
5388
5389       if (TYPE_STRUCTURAL_EQUALITY_P (type))
5390         /* Propagate structural equality. */
5391         SET_TYPE_STRUCTURAL_EQUALITY (t);
5392       else if (TYPE_CANONICAL (type) != type)
5393         /* Build the underlying canonical type, since it is different
5394            from TYPE. */
5395         TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
5396                                                    type_quals);
5397       else
5398         /* T is its own canonical type. */
5399         TYPE_CANONICAL (t) = t;
5400
5401     }
5402
5403   return t;
5404 }
5405
5406 /* Create a new distinct copy of TYPE.  The new type is made its own
5407    MAIN_VARIANT. If TYPE requires structural equality checks, the
5408    resulting type requires structural equality checks; otherwise, its
5409    TYPE_CANONICAL points to itself. */
5410
5411 tree
5412 build_distinct_type_copy (tree type)
5413 {
5414   tree t = copy_node (type);
5415
5416   TYPE_POINTER_TO (t) = 0;
5417   TYPE_REFERENCE_TO (t) = 0;
5418
5419   /* Set the canonical type either to a new equivalence class, or
5420      propagate the need for structural equality checks. */
5421   if (TYPE_STRUCTURAL_EQUALITY_P (type))
5422     SET_TYPE_STRUCTURAL_EQUALITY (t);
5423   else
5424     TYPE_CANONICAL (t) = t;
5425
5426   /* Make it its own variant.  */
5427   TYPE_MAIN_VARIANT (t) = t;
5428   TYPE_NEXT_VARIANT (t) = 0;
5429
5430   /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5431      whose TREE_TYPE is not t.  This can also happen in the Ada
5432      frontend when using subtypes.  */
5433
5434   return t;
5435 }
5436
5437 /* Create a new variant of TYPE, equivalent but distinct.  This is so
5438    the caller can modify it. TYPE_CANONICAL for the return type will
5439    be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5440    are considered equal by the language itself (or that both types
5441    require structural equality checks). */
5442
5443 tree
5444 build_variant_type_copy (tree type)
5445 {
5446   tree t, m = TYPE_MAIN_VARIANT (type);
5447
5448   t = build_distinct_type_copy (type);
5449
5450   /* Since we're building a variant, assume that it is a non-semantic
5451      variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5452   TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
5453
5454   /* Add the new type to the chain of variants of TYPE.  */
5455   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
5456   TYPE_NEXT_VARIANT (m) = t;
5457   TYPE_MAIN_VARIANT (t) = m;
5458
5459   return t;
5460 }
5461 \f
5462 /* Return true if the from tree in both tree maps are equal.  */
5463
5464 int
5465 tree_map_base_eq (const void *va, const void *vb)
5466 {
5467   const struct tree_map_base  *const a = (const struct tree_map_base *) va,
5468     *const b = (const struct tree_map_base *) vb;
5469   return (a->from == b->from);
5470 }
5471
5472 /* Hash a from tree in a tree_map.  */
5473
5474 unsigned int
5475 tree_map_base_hash (const void *item)
5476 {
5477   return htab_hash_pointer (((const struct tree_map_base *)item)->from);
5478 }
5479
5480 /* Return true if this tree map structure is marked for garbage collection
5481    purposes.  We simply return true if the from tree is marked, so that this
5482    structure goes away when the from tree goes away.  */
5483
5484 int
5485 tree_map_base_marked_p (const void *p)
5486 {
5487   return ggc_marked_p (((const struct tree_map_base *) p)->from);
5488 }
5489
5490 unsigned int
5491 tree_map_hash (const void *item)
5492 {
5493   return (((const struct tree_map *) item)->hash);
5494 }
5495
5496 /* Return the initialization priority for DECL.  */
5497
5498 priority_type
5499 decl_init_priority_lookup (tree decl)
5500 {
5501   struct tree_priority_map *h;
5502   struct tree_map_base in;
5503
5504   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5505   in.from = decl;
5506   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5507   return h ? h->init : DEFAULT_INIT_PRIORITY;
5508 }
5509
5510 /* Return the finalization priority for DECL.  */
5511
5512 priority_type
5513 decl_fini_priority_lookup (tree decl)
5514 {
5515   struct tree_priority_map *h;
5516   struct tree_map_base in;
5517
5518   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5519   in.from = decl;
5520   h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5521   return h ? h->fini : DEFAULT_INIT_PRIORITY;
5522 }
5523
5524 /* Return the initialization and finalization priority information for
5525    DECL.  If there is no previous priority information, a freshly
5526    allocated structure is returned.  */
5527
5528 static struct tree_priority_map *
5529 decl_priority_info (tree decl)
5530 {
5531   struct tree_priority_map in;
5532   struct tree_priority_map *h;
5533   void **loc;
5534
5535   in.base.from = decl;
5536   loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
5537   h = (struct tree_priority_map *) *loc;
5538   if (!h)
5539     {
5540       h = GGC_CNEW (struct tree_priority_map);
5541       *loc = h;
5542       h->base.from = decl;
5543       h->init = DEFAULT_INIT_PRIORITY;
5544       h->fini = DEFAULT_INIT_PRIORITY;
5545     }
5546
5547   return h;
5548 }
5549
5550 /* Set the initialization priority for DECL to PRIORITY.  */
5551
5552 void
5553 decl_init_priority_insert (tree decl, priority_type priority)
5554 {
5555   struct tree_priority_map *h;
5556
5557   gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5558   h = decl_priority_info (decl);
5559   h->init = priority;
5560 }
5561
5562 /* Set the finalization priority for DECL to PRIORITY.  */
5563
5564 void
5565 decl_fini_priority_insert (tree decl, priority_type priority)
5566 {
5567   struct tree_priority_map *h;
5568
5569   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5570   h = decl_priority_info (decl);
5571   h->fini = priority;
5572 }
5573
5574 /* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
5575
5576 static void
5577 print_debug_expr_statistics (void)
5578 {
5579   fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5580            (long) htab_size (debug_expr_for_decl),
5581            (long) htab_elements (debug_expr_for_decl),
5582            htab_collisions (debug_expr_for_decl));
5583 }
5584
5585 /* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
5586
5587 static void
5588 print_value_expr_statistics (void)
5589 {
5590   fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5591            (long) htab_size (value_expr_for_decl),
5592            (long) htab_elements (value_expr_for_decl),
5593            htab_collisions (value_expr_for_decl));
5594 }
5595
5596 /* Lookup a debug expression for FROM, and return it if we find one.  */
5597
5598 tree
5599 decl_debug_expr_lookup (tree from)
5600 {
5601   struct tree_map *h, in;
5602   in.base.from = from;
5603
5604   h = (struct tree_map *) htab_find_with_hash (debug_expr_for_decl, &in,
5605                                                htab_hash_pointer (from));
5606   if (h)
5607     return h->to;
5608   return NULL_TREE;
5609 }
5610
5611 /* Insert a mapping FROM->TO in the debug expression hashtable.  */
5612
5613 void
5614 decl_debug_expr_insert (tree from, tree to)
5615 {
5616   struct tree_map *h;
5617   void **loc;
5618
5619   h = GGC_NEW (struct tree_map);
5620   h->hash = htab_hash_pointer (from);
5621   h->base.from = from;
5622   h->to = to;
5623   loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
5624   *(struct tree_map **) loc = h;
5625 }
5626
5627 /* Lookup a value expression for FROM, and return it if we find one.  */
5628
5629 tree
5630 decl_value_expr_lookup (tree from)
5631 {
5632   struct tree_map *h, in;
5633   in.base.from = from;
5634
5635   h = (struct tree_map *) htab_find_with_hash (value_expr_for_decl, &in,
5636                                                htab_hash_pointer (from));
5637   if (h)
5638     return h->to;
5639   return NULL_TREE;
5640 }
5641
5642 /* Insert a mapping FROM->TO in the value expression hashtable.  */
5643
5644 void
5645 decl_value_expr_insert (tree from, tree to)
5646 {
5647   struct tree_map *h;
5648   void **loc;
5649
5650   h = GGC_NEW (struct tree_map);
5651   h->hash = htab_hash_pointer (from);
5652   h->base.from = from;
5653   h->to = to;
5654   loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
5655   *(struct tree_map **) loc = h;
5656 }
5657
5658 /* Hashing of types so that we don't make duplicates.
5659    The entry point is `type_hash_canon'.  */
5660
5661 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
5662    with types in the TREE_VALUE slots), by adding the hash codes
5663    of the individual types.  */
5664
5665 static unsigned int
5666 type_hash_list (const_tree list, hashval_t hashcode)
5667 {
5668   const_tree tail;
5669
5670   for (tail = list; tail; tail = TREE_CHAIN (tail))
5671     if (TREE_VALUE (tail) != error_mark_node)
5672       hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
5673                                         hashcode);
5674
5675   return hashcode;
5676 }
5677
5678 /* These are the Hashtable callback functions.  */
5679
5680 /* Returns true iff the types are equivalent.  */
5681
5682 static int
5683 type_hash_eq (const void *va, const void *vb)
5684 {
5685   const struct type_hash *const a = (const struct type_hash *) va,
5686     *const b = (const struct type_hash *) vb;
5687
5688   /* First test the things that are the same for all types.  */
5689   if (a->hash != b->hash
5690       || TREE_CODE (a->type) != TREE_CODE (b->type)
5691       || TREE_TYPE (a->type) != TREE_TYPE (b->type)
5692       || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
5693                                  TYPE_ATTRIBUTES (b->type))
5694       || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
5695       || TYPE_MODE (a->type) != TYPE_MODE (b->type)
5696       || (TREE_CODE (a->type) != COMPLEX_TYPE
5697           && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
5698     return 0;
5699
5700   switch (TREE_CODE (a->type))
5701     {
5702     case VOID_TYPE:
5703     case COMPLEX_TYPE:
5704     case POINTER_TYPE:
5705     case REFERENCE_TYPE:
5706       return 1;
5707
5708     case VECTOR_TYPE:
5709       return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
5710
5711     case ENUMERAL_TYPE:
5712       if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
5713           && !(TYPE_VALUES (a->type)
5714                && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
5715                && TYPE_VALUES (b->type)
5716                && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
5717                && type_list_equal (TYPE_VALUES (a->type),
5718                                    TYPE_VALUES (b->type))))
5719         return 0;
5720
5721       /* ... fall through ... */
5722
5723     case INTEGER_TYPE:
5724     case REAL_TYPE:
5725     case BOOLEAN_TYPE:
5726       return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
5727                || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
5728                                       TYPE_MAX_VALUE (b->type)))
5729               && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
5730                   || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
5731                                          TYPE_MIN_VALUE (b->type))));
5732
5733     case FIXED_POINT_TYPE:
5734       return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
5735
5736     case OFFSET_TYPE:
5737       return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
5738
5739     case METHOD_TYPE:
5740       return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
5741               && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5742                   || (TYPE_ARG_TYPES (a->type)
5743                       && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5744                       && TYPE_ARG_TYPES (b->type)
5745                       && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5746                       && type_list_equal (TYPE_ARG_TYPES (a->type),
5747                                           TYPE_ARG_TYPES (b->type)))));
5748
5749     case ARRAY_TYPE:
5750       return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
5751
5752     case RECORD_TYPE:
5753     case UNION_TYPE:
5754     case QUAL_UNION_TYPE:
5755       return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
5756               || (TYPE_FIELDS (a->type)
5757                   && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
5758                   && TYPE_FIELDS (b->type)
5759                   && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
5760                   && type_list_equal (TYPE_FIELDS (a->type),
5761                                       TYPE_FIELDS (b->type))));
5762
5763     case FUNCTION_TYPE:
5764       if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5765           || (TYPE_ARG_TYPES (a->type)
5766               && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5767               && TYPE_ARG_TYPES (b->type)
5768               && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5769               && type_list_equal (TYPE_ARG_TYPES (a->type),
5770                                   TYPE_ARG_TYPES (b->type))))
5771         break;
5772       return 0;
5773
5774     default:
5775       return 0;
5776     }
5777
5778   if (lang_hooks.types.type_hash_eq != NULL)
5779     return lang_hooks.types.type_hash_eq (a->type, b->type);
5780
5781   return 1;
5782 }
5783
5784 /* Return the cached hash value.  */
5785
5786 static hashval_t
5787 type_hash_hash (const void *item)
5788 {
5789   return ((const struct type_hash *) item)->hash;
5790 }
5791
5792 /* Look in the type hash table for a type isomorphic to TYPE.
5793    If one is found, return it.  Otherwise return 0.  */
5794
5795 tree
5796 type_hash_lookup (hashval_t hashcode, tree type)
5797 {
5798   struct type_hash *h, in;
5799
5800   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
5801      must call that routine before comparing TYPE_ALIGNs.  */
5802   layout_type (type);
5803
5804   in.hash = hashcode;
5805   in.type = type;
5806
5807   h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
5808                                                 hashcode);
5809   if (h)
5810     return h->type;
5811   return NULL_TREE;
5812 }
5813
5814 /* Add an entry to the type-hash-table
5815    for a type TYPE whose hash code is HASHCODE.  */
5816
5817 void
5818 type_hash_add (hashval_t hashcode, tree type)
5819 {
5820   struct type_hash *h;
5821   void **loc;
5822
5823   h = GGC_NEW (struct type_hash);
5824   h->hash = hashcode;
5825   h->type = type;
5826   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
5827   *loc = (void *)h;
5828 }
5829
5830 /* Given TYPE, and HASHCODE its hash code, return the canonical
5831    object for an identical type if one already exists.
5832    Otherwise, return TYPE, and record it as the canonical object.
5833
5834    To use this function, first create a type of the sort you want.
5835    Then compute its hash code from the fields of the type that
5836    make it different from other similar types.
5837    Then call this function and use the value.  */
5838
5839 tree
5840 type_hash_canon (unsigned int hashcode, tree type)
5841 {
5842   tree t1;
5843
5844   /* The hash table only contains main variants, so ensure that's what we're
5845      being passed.  */
5846   gcc_assert (TYPE_MAIN_VARIANT (type) == type);
5847
5848   if (!lang_hooks.types.hash_types)
5849     return type;
5850
5851   /* See if the type is in the hash table already.  If so, return it.
5852      Otherwise, add the type.  */
5853   t1 = type_hash_lookup (hashcode, type);
5854   if (t1 != 0)
5855     {
5856 #ifdef GATHER_STATISTICS
5857       tree_node_counts[(int) t_kind]--;
5858       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
5859 #endif
5860       return t1;
5861     }
5862   else
5863     {
5864       type_hash_add (hashcode, type);
5865       return type;
5866     }
5867 }
5868
5869 /* See if the data pointed to by the type hash table is marked.  We consider
5870    it marked if the type is marked or if a debug type number or symbol
5871    table entry has been made for the type.  This reduces the amount of
5872    debugging output and eliminates that dependency of the debug output on
5873    the number of garbage collections.  */
5874
5875 static int
5876 type_hash_marked_p (const void *p)
5877 {
5878   const_tree const type = ((const struct type_hash *) p)->type;
5879
5880   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
5881 }
5882
5883 static void
5884 print_type_hash_statistics (void)
5885 {
5886   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
5887            (long) htab_size (type_hash_table),
5888            (long) htab_elements (type_hash_table),
5889            htab_collisions (type_hash_table));
5890 }
5891
5892 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
5893    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
5894    by adding the hash codes of the individual attributes.  */
5895
5896 static unsigned int
5897 attribute_hash_list (const_tree list, hashval_t hashcode)
5898 {
5899   const_tree tail;
5900
5901   for (tail = list; tail; tail = TREE_CHAIN (tail))
5902     /* ??? Do we want to add in TREE_VALUE too? */
5903     hashcode = iterative_hash_object
5904       (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
5905   return hashcode;
5906 }
5907
5908 /* Given two lists of attributes, return true if list l2 is
5909    equivalent to l1.  */
5910
5911 int
5912 attribute_list_equal (const_tree l1, const_tree l2)
5913 {
5914   return attribute_list_contained (l1, l2)
5915          && attribute_list_contained (l2, l1);
5916 }
5917
5918 /* Given two lists of attributes, return true if list L2 is
5919    completely contained within L1.  */
5920 /* ??? This would be faster if attribute names were stored in a canonicalized
5921    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
5922    must be used to show these elements are equivalent (which they are).  */
5923 /* ??? It's not clear that attributes with arguments will always be handled
5924    correctly.  */
5925
5926 int
5927 attribute_list_contained (const_tree l1, const_tree l2)
5928 {
5929   const_tree t1, t2;
5930
5931   /* First check the obvious, maybe the lists are identical.  */
5932   if (l1 == l2)
5933     return 1;
5934
5935   /* Maybe the lists are similar.  */
5936   for (t1 = l1, t2 = l2;
5937        t1 != 0 && t2 != 0
5938         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
5939         && TREE_VALUE (t1) == TREE_VALUE (t2);
5940        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
5941
5942   /* Maybe the lists are equal.  */
5943   if (t1 == 0 && t2 == 0)
5944     return 1;
5945
5946   for (; t2 != 0; t2 = TREE_CHAIN (t2))
5947     {
5948       const_tree attr;
5949       /* This CONST_CAST is okay because lookup_attribute does not
5950          modify its argument and the return value is assigned to a
5951          const_tree.  */
5952       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
5953                                     CONST_CAST_TREE(l1));
5954            attr != NULL_TREE;
5955            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
5956                                     TREE_CHAIN (attr)))
5957         {
5958           if (TREE_VALUE (t2) != NULL
5959               && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
5960               && TREE_VALUE (attr) != NULL
5961               && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
5962             {
5963               if (simple_cst_list_equal (TREE_VALUE (t2),
5964                                          TREE_VALUE (attr)) == 1)
5965                 break;
5966             }
5967           else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
5968             break;
5969         }
5970
5971       if (attr == 0)
5972         return 0;
5973     }
5974
5975   return 1;
5976 }
5977
5978 /* Given two lists of types
5979    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
5980    return 1 if the lists contain the same types in the same order.
5981    Also, the TREE_PURPOSEs must match.  */
5982
5983 int
5984 type_list_equal (const_tree l1, const_tree l2)
5985 {
5986   const_tree t1, t2;
5987
5988   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
5989     if (TREE_VALUE (t1) != TREE_VALUE (t2)
5990         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
5991             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
5992                   && (TREE_TYPE (TREE_PURPOSE (t1))
5993                       == TREE_TYPE (TREE_PURPOSE (t2))))))
5994       return 0;
5995
5996   return t1 == t2;
5997 }
5998
5999 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6000    given by TYPE.  If the argument list accepts variable arguments,
6001    then this function counts only the ordinary arguments.  */
6002
6003 int
6004 type_num_arguments (const_tree type)
6005 {
6006   int i = 0;
6007   tree t;
6008
6009   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6010     /* If the function does not take a variable number of arguments,
6011        the last element in the list will have type `void'.  */
6012     if (VOID_TYPE_P (TREE_VALUE (t)))
6013       break;
6014     else
6015       ++i;
6016
6017   return i;
6018 }
6019
6020 /* Nonzero if integer constants T1 and T2
6021    represent the same constant value.  */
6022
6023 int
6024 tree_int_cst_equal (const_tree t1, const_tree t2)
6025 {
6026   if (t1 == t2)
6027     return 1;
6028
6029   if (t1 == 0 || t2 == 0)
6030     return 0;
6031
6032   if (TREE_CODE (t1) == INTEGER_CST
6033       && TREE_CODE (t2) == INTEGER_CST
6034       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6035       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6036     return 1;
6037
6038   return 0;
6039 }
6040
6041 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6042    The precise way of comparison depends on their data type.  */
6043
6044 int
6045 tree_int_cst_lt (const_tree t1, const_tree t2)
6046 {
6047   if (t1 == t2)
6048     return 0;
6049
6050   if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6051     {
6052       int t1_sgn = tree_int_cst_sgn (t1);
6053       int t2_sgn = tree_int_cst_sgn (t2);
6054
6055       if (t1_sgn < t2_sgn)
6056         return 1;
6057       else if (t1_sgn > t2_sgn)
6058         return 0;
6059       /* Otherwise, both are non-negative, so we compare them as
6060          unsigned just in case one of them would overflow a signed
6061          type.  */
6062     }
6063   else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6064     return INT_CST_LT (t1, t2);
6065
6066   return INT_CST_LT_UNSIGNED (t1, t2);
6067 }
6068
6069 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
6070
6071 int
6072 tree_int_cst_compare (const_tree t1, const_tree t2)
6073 {
6074   if (tree_int_cst_lt (t1, t2))
6075     return -1;
6076   else if (tree_int_cst_lt (t2, t1))
6077     return 1;
6078   else
6079     return 0;
6080 }
6081
6082 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6083    the host.  If POS is zero, the value can be represented in a single
6084    HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
6085    be represented in a single unsigned HOST_WIDE_INT.  */
6086
6087 int
6088 host_integerp (const_tree t, int pos)
6089 {
6090   if (t == NULL_TREE)
6091     return 0;
6092
6093   return (TREE_CODE (t) == INTEGER_CST
6094           && ((TREE_INT_CST_HIGH (t) == 0
6095                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6096               || (! pos && TREE_INT_CST_HIGH (t) == -1
6097                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6098                   && (!TYPE_UNSIGNED (TREE_TYPE (t))
6099                       || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6100                           && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
6101               || (pos && TREE_INT_CST_HIGH (t) == 0)));
6102 }
6103
6104 /* Return the HOST_WIDE_INT least significant bits of T if it is an
6105    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
6106    be non-negative.  We must be able to satisfy the above conditions.  */
6107
6108 HOST_WIDE_INT
6109 tree_low_cst (const_tree t, int pos)
6110 {
6111   gcc_assert (host_integerp (t, pos));
6112   return TREE_INT_CST_LOW (t);
6113 }
6114
6115 /* Return the most significant bit of the integer constant T.  */
6116
6117 int
6118 tree_int_cst_msb (const_tree t)
6119 {
6120   int prec;
6121   HOST_WIDE_INT h;
6122   unsigned HOST_WIDE_INT l;
6123
6124   /* Note that using TYPE_PRECISION here is wrong.  We care about the
6125      actual bits, not the (arbitrary) range of the type.  */
6126   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
6127   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
6128                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
6129   return (l & 1) == 1;
6130 }
6131
6132 /* Return an indication of the sign of the integer constant T.
6133    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6134    Note that -1 will never be returned if T's type is unsigned.  */
6135
6136 int
6137 tree_int_cst_sgn (const_tree t)
6138 {
6139   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
6140     return 0;
6141   else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6142     return 1;
6143   else if (TREE_INT_CST_HIGH (t) < 0)
6144     return -1;
6145   else
6146     return 1;
6147 }
6148
6149 /* Return the minimum number of bits needed to represent VALUE in a
6150    signed or unsigned type, UNSIGNEDP says which.  */
6151
6152 unsigned int
6153 tree_int_cst_min_precision (tree value, bool unsignedp)
6154 {
6155   int log;
6156
6157   /* If the value is negative, compute its negative minus 1.  The latter
6158      adjustment is because the absolute value of the largest negative value
6159      is one larger than the largest positive value.  This is equivalent to
6160      a bit-wise negation, so use that operation instead.  */
6161
6162   if (tree_int_cst_sgn (value) < 0)
6163     value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6164
6165   /* Return the number of bits needed, taking into account the fact
6166      that we need one more bit for a signed than unsigned type.  */
6167
6168   if (integer_zerop (value))
6169     log = 0;
6170   else
6171     log = tree_floor_log2 (value);
6172
6173   return log + 1 + !unsignedp;
6174 }
6175
6176 /* Compare two constructor-element-type constants.  Return 1 if the lists
6177    are known to be equal; otherwise return 0.  */
6178
6179 int
6180 simple_cst_list_equal (const_tree l1, const_tree l2)
6181 {
6182   while (l1 != NULL_TREE && l2 != NULL_TREE)
6183     {
6184       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
6185         return 0;
6186
6187       l1 = TREE_CHAIN (l1);
6188       l2 = TREE_CHAIN (l2);
6189     }
6190
6191   return l1 == l2;
6192 }
6193
6194 /* Return truthvalue of whether T1 is the same tree structure as T2.
6195    Return 1 if they are the same.
6196    Return 0 if they are understandably different.
6197    Return -1 if either contains tree structure not understood by
6198    this function.  */
6199
6200 int
6201 simple_cst_equal (const_tree t1, const_tree t2)
6202 {
6203   enum tree_code code1, code2;
6204   int cmp;
6205   int i;
6206
6207   if (t1 == t2)
6208     return 1;
6209   if (t1 == 0 || t2 == 0)
6210     return 0;
6211
6212   code1 = TREE_CODE (t1);
6213   code2 = TREE_CODE (t2);
6214
6215   if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6216     {
6217       if (CONVERT_EXPR_CODE_P (code2)
6218           || code2 == NON_LVALUE_EXPR)
6219         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6220       else
6221         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6222     }
6223
6224   else if (CONVERT_EXPR_CODE_P (code2)
6225            || code2 == NON_LVALUE_EXPR)
6226     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6227
6228   if (code1 != code2)
6229     return 0;
6230
6231   switch (code1)
6232     {
6233     case INTEGER_CST:
6234       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6235               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
6236
6237     case REAL_CST:
6238       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
6239
6240     case FIXED_CST:
6241       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6242
6243     case STRING_CST:
6244       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6245               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6246                          TREE_STRING_LENGTH (t1)));
6247
6248     case CONSTRUCTOR:
6249       {
6250         unsigned HOST_WIDE_INT idx;
6251         VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
6252         VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
6253
6254         if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
6255           return false;
6256
6257         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
6258           /* ??? Should we handle also fields here? */
6259           if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
6260                                  VEC_index (constructor_elt, v2, idx)->value))
6261             return false;
6262         return true;
6263       }
6264
6265     case SAVE_EXPR:
6266       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6267
6268     case CALL_EXPR:
6269       cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6270       if (cmp <= 0)
6271         return cmp;
6272       if (call_expr_nargs (t1) != call_expr_nargs (t2))
6273         return 0;
6274       {
6275         const_tree arg1, arg2;
6276         const_call_expr_arg_iterator iter1, iter2;
6277         for (arg1 = first_const_call_expr_arg (t1, &iter1),
6278                arg2 = first_const_call_expr_arg (t2, &iter2);
6279              arg1 && arg2;
6280              arg1 = next_const_call_expr_arg (&iter1),
6281                arg2 = next_const_call_expr_arg (&iter2))
6282           {
6283             cmp = simple_cst_equal (arg1, arg2);
6284             if (cmp <= 0)
6285               return cmp;
6286           }
6287         return arg1 == arg2;
6288       }
6289
6290     case TARGET_EXPR:
6291       /* Special case: if either target is an unallocated VAR_DECL,
6292          it means that it's going to be unified with whatever the
6293          TARGET_EXPR is really supposed to initialize, so treat it
6294          as being equivalent to anything.  */
6295       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6296            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6297            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6298           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6299               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6300               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6301         cmp = 1;
6302       else
6303         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6304
6305       if (cmp <= 0)
6306         return cmp;
6307
6308       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6309
6310     case WITH_CLEANUP_EXPR:
6311       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6312       if (cmp <= 0)
6313         return cmp;
6314
6315       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6316
6317     case COMPONENT_REF:
6318       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6319         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6320
6321       return 0;
6322
6323     case VAR_DECL:
6324     case PARM_DECL:
6325     case CONST_DECL:
6326     case FUNCTION_DECL:
6327       return 0;
6328
6329     default:
6330       break;
6331     }
6332
6333   /* This general rule works for most tree codes.  All exceptions should be
6334      handled above.  If this is a language-specific tree code, we can't
6335      trust what might be in the operand, so say we don't know
6336      the situation.  */
6337   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
6338     return -1;
6339
6340   switch (TREE_CODE_CLASS (code1))
6341     {
6342     case tcc_unary:
6343     case tcc_binary:
6344     case tcc_comparison:
6345     case tcc_expression:
6346     case tcc_reference:
6347     case tcc_statement:
6348       cmp = 1;
6349       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
6350         {
6351           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
6352           if (cmp <= 0)
6353             return cmp;
6354         }
6355
6356       return cmp;
6357
6358     default:
6359       return -1;
6360     }
6361 }
6362
6363 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6364    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6365    than U, respectively.  */
6366
6367 int
6368 compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
6369 {
6370   if (tree_int_cst_sgn (t) < 0)
6371     return -1;
6372   else if (TREE_INT_CST_HIGH (t) != 0)
6373     return 1;
6374   else if (TREE_INT_CST_LOW (t) == u)
6375     return 0;
6376   else if (TREE_INT_CST_LOW (t) < u)
6377     return -1;
6378   else
6379     return 1;
6380 }
6381
6382 /* Return true if CODE represents an associative tree code.  Otherwise
6383    return false.  */
6384 bool
6385 associative_tree_code (enum tree_code code)
6386 {
6387   switch (code)
6388     {
6389     case BIT_IOR_EXPR:
6390     case BIT_AND_EXPR:
6391     case BIT_XOR_EXPR:
6392     case PLUS_EXPR:
6393     case MULT_EXPR:
6394     case MIN_EXPR:
6395     case MAX_EXPR:
6396       return true;
6397
6398     default:
6399       break;
6400     }
6401   return false;
6402 }
6403
6404 /* Return true if CODE represents a commutative tree code.  Otherwise
6405    return false.  */
6406 bool
6407 commutative_tree_code (enum tree_code code)
6408 {
6409   switch (code)
6410     {
6411     case PLUS_EXPR:
6412     case MULT_EXPR:
6413     case MIN_EXPR:
6414     case MAX_EXPR:
6415     case BIT_IOR_EXPR:
6416     case BIT_XOR_EXPR:
6417     case BIT_AND_EXPR:
6418     case NE_EXPR:
6419     case EQ_EXPR:
6420     case UNORDERED_EXPR:
6421     case ORDERED_EXPR:
6422     case UNEQ_EXPR:
6423     case LTGT_EXPR:
6424     case TRUTH_AND_EXPR:
6425     case TRUTH_XOR_EXPR:
6426     case TRUTH_OR_EXPR:
6427       return true;
6428
6429     default:
6430       break;
6431     }
6432   return false;
6433 }
6434
6435 /* Generate a hash value for an expression.  This can be used iteratively
6436    by passing a previous result as the VAL argument.
6437
6438    This function is intended to produce the same hash for expressions which
6439    would compare equal using operand_equal_p.  */
6440
6441 hashval_t
6442 iterative_hash_expr (const_tree t, hashval_t val)
6443 {
6444   int i;
6445   enum tree_code code;
6446   char tclass;
6447
6448   if (t == NULL_TREE)
6449     return iterative_hash_hashval_t (0, val);
6450
6451   code = TREE_CODE (t);
6452
6453   switch (code)
6454     {
6455     /* Alas, constants aren't shared, so we can't rely on pointer
6456        identity.  */
6457     case INTEGER_CST:
6458       val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
6459       return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
6460     case REAL_CST:
6461       {
6462         unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
6463
6464         return iterative_hash_hashval_t (val2, val);
6465       }
6466     case FIXED_CST:
6467       {
6468         unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
6469
6470         return iterative_hash_hashval_t (val2, val);
6471       }
6472     case STRING_CST:
6473       return iterative_hash (TREE_STRING_POINTER (t),
6474                              TREE_STRING_LENGTH (t), val);
6475     case COMPLEX_CST:
6476       val = iterative_hash_expr (TREE_REALPART (t), val);
6477       return iterative_hash_expr (TREE_IMAGPART (t), val);
6478     case VECTOR_CST:
6479       return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
6480
6481     case SSA_NAME:
6482       /* we can just compare by pointer.  */
6483       return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
6484
6485     case TREE_LIST:
6486       /* A list of expressions, for a CALL_EXPR or as the elements of a
6487          VECTOR_CST.  */
6488       for (; t; t = TREE_CHAIN (t))
6489         val = iterative_hash_expr (TREE_VALUE (t), val);
6490       return val;
6491     case CONSTRUCTOR:
6492       {
6493         unsigned HOST_WIDE_INT idx;
6494         tree field, value;
6495         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
6496           {
6497             val = iterative_hash_expr (field, val);
6498             val = iterative_hash_expr (value, val);
6499           }
6500         return val;
6501       }
6502     case FUNCTION_DECL:
6503       /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6504          Otherwise nodes that compare equal according to operand_equal_p might
6505          get different hash codes.  However, don't do this for machine specific
6506          or front end builtins, since the function code is overloaded in those
6507          cases.  */
6508       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
6509           && built_in_decls[DECL_FUNCTION_CODE (t)])
6510         {
6511           t = built_in_decls[DECL_FUNCTION_CODE (t)];
6512           code = TREE_CODE (t);
6513         }
6514       /* FALL THROUGH */
6515     default:
6516       tclass = TREE_CODE_CLASS (code);
6517
6518       if (tclass == tcc_declaration)
6519         {
6520           /* DECL's have a unique ID */
6521           val = iterative_hash_host_wide_int (DECL_UID (t), val);
6522         }
6523       else
6524         {
6525           gcc_assert (IS_EXPR_CODE_CLASS (tclass));
6526
6527           val = iterative_hash_object (code, val);
6528
6529           /* Don't hash the type, that can lead to having nodes which
6530              compare equal according to operand_equal_p, but which
6531              have different hash codes.  */
6532           if (CONVERT_EXPR_CODE_P (code)
6533               || code == NON_LVALUE_EXPR)
6534             {
6535               /* Make sure to include signness in the hash computation.  */
6536               val += TYPE_UNSIGNED (TREE_TYPE (t));
6537               val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6538             }
6539
6540           else if (commutative_tree_code (code))
6541             {
6542               /* It's a commutative expression.  We want to hash it the same
6543                  however it appears.  We do this by first hashing both operands
6544                  and then rehashing based on the order of their independent
6545                  hashes.  */
6546               hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
6547               hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
6548               hashval_t t;
6549
6550               if (one > two)
6551                 t = one, one = two, two = t;
6552
6553               val = iterative_hash_hashval_t (one, val);
6554               val = iterative_hash_hashval_t (two, val);
6555             }
6556           else
6557             for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
6558               val = iterative_hash_expr (TREE_OPERAND (t, i), val);
6559         }
6560       return val;
6561       break;
6562     }
6563 }
6564
6565 /* Generate a hash value for a pair of expressions.  This can be used
6566    iteratively by passing a previous result as the VAL argument.
6567
6568    The same hash value is always returned for a given pair of expressions,
6569    regardless of the order in which they are presented.  This is useful in
6570    hashing the operands of commutative functions.  */
6571
6572 hashval_t
6573 iterative_hash_exprs_commutative (const_tree t1,
6574                                   const_tree t2, hashval_t val)
6575 {
6576   hashval_t one = iterative_hash_expr (t1, 0);
6577   hashval_t two = iterative_hash_expr (t2, 0);
6578   hashval_t t;
6579
6580   if (one > two)
6581     t = one, one = two, two = t;
6582   val = iterative_hash_hashval_t (one, val);
6583   val = iterative_hash_hashval_t (two, val);
6584
6585   return val;
6586 }
6587 \f
6588 /* Constructors for pointer, array and function types.
6589    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6590    constructed by language-dependent code, not here.)  */
6591
6592 /* Construct, lay out and return the type of pointers to TO_TYPE with
6593    mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
6594    reference all of memory. If such a type has already been
6595    constructed, reuse it.  */
6596
6597 tree
6598 build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
6599                              bool can_alias_all)
6600 {
6601   tree t;
6602
6603   if (to_type == error_mark_node)
6604     return error_mark_node;
6605
6606   /* If the pointed-to type has the may_alias attribute set, force
6607      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6608   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6609     can_alias_all = true;
6610
6611   /* In some cases, languages will have things that aren't a POINTER_TYPE
6612      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6613      In that case, return that type without regard to the rest of our
6614      operands.
6615
6616      ??? This is a kludge, but consistent with the way this function has
6617      always operated and there doesn't seem to be a good way to avoid this
6618      at the moment.  */
6619   if (TYPE_POINTER_TO (to_type) != 0
6620       && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
6621     return TYPE_POINTER_TO (to_type);
6622
6623   /* First, if we already have a type for pointers to TO_TYPE and it's
6624      the proper mode, use it.  */
6625   for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
6626     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6627       return t;
6628
6629   t = make_node (POINTER_TYPE);
6630
6631   TREE_TYPE (t) = to_type;
6632   SET_TYPE_MODE (t, mode);
6633   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6634   TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
6635   TYPE_POINTER_TO (to_type) = t;
6636
6637   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6638     SET_TYPE_STRUCTURAL_EQUALITY (t);
6639   else if (TYPE_CANONICAL (to_type) != to_type)
6640     TYPE_CANONICAL (t)
6641       = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
6642                                      mode, can_alias_all);
6643
6644   /* Lay out the type.  This function has many callers that are concerned
6645      with expression-construction, and this simplifies them all.  */
6646   layout_type (t);
6647
6648   return t;
6649 }
6650
6651 /* By default build pointers in ptr_mode.  */
6652
6653 tree
6654 build_pointer_type (tree to_type)
6655 {
6656   return build_pointer_type_for_mode (to_type, ptr_mode, false);
6657 }
6658
6659 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
6660
6661 tree
6662 build_reference_type_for_mode (tree to_type, enum machine_mode mode,
6663                                bool can_alias_all)
6664 {
6665   tree t;
6666
6667   if (to_type == error_mark_node)
6668     return error_mark_node;
6669
6670   /* If the pointed-to type has the may_alias attribute set, force
6671      a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6672   if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6673     can_alias_all = true;
6674
6675   /* In some cases, languages will have things that aren't a REFERENCE_TYPE
6676      (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
6677      In that case, return that type without regard to the rest of our
6678      operands.
6679
6680      ??? This is a kludge, but consistent with the way this function has
6681      always operated and there doesn't seem to be a good way to avoid this
6682      at the moment.  */
6683   if (TYPE_REFERENCE_TO (to_type) != 0
6684       && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
6685     return TYPE_REFERENCE_TO (to_type);
6686
6687   /* First, if we already have a type for pointers to TO_TYPE and it's
6688      the proper mode, use it.  */
6689   for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
6690     if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6691       return t;
6692
6693   t = make_node (REFERENCE_TYPE);
6694
6695   TREE_TYPE (t) = to_type;
6696   SET_TYPE_MODE (t, mode);
6697   TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6698   TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
6699   TYPE_REFERENCE_TO (to_type) = t;
6700
6701   if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6702     SET_TYPE_STRUCTURAL_EQUALITY (t);
6703   else if (TYPE_CANONICAL (to_type) != to_type)
6704     TYPE_CANONICAL (t)
6705       = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
6706                                        mode, can_alias_all);
6707
6708   layout_type (t);
6709
6710   return t;
6711 }
6712
6713
6714 /* Build the node for the type of references-to-TO_TYPE by default
6715    in ptr_mode.  */
6716
6717 tree
6718 build_reference_type (tree to_type)
6719 {
6720   return build_reference_type_for_mode (to_type, ptr_mode, false);
6721 }
6722
6723 /* Build a type that is compatible with t but has no cv quals anywhere
6724    in its type, thus
6725
6726    const char *const *const *  ->  char ***.  */
6727
6728 tree
6729 build_type_no_quals (tree t)
6730 {
6731   switch (TREE_CODE (t))
6732     {
6733     case POINTER_TYPE:
6734       return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6735                                           TYPE_MODE (t),
6736                                           TYPE_REF_CAN_ALIAS_ALL (t));
6737     case REFERENCE_TYPE:
6738       return
6739         build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6740                                        TYPE_MODE (t),
6741                                        TYPE_REF_CAN_ALIAS_ALL (t));
6742     default:
6743       return TYPE_MAIN_VARIANT (t);
6744     }
6745 }
6746
6747 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
6748    MAXVAL should be the maximum value in the domain
6749    (one less than the length of the array).
6750
6751    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
6752    We don't enforce this limit, that is up to caller (e.g. language front end).
6753    The limit exists because the result is a signed type and we don't handle
6754    sizes that use more than one HOST_WIDE_INT.  */
6755
6756 tree
6757 build_index_type (tree maxval)
6758 {
6759   tree itype = make_node (INTEGER_TYPE);
6760
6761   TREE_TYPE (itype) = sizetype;
6762   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
6763   TYPE_MIN_VALUE (itype) = size_zero_node;
6764   TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
6765   SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
6766   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
6767   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
6768   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
6769   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
6770
6771   if (host_integerp (maxval, 1))
6772     return type_hash_canon (tree_low_cst (maxval, 1), itype);
6773   else
6774     {
6775       /* Since we cannot hash this type, we need to compare it using
6776          structural equality checks. */
6777       SET_TYPE_STRUCTURAL_EQUALITY (itype);
6778       return itype;
6779     }
6780 }
6781
6782 /* Builds a signed or unsigned integer type of precision PRECISION.
6783    Used for C bitfields whose precision does not match that of
6784    built-in target types.  */
6785 tree
6786 build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
6787                                 int unsignedp)
6788 {
6789   tree itype = make_node (INTEGER_TYPE);
6790
6791   TYPE_PRECISION (itype) = precision;
6792
6793   if (unsignedp)
6794     fixup_unsigned_type (itype);
6795   else
6796     fixup_signed_type (itype);
6797
6798   if (host_integerp (TYPE_MAX_VALUE (itype), 1))
6799     return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
6800
6801   return itype;
6802 }
6803
6804 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
6805    ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
6806    high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
6807
6808 tree
6809 build_range_type (tree type, tree lowval, tree highval)
6810 {
6811   tree itype = make_node (INTEGER_TYPE);
6812
6813   TREE_TYPE (itype) = type;
6814   if (type == NULL_TREE)
6815     type = sizetype;
6816
6817   TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
6818   TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
6819
6820   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
6821   SET_TYPE_MODE (itype, TYPE_MODE (type));
6822   TYPE_SIZE (itype) = TYPE_SIZE (type);
6823   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
6824   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
6825   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
6826
6827   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
6828     return type_hash_canon (tree_low_cst (highval, 0)
6829                             - tree_low_cst (lowval, 0),
6830                             itype);
6831   else
6832     return itype;
6833 }
6834
6835 /* Return true if the debug information for TYPE, a subtype, should be emitted
6836    as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
6837    high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
6838    debug info and doesn't reflect the source code.  */
6839
6840 bool
6841 subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
6842 {
6843   tree base_type = TREE_TYPE (type), low, high;
6844
6845   /* Subrange types have a base type which is an integral type.  */
6846   if (!INTEGRAL_TYPE_P (base_type))
6847     return false;
6848
6849   /* Get the real bounds of the subtype.  */
6850   if (lang_hooks.types.get_subrange_bounds)
6851     lang_hooks.types.get_subrange_bounds (type, &low, &high);
6852   else
6853     {
6854       low = TYPE_MIN_VALUE (type);
6855       high = TYPE_MAX_VALUE (type);
6856     }
6857
6858   /* If the type and its base type have the same representation and the same
6859      name, then the type is not a subrange but a copy of the base type.  */
6860   if ((TREE_CODE (base_type) == INTEGER_TYPE
6861        || TREE_CODE (base_type) == BOOLEAN_TYPE)
6862       && int_size_in_bytes (type) == int_size_in_bytes (base_type)
6863       && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
6864       && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
6865     {
6866       tree type_name = TYPE_NAME (type);
6867       tree base_type_name = TYPE_NAME (base_type);
6868
6869       if (type_name && TREE_CODE (type_name) == TYPE_DECL)
6870         type_name = DECL_NAME (type_name);
6871
6872       if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
6873         base_type_name = DECL_NAME (base_type_name);
6874
6875       if (type_name == base_type_name)
6876         return false;
6877     }
6878
6879   if (lowval)
6880     *lowval = low;
6881   if (highval)
6882     *highval = high;
6883   return true;
6884 }
6885
6886 /* Just like build_index_type, but takes lowval and highval instead
6887    of just highval (maxval).  */
6888
6889 tree
6890 build_index_2_type (tree lowval, tree highval)
6891 {
6892   return build_range_type (sizetype, lowval, highval);
6893 }
6894
6895 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
6896    and number of elements specified by the range of values of INDEX_TYPE.
6897    If such a type has already been constructed, reuse it.  */
6898
6899 tree
6900 build_array_type (tree elt_type, tree index_type)
6901 {
6902   tree t;
6903   hashval_t hashcode = 0;
6904
6905   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
6906     {
6907       error ("arrays of functions are not meaningful");
6908       elt_type = integer_type_node;
6909     }
6910
6911   t = make_node (ARRAY_TYPE);
6912   TREE_TYPE (t) = elt_type;
6913   TYPE_DOMAIN (t) = index_type;
6914   layout_type (t);
6915
6916   /* If the element type is incomplete at this point we get marked for
6917      structural equality.  Do not record these types in the canonical
6918      type hashtable.  */
6919   if (TYPE_STRUCTURAL_EQUALITY_P (t))
6920     return t;
6921
6922   hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
6923   if (index_type)
6924     hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
6925   t = type_hash_canon (hashcode, t);
6926
6927   if (TYPE_CANONICAL (t) == t)
6928     {
6929       if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
6930           || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
6931         SET_TYPE_STRUCTURAL_EQUALITY (t);
6932       else if (TYPE_CANONICAL (elt_type) != elt_type
6933                || (index_type && TYPE_CANONICAL (index_type) != index_type))
6934         TYPE_CANONICAL (t)
6935           = build_array_type (TYPE_CANONICAL (elt_type),
6936                               index_type ? TYPE_CANONICAL (index_type) : NULL);
6937     }
6938
6939   return t;
6940 }
6941
6942 /* Recursively examines the array elements of TYPE, until a non-array
6943    element type is found.  */
6944
6945 tree
6946 strip_array_types (tree type)
6947 {
6948   while (TREE_CODE (type) == ARRAY_TYPE)
6949     type = TREE_TYPE (type);
6950
6951   return type;
6952 }
6953
6954 /* Computes the canonical argument types from the argument type list
6955    ARGTYPES.
6956
6957    Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
6958    on entry to this function, or if any of the ARGTYPES are
6959    structural.
6960
6961    Upon return, *ANY_NONCANONICAL_P will be true iff either it was
6962    true on entry to this function, or if any of the ARGTYPES are
6963    non-canonical.
6964
6965    Returns a canonical argument list, which may be ARGTYPES when the
6966    canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
6967    true) or would not differ from ARGTYPES.  */
6968
6969 static tree
6970 maybe_canonicalize_argtypes(tree argtypes,
6971                             bool *any_structural_p,
6972                             bool *any_noncanonical_p)
6973 {
6974   tree arg;
6975   bool any_noncanonical_argtypes_p = false;
6976
6977   for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
6978     {
6979       if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
6980         /* Fail gracefully by stating that the type is structural.  */
6981         *any_structural_p = true;
6982       else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
6983         *any_structural_p = true;
6984       else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
6985                || TREE_PURPOSE (arg))
6986         /* If the argument has a default argument, we consider it
6987            non-canonical even though the type itself is canonical.
6988            That way, different variants of function and method types
6989            with default arguments will all point to the variant with
6990            no defaults as their canonical type.  */
6991         any_noncanonical_argtypes_p = true;
6992     }
6993
6994   if (*any_structural_p)
6995     return argtypes;
6996
6997   if (any_noncanonical_argtypes_p)
6998     {
6999       /* Build the canonical list of argument types.  */
7000       tree canon_argtypes = NULL_TREE;
7001       bool is_void = false;
7002
7003       for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7004         {
7005           if (arg == void_list_node)
7006             is_void = true;
7007           else
7008             canon_argtypes = tree_cons (NULL_TREE,
7009                                         TYPE_CANONICAL (TREE_VALUE (arg)),
7010                                         canon_argtypes);
7011         }
7012
7013       canon_argtypes = nreverse (canon_argtypes);
7014       if (is_void)
7015         canon_argtypes = chainon (canon_argtypes, void_list_node);
7016
7017       /* There is a non-canonical type.  */
7018       *any_noncanonical_p = true;
7019       return canon_argtypes;
7020     }
7021
7022   /* The canonical argument types are the same as ARGTYPES.  */
7023   return argtypes;
7024 }
7025
7026 /* Construct, lay out and return
7027    the type of functions returning type VALUE_TYPE
7028    given arguments of types ARG_TYPES.
7029    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7030    are data type nodes for the arguments of the function.
7031    If such a type has already been constructed, reuse it.  */
7032
7033 tree
7034 build_function_type (tree value_type, tree arg_types)
7035 {
7036   tree t;
7037   hashval_t hashcode = 0;
7038   bool any_structural_p, any_noncanonical_p;
7039   tree canon_argtypes;
7040
7041   if (TREE_CODE (value_type) == FUNCTION_TYPE)
7042     {
7043       error ("function return type cannot be function");
7044       value_type = integer_type_node;
7045     }
7046
7047   /* Make a node of the sort we want.  */
7048   t = make_node (FUNCTION_TYPE);
7049   TREE_TYPE (t) = value_type;
7050   TYPE_ARG_TYPES (t) = arg_types;
7051
7052   /* If we already have such a type, use the old one.  */
7053   hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
7054   hashcode = type_hash_list (arg_types, hashcode);
7055   t = type_hash_canon (hashcode, t);
7056
7057   /* Set up the canonical type. */
7058   any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
7059   any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
7060   canon_argtypes = maybe_canonicalize_argtypes (arg_types,
7061                                                 &any_structural_p,
7062                                                 &any_noncanonical_p);
7063   if (any_structural_p)
7064     SET_TYPE_STRUCTURAL_EQUALITY (t);
7065   else if (any_noncanonical_p)
7066     TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
7067                                               canon_argtypes);
7068
7069   if (!COMPLETE_TYPE_P (t))
7070     layout_type (t);
7071   return t;
7072 }
7073
7074 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.  */
7075
7076 tree
7077 build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
7078 {
7079   tree new_type = NULL;
7080   tree args, new_args = NULL, t;
7081   tree new_reversed;
7082   int i = 0;
7083
7084   for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
7085        args = TREE_CHAIN (args), i++)
7086     if (!bitmap_bit_p (args_to_skip, i))
7087       new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
7088
7089   new_reversed = nreverse (new_args);
7090   if (args)
7091     {
7092       if (new_reversed)
7093         TREE_CHAIN (new_args) = void_list_node;
7094       else
7095         new_reversed = void_list_node;
7096     }
7097
7098   /* Use copy_node to preserve as much as possible from original type
7099      (debug info, attribute lists etc.)
7100      Exception is METHOD_TYPEs must have THIS argument.
7101      When we are asked to remove it, we need to build new FUNCTION_TYPE
7102      instead.  */
7103   if (TREE_CODE (orig_type) != METHOD_TYPE
7104       || !bitmap_bit_p (args_to_skip, 0))
7105     {
7106       new_type = copy_node (orig_type);
7107       TYPE_ARG_TYPES (new_type) = new_reversed;
7108     }
7109   else
7110     {
7111       new_type
7112         = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
7113                                                          new_reversed));
7114       TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
7115     }
7116
7117   /* This is a new type, not a copy of an old type.  Need to reassociate
7118      variants.  We can handle everything except the main variant lazily.  */
7119   t = TYPE_MAIN_VARIANT (orig_type);
7120   if (orig_type != t)
7121     {
7122       TYPE_MAIN_VARIANT (new_type) = t;
7123       TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
7124       TYPE_NEXT_VARIANT (t) = new_type;
7125     }
7126   else
7127     {
7128       TYPE_MAIN_VARIANT (new_type) = new_type;
7129       TYPE_NEXT_VARIANT (new_type) = NULL;
7130     }
7131   return new_type;
7132 }
7133
7134 /* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7135
7136    Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7137    linked by TREE_CHAIN directly.  It is caller responsibility to eliminate
7138    them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
7139
7140 tree
7141 build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
7142 {
7143   tree new_decl = copy_node (orig_decl);
7144   tree new_type;
7145
7146   new_type = TREE_TYPE (orig_decl);
7147   if (prototype_p (new_type))
7148     new_type = build_function_type_skip_args (new_type, args_to_skip);
7149   TREE_TYPE (new_decl) = new_type;
7150
7151   /* For declarations setting DECL_VINDEX (i.e. methods)
7152      we expect first argument to be THIS pointer.   */
7153   if (bitmap_bit_p (args_to_skip, 0))
7154     DECL_VINDEX (new_decl) = NULL_TREE;
7155   return new_decl;
7156 }
7157
7158 /* Build a function type.  The RETURN_TYPE is the type returned by the
7159    function. If VAARGS is set, no void_type_node is appended to the
7160    the list. ARGP muse be alway be terminated be a NULL_TREE.  */
7161
7162 static tree
7163 build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
7164 {
7165   tree t, args, last;
7166
7167   t = va_arg (argp, tree);
7168   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
7169     args = tree_cons (NULL_TREE, t, args);
7170
7171   if (vaargs)
7172     {
7173       last = args;
7174       if (args != NULL_TREE)
7175         args = nreverse (args);
7176       gcc_assert (args != NULL_TREE && last != void_list_node);
7177     }
7178   else if (args == NULL_TREE)
7179     args = void_list_node;
7180   else
7181     {
7182       last = args;
7183       args = nreverse (args);
7184       TREE_CHAIN (last) = void_list_node;
7185     }
7186   args = build_function_type (return_type, args);
7187
7188   return args;
7189 }
7190
7191 /* Build a function type.  The RETURN_TYPE is the type returned by the
7192    function.  If additional arguments are provided, they are
7193    additional argument types.  The list of argument types must always
7194    be terminated by NULL_TREE.  */
7195
7196 tree
7197 build_function_type_list (tree return_type, ...)
7198 {
7199   tree args;
7200   va_list p;
7201
7202   va_start (p, return_type);
7203   args = build_function_type_list_1 (false, return_type, p);
7204   va_end (p);
7205   return args;
7206 }
7207
7208 /* Build a variable argument function type.  The RETURN_TYPE is the
7209    type returned by the function.  If additional arguments are provided,
7210    they are additional argument types.  The list of argument types must
7211    always be terminated by NULL_TREE.  */
7212
7213 tree
7214 build_varargs_function_type_list (tree return_type, ...)
7215 {
7216   tree args;
7217   va_list p;
7218
7219   va_start (p, return_type);
7220   args = build_function_type_list_1 (true, return_type, p);
7221   va_end (p);
7222
7223   return args;
7224 }
7225
7226 /* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
7227    and ARGTYPES (a TREE_LIST) are the return type and arguments types
7228    for the method.  An implicit additional parameter (of type
7229    pointer-to-BASETYPE) is added to the ARGTYPES.  */
7230
7231 tree
7232 build_method_type_directly (tree basetype,
7233                             tree rettype,
7234                             tree argtypes)
7235 {
7236   tree t;
7237   tree ptype;
7238   int hashcode = 0;
7239   bool any_structural_p, any_noncanonical_p;
7240   tree canon_argtypes;
7241
7242   /* Make a node of the sort we want.  */
7243   t = make_node (METHOD_TYPE);
7244
7245   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7246   TREE_TYPE (t) = rettype;
7247   ptype = build_pointer_type (basetype);
7248
7249   /* The actual arglist for this function includes a "hidden" argument
7250      which is "this".  Put it into the list of argument types.  */
7251   argtypes = tree_cons (NULL_TREE, ptype, argtypes);
7252   TYPE_ARG_TYPES (t) = argtypes;
7253
7254   /* If we already have such a type, use the old one.  */
7255   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7256   hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
7257   hashcode = type_hash_list (argtypes, hashcode);
7258   t = type_hash_canon (hashcode, t);
7259
7260   /* Set up the canonical type. */
7261   any_structural_p
7262     = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7263        || TYPE_STRUCTURAL_EQUALITY_P (rettype));
7264   any_noncanonical_p
7265     = (TYPE_CANONICAL (basetype) != basetype
7266        || TYPE_CANONICAL (rettype) != rettype);
7267   canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
7268                                                 &any_structural_p,
7269                                                 &any_noncanonical_p);
7270   if (any_structural_p)
7271     SET_TYPE_STRUCTURAL_EQUALITY (t);
7272   else if (any_noncanonical_p)
7273     TYPE_CANONICAL (t)
7274       = build_method_type_directly (TYPE_CANONICAL (basetype),
7275                                     TYPE_CANONICAL (rettype),
7276                                     canon_argtypes);
7277   if (!COMPLETE_TYPE_P (t))
7278     layout_type (t);
7279
7280   return t;
7281 }
7282
7283 /* Construct, lay out and return the type of methods belonging to class
7284    BASETYPE and whose arguments and values are described by TYPE.
7285    If that type exists already, reuse it.
7286    TYPE must be a FUNCTION_TYPE node.  */
7287
7288 tree
7289 build_method_type (tree basetype, tree type)
7290 {
7291   gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
7292
7293   return build_method_type_directly (basetype,
7294                                      TREE_TYPE (type),
7295                                      TYPE_ARG_TYPES (type));
7296 }
7297
7298 /* Construct, lay out and return the type of offsets to a value
7299    of type TYPE, within an object of type BASETYPE.
7300    If a suitable offset type exists already, reuse it.  */
7301
7302 tree
7303 build_offset_type (tree basetype, tree type)
7304 {
7305   tree t;
7306   hashval_t hashcode = 0;
7307
7308   /* Make a node of the sort we want.  */
7309   t = make_node (OFFSET_TYPE);
7310
7311   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7312   TREE_TYPE (t) = type;
7313
7314   /* If we already have such a type, use the old one.  */
7315   hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7316   hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
7317   t = type_hash_canon (hashcode, t);
7318
7319   if (!COMPLETE_TYPE_P (t))
7320     layout_type (t);
7321
7322   if (TYPE_CANONICAL (t) == t)
7323     {
7324       if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7325           || TYPE_STRUCTURAL_EQUALITY_P (type))
7326         SET_TYPE_STRUCTURAL_EQUALITY (t);
7327       else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
7328                || TYPE_CANONICAL (type) != type)
7329         TYPE_CANONICAL (t)
7330           = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
7331                                TYPE_CANONICAL (type));
7332     }
7333
7334   return t;
7335 }
7336
7337 /* Create a complex type whose components are COMPONENT_TYPE.  */
7338
7339 tree
7340 build_complex_type (tree component_type)
7341 {
7342   tree t;
7343   hashval_t hashcode;
7344
7345   gcc_assert (INTEGRAL_TYPE_P (component_type)
7346               || SCALAR_FLOAT_TYPE_P (component_type)
7347               || FIXED_POINT_TYPE_P (component_type));
7348
7349   /* Make a node of the sort we want.  */
7350   t = make_node (COMPLEX_TYPE);
7351
7352   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
7353
7354   /* If we already have such a type, use the old one.  */
7355   hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
7356   t = type_hash_canon (hashcode, t);
7357
7358   if (!COMPLETE_TYPE_P (t))
7359     layout_type (t);
7360
7361   if (TYPE_CANONICAL (t) == t)
7362     {
7363       if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
7364         SET_TYPE_STRUCTURAL_EQUALITY (t);
7365       else if (TYPE_CANONICAL (component_type) != component_type)
7366         TYPE_CANONICAL (t)
7367           = build_complex_type (TYPE_CANONICAL (component_type));
7368     }
7369
7370   /* We need to create a name, since complex is a fundamental type.  */
7371   if (! TYPE_NAME (t))
7372     {
7373       const char *name;
7374       if (component_type == char_type_node)
7375         name = "complex char";
7376       else if (component_type == signed_char_type_node)
7377         name = "complex signed char";
7378       else if (component_type == unsigned_char_type_node)
7379         name = "complex unsigned char";
7380       else if (component_type == short_integer_type_node)
7381         name = "complex short int";
7382       else if (component_type == short_unsigned_type_node)
7383         name = "complex short unsigned int";
7384       else if (component_type == integer_type_node)
7385         name = "complex int";
7386       else if (component_type == unsigned_type_node)
7387         name = "complex unsigned int";
7388       else if (component_type == long_integer_type_node)
7389         name = "complex long int";
7390       else if (component_type == long_unsigned_type_node)
7391         name = "complex long unsigned int";
7392       else if (component_type == long_long_integer_type_node)
7393         name = "complex long long int";
7394       else if (component_type == long_long_unsigned_type_node)
7395         name = "complex long long unsigned int";
7396       else
7397         name = 0;
7398
7399       if (name != 0)
7400         TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
7401                                     get_identifier (name), t);
7402     }
7403
7404   return build_qualified_type (t, TYPE_QUALS (component_type));
7405 }
7406
7407 /* If TYPE is a real or complex floating-point type and the target
7408    does not directly support arithmetic on TYPE then return the wider
7409    type to be used for arithmetic on TYPE.  Otherwise, return
7410    NULL_TREE.  */
7411
7412 tree
7413 excess_precision_type (tree type)
7414 {
7415   if (flag_excess_precision != EXCESS_PRECISION_FAST)
7416     {
7417       int flt_eval_method = TARGET_FLT_EVAL_METHOD;
7418       switch (TREE_CODE (type))
7419         {
7420         case REAL_TYPE:
7421           switch (flt_eval_method)
7422             {
7423             case 1:
7424               if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
7425                 return double_type_node;
7426               break;
7427             case 2:
7428               if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
7429                   || TYPE_MODE (type) == TYPE_MODE (double_type_node))
7430                 return long_double_type_node;
7431               break;
7432             default:
7433               gcc_unreachable ();
7434             }
7435           break;
7436         case COMPLEX_TYPE:
7437           if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
7438             return NULL_TREE;
7439           switch (flt_eval_method)
7440             {
7441             case 1:
7442               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
7443                 return complex_double_type_node;
7444               break;
7445             case 2:
7446               if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
7447                   || (TYPE_MODE (TREE_TYPE (type))
7448                       == TYPE_MODE (double_type_node)))
7449                 return complex_long_double_type_node;
7450               break;
7451             default:
7452               gcc_unreachable ();
7453             }
7454           break;
7455         default:
7456           break;
7457         }
7458     }
7459   return NULL_TREE;
7460 }
7461 \f
7462 /* Return OP, stripped of any conversions to wider types as much as is safe.
7463    Converting the value back to OP's type makes a value equivalent to OP.
7464
7465    If FOR_TYPE is nonzero, we return a value which, if converted to
7466    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7467
7468    OP must have integer, real or enumeral type.  Pointers are not allowed!
7469
7470    There are some cases where the obvious value we could return
7471    would regenerate to OP if converted to OP's type,
7472    but would not extend like OP to wider types.
7473    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7474    For example, if OP is (unsigned short)(signed char)-1,
7475    we avoid returning (signed char)-1 if FOR_TYPE is int,
7476    even though extending that to an unsigned short would regenerate OP,
7477    since the result of extending (signed char)-1 to (int)
7478    is different from (int) OP.  */
7479
7480 tree
7481 get_unwidened (tree op, tree for_type)
7482 {
7483   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
7484   tree type = TREE_TYPE (op);
7485   unsigned final_prec
7486     = TYPE_PRECISION (for_type != 0 ? for_type : type);
7487   int uns
7488     = (for_type != 0 && for_type != type
7489        && final_prec > TYPE_PRECISION (type)
7490        && TYPE_UNSIGNED (type));
7491   tree win = op;
7492
7493   while (CONVERT_EXPR_P (op))
7494     {
7495       int bitschange;
7496
7497       /* TYPE_PRECISION on vector types has different meaning
7498          (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7499          so avoid them here.  */
7500       if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
7501         break;
7502
7503       bitschange = TYPE_PRECISION (TREE_TYPE (op))
7504                    - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
7505
7506       /* Truncations are many-one so cannot be removed.
7507          Unless we are later going to truncate down even farther.  */
7508       if (bitschange < 0
7509           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
7510         break;
7511
7512       /* See what's inside this conversion.  If we decide to strip it,
7513          we will set WIN.  */
7514       op = TREE_OPERAND (op, 0);
7515
7516       /* If we have not stripped any zero-extensions (uns is 0),
7517          we can strip any kind of extension.
7518          If we have previously stripped a zero-extension,
7519          only zero-extensions can safely be stripped.
7520          Any extension can be stripped if the bits it would produce
7521          are all going to be discarded later by truncating to FOR_TYPE.  */
7522
7523       if (bitschange > 0)
7524         {
7525           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
7526             win = op;
7527           /* TYPE_UNSIGNED says whether this is a zero-extension.
7528              Let's avoid computing it if it does not affect WIN
7529              and if UNS will not be needed again.  */
7530           if ((uns
7531                || CONVERT_EXPR_P (op))
7532               && TYPE_UNSIGNED (TREE_TYPE (op)))
7533             {
7534               uns = 1;
7535               win = op;
7536             }
7537         }
7538     }
7539
7540   return win;
7541 }
7542 \f
7543 /* Return OP or a simpler expression for a narrower value
7544    which can be sign-extended or zero-extended to give back OP.
7545    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
7546    or 0 if the value should be sign-extended.  */
7547
7548 tree
7549 get_narrower (tree op, int *unsignedp_ptr)
7550 {
7551   int uns = 0;
7552   int first = 1;
7553   tree win = op;
7554   bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
7555
7556   while (TREE_CODE (op) == NOP_EXPR)
7557     {
7558       int bitschange
7559         = (TYPE_PRECISION (TREE_TYPE (op))
7560            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
7561
7562       /* Truncations are many-one so cannot be removed.  */
7563       if (bitschange < 0)
7564         break;
7565
7566       /* See what's inside this conversion.  If we decide to strip it,
7567          we will set WIN.  */
7568
7569       if (bitschange > 0)
7570         {
7571           op = TREE_OPERAND (op, 0);
7572           /* An extension: the outermost one can be stripped,
7573              but remember whether it is zero or sign extension.  */
7574           if (first)
7575             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7576           /* Otherwise, if a sign extension has been stripped,
7577              only sign extensions can now be stripped;
7578              if a zero extension has been stripped, only zero-extensions.  */
7579           else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
7580             break;
7581           first = 0;
7582         }
7583       else /* bitschange == 0 */
7584         {
7585           /* A change in nominal type can always be stripped, but we must
7586              preserve the unsignedness.  */
7587           if (first)
7588             uns = TYPE_UNSIGNED (TREE_TYPE (op));
7589           first = 0;
7590           op = TREE_OPERAND (op, 0);
7591           /* Keep trying to narrow, but don't assign op to win if it
7592              would turn an integral type into something else.  */
7593           if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
7594             continue;
7595         }
7596
7597       win = op;
7598     }
7599
7600   if (TREE_CODE (op) == COMPONENT_REF
7601       /* Since type_for_size always gives an integer type.  */
7602       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
7603       && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
7604       /* Ensure field is laid out already.  */
7605       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
7606       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
7607     {
7608       unsigned HOST_WIDE_INT innerprec
7609         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
7610       int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
7611                        || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
7612       tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
7613
7614       /* We can get this structure field in a narrower type that fits it,
7615          but the resulting extension to its nominal type (a fullword type)
7616          must satisfy the same conditions as for other extensions.
7617
7618          Do this only for fields that are aligned (not bit-fields),
7619          because when bit-field insns will be used there is no
7620          advantage in doing this.  */
7621
7622       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
7623           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
7624           && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
7625           && type != 0)
7626         {
7627           if (first)
7628             uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
7629           win = fold_convert (type, op);
7630         }
7631     }
7632
7633   *unsignedp_ptr = uns;
7634   return win;
7635 }
7636 \f
7637 /* Nonzero if integer constant C has a value that is permissible
7638    for type TYPE (an INTEGER_TYPE).  */
7639
7640 int
7641 int_fits_type_p (const_tree c, const_tree type)
7642 {
7643   tree type_low_bound, type_high_bound;
7644   bool ok_for_low_bound, ok_for_high_bound, unsc;
7645   double_int dc, dd;
7646
7647   dc = tree_to_double_int (c);
7648   unsc = TYPE_UNSIGNED (TREE_TYPE (c));
7649
7650   if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
7651       && TYPE_IS_SIZETYPE (TREE_TYPE (c))
7652       && unsc)
7653     /* So c is an unsigned integer whose type is sizetype and type is not.
7654        sizetype'd integers are sign extended even though they are
7655        unsigned. If the integer value fits in the lower end word of c,
7656        and if the higher end word has all its bits set to 1, that
7657        means the higher end bits are set to 1 only for sign extension.
7658        So let's convert c into an equivalent zero extended unsigned
7659        integer.  */
7660     dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
7661
7662 retry:
7663   type_low_bound = TYPE_MIN_VALUE (type);
7664   type_high_bound = TYPE_MAX_VALUE (type);
7665
7666   /* If at least one bound of the type is a constant integer, we can check
7667      ourselves and maybe make a decision. If no such decision is possible, but
7668      this type is a subtype, try checking against that.  Otherwise, use
7669      fit_double_type, which checks against the precision.
7670
7671      Compute the status for each possibly constant bound, and return if we see
7672      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
7673      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
7674      for "constant known to fit".  */
7675
7676   /* Check if c >= type_low_bound.  */
7677   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
7678     {
7679       dd = tree_to_double_int (type_low_bound);
7680       if (TREE_CODE (type) == INTEGER_TYPE
7681           && TYPE_IS_SIZETYPE (type)
7682           && TYPE_UNSIGNED (type))
7683         dd = double_int_zext (dd, TYPE_PRECISION (type));
7684       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
7685         {
7686           int c_neg = (!unsc && double_int_negative_p (dc));
7687           int t_neg = (unsc && double_int_negative_p (dd));
7688
7689           if (c_neg && !t_neg)
7690             return 0;
7691           if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
7692             return 0;
7693         }
7694       else if (double_int_cmp (dc, dd, unsc) < 0)
7695         return 0;
7696       ok_for_low_bound = true;
7697     }
7698   else
7699     ok_for_low_bound = false;
7700
7701   /* Check if c <= type_high_bound.  */
7702   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
7703     {
7704       dd = tree_to_double_int (type_high_bound);
7705       if (TREE_CODE (type) == INTEGER_TYPE
7706           && TYPE_IS_SIZETYPE (type)
7707           && TYPE_UNSIGNED (type))
7708         dd = double_int_zext (dd, TYPE_PRECISION (type));
7709       if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
7710         {
7711           int c_neg = (!unsc && double_int_negative_p (dc));
7712           int t_neg = (unsc && double_int_negative_p (dd));
7713
7714           if (t_neg && !c_neg)
7715             return 0;
7716           if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
7717             return 0;
7718         }
7719       else if (double_int_cmp (dc, dd, unsc) > 0)
7720         return 0;
7721       ok_for_high_bound = true;
7722     }
7723   else
7724     ok_for_high_bound = false;
7725
7726   /* If the constant fits both bounds, the result is known.  */
7727   if (ok_for_low_bound && ok_for_high_bound)
7728     return 1;
7729
7730   /* Perform some generic filtering which may allow making a decision
7731      even if the bounds are not constant.  First, negative integers
7732      never fit in unsigned types, */
7733   if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
7734     return 0;
7735
7736   /* Second, narrower types always fit in wider ones.  */
7737   if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
7738     return 1;
7739
7740   /* Third, unsigned integers with top bit set never fit signed types.  */
7741   if (! TYPE_UNSIGNED (type) && unsc)
7742     {
7743       int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
7744       if (prec < HOST_BITS_PER_WIDE_INT)
7745         {
7746           if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
7747             return 0;
7748         }
7749       else if (((((unsigned HOST_WIDE_INT) 1)
7750                  << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
7751         return 0;
7752     }
7753
7754   /* If we haven't been able to decide at this point, there nothing more we
7755      can check ourselves here.  Look at the base type if we have one and it
7756      has the same precision.  */
7757   if (TREE_CODE (type) == INTEGER_TYPE
7758       && TREE_TYPE (type) != 0
7759       && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
7760     {
7761       type = TREE_TYPE (type);
7762       goto retry;
7763     }
7764
7765   /* Or to fit_double_type, if nothing else.  */
7766   return !fit_double_type (dc.low, dc.high, &dc.low, &dc.high, type);
7767 }
7768
7769 /* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
7770    bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
7771    represented (assuming two's-complement arithmetic) within the bit
7772    precision of the type are returned instead.  */
7773
7774 void
7775 get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
7776 {
7777   if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
7778       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
7779     mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
7780                         TYPE_UNSIGNED (type));
7781   else
7782     {
7783       if (TYPE_UNSIGNED (type))
7784         mpz_set_ui (min, 0);
7785       else
7786         {
7787           double_int mn;
7788           mn = double_int_mask (TYPE_PRECISION (type) - 1);
7789           mn = double_int_sext (double_int_add (mn, double_int_one),
7790                                 TYPE_PRECISION (type));
7791           mpz_set_double_int (min, mn, false);
7792         }
7793     }
7794
7795   if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
7796       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
7797     mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
7798                         TYPE_UNSIGNED (type));
7799   else
7800     {
7801       if (TYPE_UNSIGNED (type))
7802         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
7803                             true);
7804       else
7805         mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
7806                             true);
7807     }
7808 }
7809
7810 /* Return true if VAR is an automatic variable defined in function FN.  */
7811
7812 bool
7813 auto_var_in_fn_p (const_tree var, const_tree fn)
7814 {
7815   return (DECL_P (var) && DECL_CONTEXT (var) == fn
7816           && (((TREE_CODE (var) == VAR_DECL || TREE_CODE (var) == PARM_DECL)
7817                && ! TREE_STATIC (var))
7818               || TREE_CODE (var) == LABEL_DECL
7819               || TREE_CODE (var) == RESULT_DECL));
7820 }
7821
7822 /* Subprogram of following function.  Called by walk_tree.
7823
7824    Return *TP if it is an automatic variable or parameter of the
7825    function passed in as DATA.  */
7826
7827 static tree
7828 find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
7829 {
7830   tree fn = (tree) data;
7831
7832   if (TYPE_P (*tp))
7833     *walk_subtrees = 0;
7834
7835   else if (DECL_P (*tp)
7836            && auto_var_in_fn_p (*tp, fn))
7837     return *tp;
7838
7839   return NULL_TREE;
7840 }
7841
7842 /* Returns true if T is, contains, or refers to a type with variable
7843    size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
7844    arguments, but not the return type.  If FN is nonzero, only return
7845    true if a modifier of the type or position of FN is a variable or
7846    parameter inside FN.
7847
7848    This concept is more general than that of C99 'variably modified types':
7849    in C99, a struct type is never variably modified because a VLA may not
7850    appear as a structure member.  However, in GNU C code like:
7851
7852      struct S { int i[f()]; };
7853
7854    is valid, and other languages may define similar constructs.  */
7855
7856 bool
7857 variably_modified_type_p (tree type, tree fn)
7858 {
7859   tree t;
7860
7861 /* Test if T is either variable (if FN is zero) or an expression containing
7862    a variable in FN.  */
7863 #define RETURN_TRUE_IF_VAR(T)                                           \
7864   do { tree _t = (T);                                                   \
7865     if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
7866         && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
7867       return true;  } while (0)
7868
7869   if (type == error_mark_node)
7870     return false;
7871
7872   /* If TYPE itself has variable size, it is variably modified.  */
7873   RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
7874   RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
7875
7876   switch (TREE_CODE (type))
7877     {
7878     case POINTER_TYPE:
7879     case REFERENCE_TYPE:
7880     case VECTOR_TYPE:
7881       if (variably_modified_type_p (TREE_TYPE (type), fn))
7882         return true;
7883       break;
7884
7885     case FUNCTION_TYPE:
7886     case METHOD_TYPE:
7887       /* If TYPE is a function type, it is variably modified if the
7888          return type is variably modified.  */
7889       if (variably_modified_type_p (TREE_TYPE (type), fn))
7890           return true;
7891       break;
7892
7893     case INTEGER_TYPE:
7894     case REAL_TYPE:
7895     case FIXED_POINT_TYPE:
7896     case ENUMERAL_TYPE:
7897     case BOOLEAN_TYPE:
7898       /* Scalar types are variably modified if their end points
7899          aren't constant.  */
7900       RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
7901       RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
7902       break;
7903
7904     case RECORD_TYPE:
7905     case UNION_TYPE:
7906     case QUAL_UNION_TYPE:
7907       /* We can't see if any of the fields are variably-modified by the
7908          definition we normally use, since that would produce infinite
7909          recursion via pointers.  */
7910       /* This is variably modified if some field's type is.  */
7911       for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
7912         if (TREE_CODE (t) == FIELD_DECL)
7913           {
7914             RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
7915             RETURN_TRUE_IF_VAR (DECL_SIZE (t));
7916             RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
7917
7918             if (TREE_CODE (type) == QUAL_UNION_TYPE)
7919               RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
7920           }
7921         break;
7922
7923     case ARRAY_TYPE:
7924       /* Do not call ourselves to avoid infinite recursion.  This is
7925          variably modified if the element type is.  */
7926       RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
7927       RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
7928       break;
7929
7930     default:
7931       break;
7932     }
7933
7934   /* The current language may have other cases to check, but in general,
7935      all other types are not variably modified.  */
7936   return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
7937
7938 #undef RETURN_TRUE_IF_VAR
7939 }
7940
7941 /* Given a DECL or TYPE, return the scope in which it was declared, or
7942    NULL_TREE if there is no containing scope.  */
7943
7944 tree
7945 get_containing_scope (const_tree t)
7946 {
7947   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
7948 }
7949
7950 /* Return the innermost context enclosing DECL that is
7951    a FUNCTION_DECL, or zero if none.  */
7952
7953 tree
7954 decl_function_context (const_tree decl)
7955 {
7956   tree context;
7957
7958   if (TREE_CODE (decl) == ERROR_MARK)
7959     return 0;
7960
7961   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
7962      where we look up the function at runtime.  Such functions always take
7963      a first argument of type 'pointer to real context'.
7964
7965      C++ should really be fixed to use DECL_CONTEXT for the real context,
7966      and use something else for the "virtual context".  */
7967   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
7968     context
7969       = TYPE_MAIN_VARIANT
7970         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
7971   else
7972     context = DECL_CONTEXT (decl);
7973
7974   while (context && TREE_CODE (context) != FUNCTION_DECL)
7975     {
7976       if (TREE_CODE (context) == BLOCK)
7977         context = BLOCK_SUPERCONTEXT (context);
7978       else
7979         context = get_containing_scope (context);
7980     }
7981
7982   return context;
7983 }
7984
7985 /* Return the innermost context enclosing DECL that is
7986    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
7987    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
7988
7989 tree
7990 decl_type_context (const_tree decl)
7991 {
7992   tree context = DECL_CONTEXT (decl);
7993
7994   while (context)
7995     switch (TREE_CODE (context))
7996       {
7997       case NAMESPACE_DECL:
7998       case TRANSLATION_UNIT_DECL:
7999         return NULL_TREE;
8000
8001       case RECORD_TYPE:
8002       case UNION_TYPE:
8003       case QUAL_UNION_TYPE:
8004         return context;
8005
8006       case TYPE_DECL:
8007       case FUNCTION_DECL:
8008         context = DECL_CONTEXT (context);
8009         break;
8010
8011       case BLOCK:
8012         context = BLOCK_SUPERCONTEXT (context);
8013         break;
8014
8015       default:
8016         gcc_unreachable ();
8017       }
8018
8019   return NULL_TREE;
8020 }
8021
8022 /* CALL is a CALL_EXPR.  Return the declaration for the function
8023    called, or NULL_TREE if the called function cannot be
8024    determined.  */
8025
8026 tree
8027 get_callee_fndecl (const_tree call)
8028 {
8029   tree addr;
8030
8031   if (call == error_mark_node)
8032     return error_mark_node;
8033
8034   /* It's invalid to call this function with anything but a
8035      CALL_EXPR.  */
8036   gcc_assert (TREE_CODE (call) == CALL_EXPR);
8037
8038   /* The first operand to the CALL is the address of the function
8039      called.  */
8040   addr = CALL_EXPR_FN (call);
8041
8042   STRIP_NOPS (addr);
8043
8044   /* If this is a readonly function pointer, extract its initial value.  */
8045   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8046       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8047       && DECL_INITIAL (addr))
8048     addr = DECL_INITIAL (addr);
8049
8050   /* If the address is just `&f' for some function `f', then we know
8051      that `f' is being called.  */
8052   if (TREE_CODE (addr) == ADDR_EXPR
8053       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8054     return TREE_OPERAND (addr, 0);
8055
8056   /* We couldn't figure out what was being called.  */
8057   return NULL_TREE;
8058 }
8059
8060 /* Print debugging information about tree nodes generated during the compile,
8061    and any language-specific information.  */
8062
8063 void
8064 dump_tree_statistics (void)
8065 {
8066 #ifdef GATHER_STATISTICS
8067   int i;
8068   int total_nodes, total_bytes;
8069 #endif
8070
8071   fprintf (stderr, "\n??? tree nodes created\n\n");
8072 #ifdef GATHER_STATISTICS
8073   fprintf (stderr, "Kind                   Nodes      Bytes\n");
8074   fprintf (stderr, "---------------------------------------\n");
8075   total_nodes = total_bytes = 0;
8076   for (i = 0; i < (int) all_kinds; i++)
8077     {
8078       fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8079                tree_node_counts[i], tree_node_sizes[i]);
8080       total_nodes += tree_node_counts[i];
8081       total_bytes += tree_node_sizes[i];
8082     }
8083   fprintf (stderr, "---------------------------------------\n");
8084   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8085   fprintf (stderr, "---------------------------------------\n");
8086   ssanames_print_statistics ();
8087   phinodes_print_statistics ();
8088 #else
8089   fprintf (stderr, "(No per-node statistics)\n");
8090 #endif
8091   print_type_hash_statistics ();
8092   print_debug_expr_statistics ();
8093   print_value_expr_statistics ();
8094   lang_hooks.print_statistics ();
8095 }
8096 \f
8097 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8098
8099 /* Generate a crc32 of a string.  */
8100
8101 unsigned
8102 crc32_string (unsigned chksum, const char *string)
8103 {
8104   do
8105     {
8106       unsigned value = *string << 24;
8107       unsigned ix;
8108
8109       for (ix = 8; ix--; value <<= 1)
8110         {
8111           unsigned feedback;
8112
8113           feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8114           chksum <<= 1;
8115           chksum ^= feedback;
8116         }
8117     }
8118   while (*string++);
8119   return chksum;
8120 }
8121
8122 /* P is a string that will be used in a symbol.  Mask out any characters
8123    that are not valid in that context.  */
8124
8125 void
8126 clean_symbol_name (char *p)
8127 {
8128   for (; *p; p++)
8129     if (! (ISALNUM (*p)
8130 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
8131             || *p == '$'
8132 #endif
8133 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
8134             || *p == '.'
8135 #endif
8136            ))
8137       *p = '_';
8138 }
8139
8140 /* Generate a name for a special-purpose function function.
8141    The generated name may need to be unique across the whole link.
8142    TYPE is some string to identify the purpose of this function to the
8143    linker or collect2; it must start with an uppercase letter,
8144    one of:
8145    I - for constructors
8146    D - for destructors
8147    N - for C++ anonymous namespaces
8148    F - for DWARF unwind frame information.  */
8149
8150 tree
8151 get_file_function_name (const char *type)
8152 {
8153   char *buf;
8154   const char *p;
8155   char *q;
8156
8157   /* If we already have a name we know to be unique, just use that.  */
8158   if (first_global_object_name)
8159     p = q = ASTRDUP (first_global_object_name);
8160   /* If the target is handling the constructors/destructors, they
8161      will be local to this file and the name is only necessary for
8162      debugging purposes.  */
8163   else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8164     {
8165       const char *file = main_input_filename;
8166       if (! file)
8167         file = input_filename;
8168       /* Just use the file's basename, because the full pathname
8169          might be quite long.  */
8170       p = strrchr (file, '/');
8171       if (p)
8172         p++;
8173       else
8174         p = file;
8175       p = q = ASTRDUP (p);
8176     }
8177   else
8178     {
8179       /* Otherwise, the name must be unique across the entire link.
8180          We don't have anything that we know to be unique to this translation
8181          unit, so use what we do have and throw in some randomness.  */
8182       unsigned len;
8183       const char *name = weak_global_object_name;
8184       const char *file = main_input_filename;
8185
8186       if (! name)
8187         name = "";
8188       if (! file)
8189         file = input_filename;
8190
8191       len = strlen (file);
8192       q = (char *) alloca (9 * 2 + len + 1);
8193       memcpy (q, file, len + 1);
8194
8195       sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8196                crc32_string (0, get_random_seed (false)));
8197
8198       p = q;
8199     }
8200
8201   clean_symbol_name (q);
8202   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8203                          + strlen (type));
8204
8205   /* Set up the name of the file-level functions we may need.
8206      Use a global object (which is already required to be unique over
8207      the program) rather than the file name (which imposes extra
8208      constraints).  */
8209   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8210
8211   return get_identifier (buf);
8212 }
8213 \f
8214 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8215
8216 /* Complain that the tree code of NODE does not match the expected 0
8217    terminated list of trailing codes. The trailing code list can be
8218    empty, for a more vague error message.  FILE, LINE, and FUNCTION
8219    are of the caller.  */
8220
8221 void
8222 tree_check_failed (const_tree node, const char *file,
8223                    int line, const char *function, ...)
8224 {
8225   va_list args;
8226   const char *buffer;
8227   unsigned length = 0;
8228   int code;
8229
8230   va_start (args, function);
8231   while ((code = va_arg (args, int)))
8232     length += 4 + strlen (tree_code_name[code]);
8233   va_end (args);
8234   if (length)
8235     {
8236       char *tmp;
8237       va_start (args, function);
8238       length += strlen ("expected ");
8239       buffer = tmp = (char *) alloca (length);
8240       length = 0;
8241       while ((code = va_arg (args, int)))
8242         {
8243           const char *prefix = length ? " or " : "expected ";
8244
8245           strcpy (tmp + length, prefix);
8246           length += strlen (prefix);
8247           strcpy (tmp + length, tree_code_name[code]);
8248           length += strlen (tree_code_name[code]);
8249         }
8250       va_end (args);
8251     }
8252   else
8253     buffer = "unexpected node";
8254
8255   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8256                   buffer, tree_code_name[TREE_CODE (node)],
8257                   function, trim_filename (file), line);
8258 }
8259
8260 /* Complain that the tree code of NODE does match the expected 0
8261    terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8262    the caller.  */
8263
8264 void
8265 tree_not_check_failed (const_tree node, const char *file,
8266                        int line, const char *function, ...)
8267 {
8268   va_list args;
8269   char *buffer;
8270   unsigned length = 0;
8271   int code;
8272
8273   va_start (args, function);
8274   while ((code = va_arg (args, int)))
8275     length += 4 + strlen (tree_code_name[code]);
8276   va_end (args);
8277   va_start (args, function);
8278   buffer = (char *) alloca (length);
8279   length = 0;
8280   while ((code = va_arg (args, int)))
8281     {
8282       if (length)
8283         {
8284           strcpy (buffer + length, " or ");
8285           length += 4;
8286         }
8287       strcpy (buffer + length, tree_code_name[code]);
8288       length += strlen (tree_code_name[code]);
8289     }
8290   va_end (args);
8291
8292   internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8293                   buffer, tree_code_name[TREE_CODE (node)],
8294                   function, trim_filename (file), line);
8295 }
8296
8297 /* Similar to tree_check_failed, except that we check for a class of tree
8298    code, given in CL.  */
8299
8300 void
8301 tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8302                          const char *file, int line, const char *function)
8303 {
8304   internal_error
8305     ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8306      TREE_CODE_CLASS_STRING (cl),
8307      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8308      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8309 }
8310
8311 /* Similar to tree_check_failed, except that instead of specifying a
8312    dozen codes, use the knowledge that they're all sequential.  */
8313
8314 void
8315 tree_range_check_failed (const_tree node, const char *file, int line,
8316                          const char *function, enum tree_code c1,
8317                          enum tree_code c2)
8318 {
8319   char *buffer;
8320   unsigned length = 0;
8321   unsigned int c;
8322
8323   for (c = c1; c <= c2; ++c)
8324     length += 4 + strlen (tree_code_name[c]);
8325
8326   length += strlen ("expected ");
8327   buffer = (char *) alloca (length);
8328   length = 0;
8329
8330   for (c = c1; c <= c2; ++c)
8331     {
8332       const char *prefix = length ? " or " : "expected ";
8333
8334       strcpy (buffer + length, prefix);
8335       length += strlen (prefix);
8336       strcpy (buffer + length, tree_code_name[c]);
8337       length += strlen (tree_code_name[c]);
8338     }
8339
8340   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8341                   buffer, tree_code_name[TREE_CODE (node)],
8342                   function, trim_filename (file), line);
8343 }
8344
8345
8346 /* Similar to tree_check_failed, except that we check that a tree does
8347    not have the specified code, given in CL.  */
8348
8349 void
8350 tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8351                              const char *file, int line, const char *function)
8352 {
8353   internal_error
8354     ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8355      TREE_CODE_CLASS_STRING (cl),
8356      TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8357      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8358 }
8359
8360
8361 /* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
8362
8363 void
8364 omp_clause_check_failed (const_tree node, const char *file, int line,
8365                          const char *function, enum omp_clause_code code)
8366 {
8367   internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8368                   omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8369                   function, trim_filename (file), line);
8370 }
8371
8372
8373 /* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
8374
8375 void
8376 omp_clause_range_check_failed (const_tree node, const char *file, int line,
8377                                const char *function, enum omp_clause_code c1,
8378                                enum omp_clause_code c2)
8379 {
8380   char *buffer;
8381   unsigned length = 0;
8382   unsigned int c;
8383
8384   for (c = c1; c <= c2; ++c)
8385     length += 4 + strlen (omp_clause_code_name[c]);
8386
8387   length += strlen ("expected ");
8388   buffer = (char *) alloca (length);
8389   length = 0;
8390
8391   for (c = c1; c <= c2; ++c)
8392     {
8393       const char *prefix = length ? " or " : "expected ";
8394
8395       strcpy (buffer + length, prefix);
8396       length += strlen (prefix);
8397       strcpy (buffer + length, omp_clause_code_name[c]);
8398       length += strlen (omp_clause_code_name[c]);
8399     }
8400
8401   internal_error ("tree check: %s, have %s in %s, at %s:%d",
8402                   buffer, omp_clause_code_name[TREE_CODE (node)],
8403                   function, trim_filename (file), line);
8404 }
8405
8406
8407 #undef DEFTREESTRUCT
8408 #define DEFTREESTRUCT(VAL, NAME) NAME,
8409
8410 static const char *ts_enum_names[] = {
8411 #include "treestruct.def"
8412 };
8413 #undef DEFTREESTRUCT
8414
8415 #define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8416
8417 /* Similar to tree_class_check_failed, except that we check for
8418    whether CODE contains the tree structure identified by EN.  */
8419
8420 void
8421 tree_contains_struct_check_failed (const_tree node,
8422                                    const enum tree_node_structure_enum en,
8423                                    const char *file, int line,
8424                                    const char *function)
8425 {
8426   internal_error
8427     ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8428      TS_ENUM_NAME(en),
8429      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8430 }
8431
8432
8433 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
8434    (dynamically sized) vector.  */
8435
8436 void
8437 tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8438                            const char *function)
8439 {
8440   internal_error
8441     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8442      idx + 1, len, function, trim_filename (file), line);
8443 }
8444
8445 /* Similar to above, except that the check is for the bounds of the operand
8446    vector of an expression node EXP.  */
8447
8448 void
8449 tree_operand_check_failed (int idx, const_tree exp, const char *file,
8450                            int line, const char *function)
8451 {
8452   int code = TREE_CODE (exp);
8453   internal_error
8454     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8455      idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8456      function, trim_filename (file), line);
8457 }
8458
8459 /* Similar to above, except that the check is for the number of
8460    operands of an OMP_CLAUSE node.  */
8461
8462 void
8463 omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8464                                  int line, const char *function)
8465 {
8466   internal_error
8467     ("tree check: accessed operand %d of omp_clause %s with %d operands "
8468      "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8469      omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8470      trim_filename (file), line);
8471 }
8472 #endif /* ENABLE_TREE_CHECKING */
8473 \f
8474 /* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8475    and mapped to the machine mode MODE.  Initialize its fields and build
8476    the information necessary for debugging output.  */
8477
8478 static tree
8479 make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8480 {
8481   tree t;
8482   hashval_t hashcode = 0;
8483
8484   t = make_node (VECTOR_TYPE);
8485   TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8486   SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8487   SET_TYPE_MODE (t, mode);
8488
8489   if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8490     SET_TYPE_STRUCTURAL_EQUALITY (t);
8491   else if (TYPE_CANONICAL (innertype) != innertype
8492            || mode != VOIDmode)
8493     TYPE_CANONICAL (t)
8494       = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8495
8496   layout_type (t);
8497
8498   {
8499     tree index = build_int_cst (NULL_TREE, nunits - 1);
8500     tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
8501                                    build_index_type (index));
8502     tree rt = make_node (RECORD_TYPE);
8503
8504     TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
8505                                    get_identifier ("f"), array);
8506     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
8507     layout_type (rt);
8508     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
8509     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
8510        the representation type, and we want to find that die when looking up
8511        the vector type.  This is most easily achieved by making the TYPE_UID
8512        numbers equal.  */
8513     TYPE_UID (rt) = TYPE_UID (t);
8514   }
8515
8516   hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8517   hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8518   hashcode = iterative_hash_host_wide_int (mode, hashcode);
8519   hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8520   t = type_hash_canon (hashcode, t);
8521
8522   /* We have built a main variant, based on the main variant of the
8523      inner type. Use it to build the variant we return.  */
8524   if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8525       && TREE_TYPE (t) != innertype)
8526     return build_type_attribute_qual_variant (t,
8527                                               TYPE_ATTRIBUTES (innertype),
8528                                               TYPE_QUALS (innertype));
8529
8530   return t;
8531 }
8532
8533 static tree
8534 make_or_reuse_type (unsigned size, int unsignedp)
8535 {
8536   if (size == INT_TYPE_SIZE)
8537     return unsignedp ? unsigned_type_node : integer_type_node;
8538   if (size == CHAR_TYPE_SIZE)
8539     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8540   if (size == SHORT_TYPE_SIZE)
8541     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8542   if (size == LONG_TYPE_SIZE)
8543     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8544   if (size == LONG_LONG_TYPE_SIZE)
8545     return (unsignedp ? long_long_unsigned_type_node
8546             : long_long_integer_type_node);
8547
8548   if (unsignedp)
8549     return make_unsigned_type (size);
8550   else
8551     return make_signed_type (size);
8552 }
8553
8554 /* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
8555
8556 static tree
8557 make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8558 {
8559   if (satp)
8560     {
8561       if (size == SHORT_FRACT_TYPE_SIZE)
8562         return unsignedp ? sat_unsigned_short_fract_type_node
8563                          : sat_short_fract_type_node;
8564       if (size == FRACT_TYPE_SIZE)
8565         return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8566       if (size == LONG_FRACT_TYPE_SIZE)
8567         return unsignedp ? sat_unsigned_long_fract_type_node
8568                          : sat_long_fract_type_node;
8569       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8570         return unsignedp ? sat_unsigned_long_long_fract_type_node
8571                          : sat_long_long_fract_type_node;
8572     }
8573   else
8574     {
8575       if (size == SHORT_FRACT_TYPE_SIZE)
8576         return unsignedp ? unsigned_short_fract_type_node
8577                          : short_fract_type_node;
8578       if (size == FRACT_TYPE_SIZE)
8579         return unsignedp ? unsigned_fract_type_node : fract_type_node;
8580       if (size == LONG_FRACT_TYPE_SIZE)
8581         return unsignedp ? unsigned_long_fract_type_node
8582                          : long_fract_type_node;
8583       if (size == LONG_LONG_FRACT_TYPE_SIZE)
8584         return unsignedp ? unsigned_long_long_fract_type_node
8585                          : long_long_fract_type_node;
8586     }
8587
8588   return make_fract_type (size, unsignedp, satp);
8589 }
8590
8591 /* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
8592
8593 static tree
8594 make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8595 {
8596   if (satp)
8597     {
8598       if (size == SHORT_ACCUM_TYPE_SIZE)
8599         return unsignedp ? sat_unsigned_short_accum_type_node
8600                          : sat_short_accum_type_node;
8601       if (size == ACCUM_TYPE_SIZE)
8602         return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8603       if (size == LONG_ACCUM_TYPE_SIZE)
8604         return unsignedp ? sat_unsigned_long_accum_type_node
8605                          : sat_long_accum_type_node;
8606       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8607         return unsignedp ? sat_unsigned_long_long_accum_type_node
8608                          : sat_long_long_accum_type_node;
8609     }
8610   else
8611     {
8612       if (size == SHORT_ACCUM_TYPE_SIZE)
8613         return unsignedp ? unsigned_short_accum_type_node
8614                          : short_accum_type_node;
8615       if (size == ACCUM_TYPE_SIZE)
8616         return unsignedp ? unsigned_accum_type_node : accum_type_node;
8617       if (size == LONG_ACCUM_TYPE_SIZE)
8618         return unsignedp ? unsigned_long_accum_type_node
8619                          : long_accum_type_node;
8620       if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8621         return unsignedp ? unsigned_long_long_accum_type_node
8622                          : long_long_accum_type_node;
8623     }
8624
8625   return make_accum_type (size, unsignedp, satp);
8626 }
8627
8628 /* Create nodes for all integer types (and error_mark_node) using the sizes
8629    of C datatypes.  The caller should call set_sizetype soon after calling
8630    this function to select one of the types as sizetype.  */
8631
8632 void
8633 build_common_tree_nodes (bool signed_char, bool signed_sizetype)
8634 {
8635   error_mark_node = make_node (ERROR_MARK);
8636   TREE_TYPE (error_mark_node) = error_mark_node;
8637
8638   initialize_sizetypes (signed_sizetype);
8639
8640   /* Define both `signed char' and `unsigned char'.  */
8641   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8642   TYPE_STRING_FLAG (signed_char_type_node) = 1;
8643   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8644   TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8645
8646   /* Define `char', which is like either `signed char' or `unsigned char'
8647      but not the same as either.  */
8648   char_type_node
8649     = (signed_char
8650        ? make_signed_type (CHAR_TYPE_SIZE)
8651        : make_unsigned_type (CHAR_TYPE_SIZE));
8652   TYPE_STRING_FLAG (char_type_node) = 1;
8653
8654   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8655   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8656   integer_type_node = make_signed_type (INT_TYPE_SIZE);
8657   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8658   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8659   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8660   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8661   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8662
8663   /* Define a boolean type.  This type only represents boolean values but
8664      may be larger than char depending on the value of BOOL_TYPE_SIZE.
8665      Front ends which want to override this size (i.e. Java) can redefine
8666      boolean_type_node before calling build_common_tree_nodes_2.  */
8667   boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8668   TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8669   TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8670   TYPE_PRECISION (boolean_type_node) = 1;
8671
8672   /* Fill in the rest of the sized types.  Reuse existing type nodes
8673      when possible.  */
8674   intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
8675   intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
8676   intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
8677   intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
8678   intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
8679
8680   unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
8681   unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
8682   unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
8683   unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
8684   unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
8685
8686   access_public_node = get_identifier ("public");
8687   access_protected_node = get_identifier ("protected");
8688   access_private_node = get_identifier ("private");
8689 }
8690
8691 /* Call this function after calling build_common_tree_nodes and set_sizetype.
8692    It will create several other common tree nodes.  */
8693
8694 void
8695 build_common_tree_nodes_2 (int short_double)
8696 {
8697   /* Define these next since types below may used them.  */
8698   integer_zero_node = build_int_cst (NULL_TREE, 0);
8699   integer_one_node = build_int_cst (NULL_TREE, 1);
8700   integer_minus_one_node = build_int_cst (NULL_TREE, -1);
8701
8702   size_zero_node = size_int (0);
8703   size_one_node = size_int (1);
8704   bitsize_zero_node = bitsize_int (0);
8705   bitsize_one_node = bitsize_int (1);
8706   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
8707
8708   boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
8709   boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
8710
8711   void_type_node = make_node (VOID_TYPE);
8712   layout_type (void_type_node);
8713
8714   /* We are not going to have real types in C with less than byte alignment,
8715      so we might as well not have any types that claim to have it.  */
8716   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
8717   TYPE_USER_ALIGN (void_type_node) = 0;
8718
8719   null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
8720   layout_type (TREE_TYPE (null_pointer_node));
8721
8722   ptr_type_node = build_pointer_type (void_type_node);
8723   const_ptr_type_node
8724     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
8725   fileptr_type_node = ptr_type_node;
8726
8727   float_type_node = make_node (REAL_TYPE);
8728   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
8729   layout_type (float_type_node);
8730
8731   double_type_node = make_node (REAL_TYPE);
8732   if (short_double)
8733     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
8734   else
8735     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
8736   layout_type (double_type_node);
8737
8738   long_double_type_node = make_node (REAL_TYPE);
8739   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
8740   layout_type (long_double_type_node);
8741
8742   float_ptr_type_node = build_pointer_type (float_type_node);
8743   double_ptr_type_node = build_pointer_type (double_type_node);
8744   long_double_ptr_type_node = build_pointer_type (long_double_type_node);
8745   integer_ptr_type_node = build_pointer_type (integer_type_node);
8746
8747   /* Fixed size integer types.  */
8748   uint32_type_node = build_nonstandard_integer_type (32, true);
8749   uint64_type_node = build_nonstandard_integer_type (64, true);
8750
8751   /* Decimal float types. */
8752   dfloat32_type_node = make_node (REAL_TYPE);
8753   TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
8754   layout_type (dfloat32_type_node);
8755   SET_TYPE_MODE (dfloat32_type_node, SDmode);
8756   dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
8757
8758   dfloat64_type_node = make_node (REAL_TYPE);
8759   TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
8760   layout_type (dfloat64_type_node);
8761   SET_TYPE_MODE (dfloat64_type_node, DDmode);
8762   dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
8763
8764   dfloat128_type_node = make_node (REAL_TYPE);
8765   TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
8766   layout_type (dfloat128_type_node);
8767   SET_TYPE_MODE (dfloat128_type_node, TDmode);
8768   dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
8769
8770   complex_integer_type_node = build_complex_type (integer_type_node);
8771   complex_float_type_node = build_complex_type (float_type_node);
8772   complex_double_type_node = build_complex_type (double_type_node);
8773   complex_long_double_type_node = build_complex_type (long_double_type_node);
8774
8775 /* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
8776 #define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
8777   sat_ ## KIND ## _type_node = \
8778     make_sat_signed_ ## KIND ## _type (SIZE); \
8779   sat_unsigned_ ## KIND ## _type_node = \
8780     make_sat_unsigned_ ## KIND ## _type (SIZE); \
8781   KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8782   unsigned_ ## KIND ## _type_node = \
8783     make_unsigned_ ## KIND ## _type (SIZE);
8784
8785 #define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
8786   sat_ ## WIDTH ## KIND ## _type_node = \
8787     make_sat_signed_ ## KIND ## _type (SIZE); \
8788   sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
8789     make_sat_unsigned_ ## KIND ## _type (SIZE); \
8790   WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8791   unsigned_ ## WIDTH ## KIND ## _type_node = \
8792     make_unsigned_ ## KIND ## _type (SIZE);
8793
8794 /* Make fixed-point type nodes based on four different widths.  */
8795 #define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
8796   MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
8797   MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
8798   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
8799   MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
8800
8801 /* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
8802 #define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
8803   NAME ## _type_node = \
8804     make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
8805   u ## NAME ## _type_node = \
8806     make_or_reuse_unsigned_ ## KIND ## _type \
8807       (GET_MODE_BITSIZE (U ## MODE ## mode)); \
8808   sat_ ## NAME ## _type_node = \
8809     make_or_reuse_sat_signed_ ## KIND ## _type \
8810       (GET_MODE_BITSIZE (MODE ## mode)); \
8811   sat_u ## NAME ## _type_node = \
8812     make_or_reuse_sat_unsigned_ ## KIND ## _type \
8813       (GET_MODE_BITSIZE (U ## MODE ## mode));
8814
8815   /* Fixed-point type and mode nodes.  */
8816   MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
8817   MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
8818   MAKE_FIXED_MODE_NODE (fract, qq, QQ)
8819   MAKE_FIXED_MODE_NODE (fract, hq, HQ)
8820   MAKE_FIXED_MODE_NODE (fract, sq, SQ)
8821   MAKE_FIXED_MODE_NODE (fract, dq, DQ)
8822   MAKE_FIXED_MODE_NODE (fract, tq, TQ)
8823   MAKE_FIXED_MODE_NODE (accum, ha, HA)
8824   MAKE_FIXED_MODE_NODE (accum, sa, SA)
8825   MAKE_FIXED_MODE_NODE (accum, da, DA)
8826   MAKE_FIXED_MODE_NODE (accum, ta, TA)
8827
8828   {
8829     tree t = targetm.build_builtin_va_list ();
8830
8831     /* Many back-ends define record types without setting TYPE_NAME.
8832        If we copied the record type here, we'd keep the original
8833        record type without a name.  This breaks name mangling.  So,
8834        don't copy record types and let c_common_nodes_and_builtins()
8835        declare the type to be __builtin_va_list.  */
8836     if (TREE_CODE (t) != RECORD_TYPE)
8837       t = build_variant_type_copy (t);
8838
8839     va_list_type_node = t;
8840   }
8841 }
8842
8843 /* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
8844
8845 static void
8846 local_define_builtin (const char *name, tree type, enum built_in_function code,
8847                       const char *library_name, int ecf_flags)
8848 {
8849   tree decl;
8850
8851   decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
8852                                library_name, NULL_TREE);
8853   if (ecf_flags & ECF_CONST)
8854     TREE_READONLY (decl) = 1;
8855   if (ecf_flags & ECF_PURE)
8856     DECL_PURE_P (decl) = 1;
8857   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
8858     DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
8859   if (ecf_flags & ECF_NORETURN)
8860     TREE_THIS_VOLATILE (decl) = 1;
8861   if (ecf_flags & ECF_NOTHROW)
8862     TREE_NOTHROW (decl) = 1;
8863   if (ecf_flags & ECF_MALLOC)
8864     DECL_IS_MALLOC (decl) = 1;
8865
8866   built_in_decls[code] = decl;
8867   implicit_built_in_decls[code] = decl;
8868 }
8869
8870 /* Call this function after instantiating all builtins that the language
8871    front end cares about.  This will build the rest of the builtins that
8872    are relied upon by the tree optimizers and the middle-end.  */
8873
8874 void
8875 build_common_builtin_nodes (void)
8876 {
8877   tree tmp, ftype;
8878
8879   if (built_in_decls[BUILT_IN_MEMCPY] == NULL
8880       || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
8881     {
8882       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
8883       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
8884       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
8885       ftype = build_function_type (ptr_type_node, tmp);
8886
8887       if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
8888         local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
8889                               "memcpy", ECF_NOTHROW);
8890       if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
8891         local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
8892                               "memmove", ECF_NOTHROW);
8893     }
8894
8895   if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
8896     {
8897       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
8898       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
8899       tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
8900       ftype = build_function_type (integer_type_node, tmp);
8901       local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
8902                             "memcmp", ECF_PURE | ECF_NOTHROW);
8903     }
8904
8905   if (built_in_decls[BUILT_IN_MEMSET] == NULL)
8906     {
8907       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
8908       tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
8909       tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
8910       ftype = build_function_type (ptr_type_node, tmp);
8911       local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
8912                             "memset", ECF_NOTHROW);
8913     }
8914
8915   if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
8916     {
8917       tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
8918       ftype = build_function_type (ptr_type_node, tmp);
8919       local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
8920                             "alloca", ECF_NOTHROW | ECF_MALLOC);
8921     }
8922
8923   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8924   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
8925   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
8926   ftype = build_function_type (void_type_node, tmp);
8927   local_define_builtin ("__builtin_init_trampoline", ftype,
8928                         BUILT_IN_INIT_TRAMPOLINE,
8929                         "__builtin_init_trampoline", ECF_NOTHROW);
8930
8931   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8932   ftype = build_function_type (ptr_type_node, tmp);
8933   local_define_builtin ("__builtin_adjust_trampoline", ftype,
8934                         BUILT_IN_ADJUST_TRAMPOLINE,
8935                         "__builtin_adjust_trampoline",
8936                         ECF_CONST | ECF_NOTHROW);
8937
8938   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8939   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
8940   ftype = build_function_type (void_type_node, tmp);
8941   local_define_builtin ("__builtin_nonlocal_goto", ftype,
8942                         BUILT_IN_NONLOCAL_GOTO,
8943                         "__builtin_nonlocal_goto",
8944                         ECF_NORETURN | ECF_NOTHROW);
8945
8946   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8947   tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
8948   ftype = build_function_type (void_type_node, tmp);
8949   local_define_builtin ("__builtin_setjmp_setup", ftype,
8950                         BUILT_IN_SETJMP_SETUP,
8951                         "__builtin_setjmp_setup", ECF_NOTHROW);
8952
8953   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8954   ftype = build_function_type (ptr_type_node, tmp);
8955   local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
8956                         BUILT_IN_SETJMP_DISPATCHER,
8957                         "__builtin_setjmp_dispatcher",
8958                         ECF_PURE | ECF_NOTHROW);
8959
8960   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8961   ftype = build_function_type (void_type_node, tmp);
8962   local_define_builtin ("__builtin_setjmp_receiver", ftype,
8963                         BUILT_IN_SETJMP_RECEIVER,
8964                         "__builtin_setjmp_receiver", ECF_NOTHROW);
8965
8966   ftype = build_function_type (ptr_type_node, void_list_node);
8967   local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
8968                         "__builtin_stack_save", ECF_NOTHROW);
8969
8970   tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
8971   ftype = build_function_type (void_type_node, tmp);
8972   local_define_builtin ("__builtin_stack_restore", ftype,
8973                         BUILT_IN_STACK_RESTORE,
8974                         "__builtin_stack_restore", ECF_NOTHROW);
8975
8976   ftype = build_function_type (void_type_node, void_list_node);
8977   local_define_builtin ("__builtin_profile_func_enter", ftype,
8978                         BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
8979   local_define_builtin ("__builtin_profile_func_exit", ftype,
8980                         BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
8981
8982   /* Complex multiplication and division.  These are handled as builtins
8983      rather than optabs because emit_library_call_value doesn't support
8984      complex.  Further, we can do slightly better with folding these
8985      beasties if the real and complex parts of the arguments are separate.  */
8986   {
8987     int mode;
8988
8989     for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
8990       {
8991         char mode_name_buf[4], *q;
8992         const char *p;
8993         enum built_in_function mcode, dcode;
8994         tree type, inner_type;
8995
8996         type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
8997         if (type == NULL)
8998           continue;
8999         inner_type = TREE_TYPE (type);
9000
9001         tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
9002         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9003         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9004         tmp = tree_cons (NULL_TREE, inner_type, tmp);
9005         ftype = build_function_type (type, tmp);
9006
9007         mcode = ((enum built_in_function)
9008                  (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9009         dcode = ((enum built_in_function)
9010                  (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9011
9012         for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9013           *q = TOLOWER (*p);
9014         *q = '\0';
9015
9016         built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9017         local_define_builtin (built_in_names[mcode], ftype, mcode,
9018                               built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
9019
9020         built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9021         local_define_builtin (built_in_names[dcode], ftype, dcode,
9022                               built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
9023       }
9024   }
9025 }
9026
9027 /* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
9028    better way.
9029
9030    If we requested a pointer to a vector, build up the pointers that
9031    we stripped off while looking for the inner type.  Similarly for
9032    return values from functions.
9033
9034    The argument TYPE is the top of the chain, and BOTTOM is the
9035    new type which we will point to.  */
9036
9037 tree
9038 reconstruct_complex_type (tree type, tree bottom)
9039 {
9040   tree inner, outer;
9041
9042   if (TREE_CODE (type) == POINTER_TYPE)
9043     {
9044       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9045       outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9046                                            TYPE_REF_CAN_ALIAS_ALL (type));
9047     }
9048   else if (TREE_CODE (type) == REFERENCE_TYPE)
9049     {
9050       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9051       outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9052                                              TYPE_REF_CAN_ALIAS_ALL (type));
9053     }
9054   else if (TREE_CODE (type) == ARRAY_TYPE)
9055     {
9056       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9057       outer = build_array_type (inner, TYPE_DOMAIN (type));
9058     }
9059   else if (TREE_CODE (type) == FUNCTION_TYPE)
9060     {
9061       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9062       outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9063     }
9064   else if (TREE_CODE (type) == METHOD_TYPE)
9065     {
9066       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9067       /* The build_method_type_directly() routine prepends 'this' to argument list,
9068          so we must compensate by getting rid of it.  */
9069       outer
9070         = build_method_type_directly
9071             (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9072              inner,
9073              TREE_CHAIN (TYPE_ARG_TYPES (type)));
9074     }
9075   else if (TREE_CODE (type) == OFFSET_TYPE)
9076     {
9077       inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9078       outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9079     }
9080   else
9081     return bottom;
9082
9083   return build_qualified_type (outer, TYPE_QUALS (type));
9084 }
9085
9086 /* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9087    the inner type.  */
9088 tree
9089 build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9090 {
9091   int nunits;
9092
9093   switch (GET_MODE_CLASS (mode))
9094     {
9095     case MODE_VECTOR_INT:
9096     case MODE_VECTOR_FLOAT:
9097     case MODE_VECTOR_FRACT:
9098     case MODE_VECTOR_UFRACT:
9099     case MODE_VECTOR_ACCUM:
9100     case MODE_VECTOR_UACCUM:
9101       nunits = GET_MODE_NUNITS (mode);
9102       break;
9103
9104     case MODE_INT:
9105       /* Check that there are no leftover bits.  */
9106       gcc_assert (GET_MODE_BITSIZE (mode)
9107                   % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9108
9109       nunits = GET_MODE_BITSIZE (mode)
9110                / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9111       break;
9112
9113     default:
9114       gcc_unreachable ();
9115     }
9116
9117   return make_vector_type (innertype, nunits, mode);
9118 }
9119
9120 /* Similarly, but takes the inner type and number of units, which must be
9121    a power of two.  */
9122
9123 tree
9124 build_vector_type (tree innertype, int nunits)
9125 {
9126   return make_vector_type (innertype, nunits, VOIDmode);
9127 }
9128
9129 /* Similarly, but takes the inner type and number of units, which must be
9130    a power of two.  */
9131
9132 tree
9133 build_opaque_vector_type (tree innertype, int nunits)
9134 {
9135   tree t;
9136   innertype = build_distinct_type_copy (innertype);
9137   t = make_vector_type (innertype, nunits, VOIDmode);
9138   TYPE_VECTOR_OPAQUE (t) = true;
9139   return t;
9140 }
9141
9142
9143 /* Build RESX_EXPR with given REGION_NUMBER.  */
9144 tree
9145 build_resx (int region_number)
9146 {
9147   tree t;
9148   t = build1 (RESX_EXPR, void_type_node,
9149               build_int_cst (NULL_TREE, region_number));
9150   return t;
9151 }
9152
9153 /* Given an initializer INIT, return TRUE if INIT is zero or some
9154    aggregate of zeros.  Otherwise return FALSE.  */
9155 bool
9156 initializer_zerop (const_tree init)
9157 {
9158   tree elt;
9159
9160   STRIP_NOPS (init);
9161
9162   switch (TREE_CODE (init))
9163     {
9164     case INTEGER_CST:
9165       return integer_zerop (init);
9166
9167     case REAL_CST:
9168       /* ??? Note that this is not correct for C4X float formats.  There,
9169          a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9170          negative exponent.  */
9171       return real_zerop (init)
9172         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9173
9174     case FIXED_CST:
9175       return fixed_zerop (init);
9176
9177     case COMPLEX_CST:
9178       return integer_zerop (init)
9179         || (real_zerop (init)
9180             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9181             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9182
9183     case VECTOR_CST:
9184       for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9185         if (!initializer_zerop (TREE_VALUE (elt)))
9186           return false;
9187       return true;
9188
9189     case CONSTRUCTOR:
9190       {
9191         unsigned HOST_WIDE_INT idx;
9192
9193         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9194           if (!initializer_zerop (elt))
9195             return false;
9196         return true;
9197       }
9198
9199     default:
9200       return false;
9201     }
9202 }
9203
9204 /* Build an empty statement at location LOC.  */
9205
9206 tree
9207 build_empty_stmt (location_t loc)
9208 {
9209   tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9210   SET_EXPR_LOCATION (t, loc);
9211   return t;
9212 }
9213
9214
9215 /* Build an OpenMP clause with code CODE.  LOC is the location of the
9216    clause.  */
9217
9218 tree
9219 build_omp_clause (location_t loc, enum omp_clause_code code)
9220 {
9221   tree t;
9222   int size, length;
9223
9224   length = omp_clause_num_ops[code];
9225   size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9226
9227   t = GGC_NEWVAR (union tree_node, size);
9228   memset (t, 0, size);
9229   TREE_SET_CODE (t, OMP_CLAUSE);
9230   OMP_CLAUSE_SET_CODE (t, code);
9231   OMP_CLAUSE_LOCATION (t) = loc;
9232
9233 #ifdef GATHER_STATISTICS
9234   tree_node_counts[(int) omp_clause_kind]++;
9235   tree_node_sizes[(int) omp_clause_kind] += size;
9236 #endif
9237
9238   return t;
9239 }
9240
9241 /* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
9242    includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9243    Except for the CODE and operand count field, other storage for the
9244    object is initialized to zeros.  */
9245
9246 tree
9247 build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9248 {
9249   tree t;
9250   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9251
9252   gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9253   gcc_assert (len >= 1);
9254
9255 #ifdef GATHER_STATISTICS
9256   tree_node_counts[(int) e_kind]++;
9257   tree_node_sizes[(int) e_kind] += length;
9258 #endif
9259
9260   t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
9261
9262   memset (t, 0, length);
9263
9264   TREE_SET_CODE (t, code);
9265
9266   /* Can't use TREE_OPERAND to store the length because if checking is
9267      enabled, it will try to check the length before we store it.  :-P  */
9268   t->exp.operands[0] = build_int_cst (sizetype, len);
9269
9270   return t;
9271 }
9272
9273
9274 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE
9275    and FN and a null static chain slot.  ARGLIST is a TREE_LIST of the
9276    arguments.  */
9277
9278 tree
9279 build_call_list (tree return_type, tree fn, tree arglist)
9280 {
9281   tree t;
9282   int i;
9283
9284   t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
9285   TREE_TYPE (t) = return_type;
9286   CALL_EXPR_FN (t) = fn;
9287   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9288   for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
9289     CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
9290   process_call_operands (t);
9291   return t;
9292 }
9293
9294 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9295    FN and a null static chain slot.  NARGS is the number of call arguments
9296    which are specified as "..." arguments.  */
9297
9298 tree
9299 build_call_nary (tree return_type, tree fn, int nargs, ...)
9300 {
9301   tree ret;
9302   va_list args;
9303   va_start (args, nargs);
9304   ret = build_call_valist (return_type, fn, nargs, args);
9305   va_end (args);
9306   return ret;
9307 }
9308
9309 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9310    FN and a null static chain slot.  NARGS is the number of call arguments
9311    which are specified as a va_list ARGS.  */
9312
9313 tree
9314 build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9315 {
9316   tree t;
9317   int i;
9318
9319   t = build_vl_exp (CALL_EXPR, nargs + 3);
9320   TREE_TYPE (t) = return_type;
9321   CALL_EXPR_FN (t) = fn;
9322   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9323   for (i = 0; i < nargs; i++)
9324     CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9325   process_call_operands (t);
9326   return t;
9327 }
9328
9329 /* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9330    FN and a null static chain slot.  NARGS is the number of call arguments
9331    which are specified as a tree array ARGS.  */
9332
9333 tree
9334 build_call_array_loc (location_t loc, tree return_type, tree fn,
9335                       int nargs, const tree *args)
9336 {
9337   tree t;
9338   int i;
9339
9340   t = build_vl_exp (CALL_EXPR, nargs + 3);
9341   TREE_TYPE (t) = return_type;
9342   CALL_EXPR_FN (t) = fn;
9343   CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9344   for (i = 0; i < nargs; i++)
9345     CALL_EXPR_ARG (t, i) = args[i];
9346   process_call_operands (t);
9347   SET_EXPR_LOCATION (t, loc);
9348   return t;
9349 }
9350
9351 /* Like build_call_array, but takes a VEC.  */
9352
9353 tree
9354 build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9355 {
9356   tree ret, t;
9357   unsigned int ix;
9358
9359   ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9360   TREE_TYPE (ret) = return_type;
9361   CALL_EXPR_FN (ret) = fn;
9362   CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9363   for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
9364     CALL_EXPR_ARG (ret, ix) = t;
9365   process_call_operands (ret);
9366   return ret;
9367 }
9368
9369
9370 /* Returns true if it is possible to prove that the index of
9371    an array access REF (an ARRAY_REF expression) falls into the
9372    array bounds.  */
9373
9374 bool
9375 in_array_bounds_p (tree ref)
9376 {
9377   tree idx = TREE_OPERAND (ref, 1);
9378   tree min, max;
9379
9380   if (TREE_CODE (idx) != INTEGER_CST)
9381     return false;
9382
9383   min = array_ref_low_bound (ref);
9384   max = array_ref_up_bound (ref);
9385   if (!min
9386       || !max
9387       || TREE_CODE (min) != INTEGER_CST
9388       || TREE_CODE (max) != INTEGER_CST)
9389     return false;
9390
9391   if (tree_int_cst_lt (idx, min)
9392       || tree_int_cst_lt (max, idx))
9393     return false;
9394
9395   return true;
9396 }
9397
9398 /* Returns true if it is possible to prove that the range of
9399    an array access REF (an ARRAY_RANGE_REF expression) falls
9400    into the array bounds.  */
9401
9402 bool
9403 range_in_array_bounds_p (tree ref)
9404 {
9405   tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9406   tree range_min, range_max, min, max;
9407
9408   range_min = TYPE_MIN_VALUE (domain_type);
9409   range_max = TYPE_MAX_VALUE (domain_type);
9410   if (!range_min
9411       || !range_max
9412       || TREE_CODE (range_min) != INTEGER_CST
9413       || TREE_CODE (range_max) != INTEGER_CST)
9414     return false;
9415
9416   min = array_ref_low_bound (ref);
9417   max = array_ref_up_bound (ref);
9418   if (!min
9419       || !max
9420       || TREE_CODE (min) != INTEGER_CST
9421       || TREE_CODE (max) != INTEGER_CST)
9422     return false;
9423
9424   if (tree_int_cst_lt (range_min, min)
9425       || tree_int_cst_lt (max, range_max))
9426     return false;
9427
9428   return true;
9429 }
9430
9431 /* Return true if T (assumed to be a DECL) must be assigned a memory
9432    location.  */
9433
9434 bool
9435 needs_to_live_in_memory (const_tree t)
9436 {
9437   if (TREE_CODE (t) == SSA_NAME)
9438     t = SSA_NAME_VAR (t);
9439
9440   return (TREE_ADDRESSABLE (t)
9441           || is_global_var (t)
9442           || (TREE_CODE (t) == RESULT_DECL
9443               && aggregate_value_p (t, current_function_decl)));
9444 }
9445
9446 /* There are situations in which a language considers record types
9447    compatible which have different field lists.  Decide if two fields
9448    are compatible.  It is assumed that the parent records are compatible.  */
9449
9450 bool
9451 fields_compatible_p (const_tree f1, const_tree f2)
9452 {
9453   if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9454                         DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9455     return false;
9456
9457   if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9458                         DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9459     return false;
9460
9461   if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9462     return false;
9463
9464   return true;
9465 }
9466
9467 /* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
9468
9469 tree
9470 find_compatible_field (tree record, tree orig_field)
9471 {
9472   tree f;
9473
9474   for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9475     if (TREE_CODE (f) == FIELD_DECL
9476         && fields_compatible_p (f, orig_field))
9477       return f;
9478
9479   /* ??? Why isn't this on the main fields list?  */
9480   f = TYPE_VFIELD (record);
9481   if (f && TREE_CODE (f) == FIELD_DECL
9482       && fields_compatible_p (f, orig_field))
9483     return f;
9484
9485   /* ??? We should abort here, but Java appears to do Bad Things
9486      with inherited fields.  */
9487   return orig_field;
9488 }
9489
9490 /* Return value of a constant X and sign-extend it.  */
9491
9492 HOST_WIDE_INT
9493 int_cst_value (const_tree x)
9494 {
9495   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9496   unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9497
9498   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9499   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9500               || TREE_INT_CST_HIGH (x) == -1);
9501
9502   if (bits < HOST_BITS_PER_WIDE_INT)
9503     {
9504       bool negative = ((val >> (bits - 1)) & 1) != 0;
9505       if (negative)
9506         val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9507       else
9508         val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9509     }
9510
9511   return val;
9512 }
9513
9514 /* Return value of a constant X and sign-extend it.  */
9515
9516 HOST_WIDEST_INT
9517 widest_int_cst_value (const_tree x)
9518 {
9519   unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9520   unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9521
9522 #if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9523   gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9524   val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9525           << HOST_BITS_PER_WIDE_INT);
9526 #else
9527   /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9528   gcc_assert (TREE_INT_CST_HIGH (x) == 0
9529               || TREE_INT_CST_HIGH (x) == -1);
9530 #endif
9531
9532   if (bits < HOST_BITS_PER_WIDEST_INT)
9533     {
9534       bool negative = ((val >> (bits - 1)) & 1) != 0;
9535       if (negative)
9536         val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9537       else
9538         val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9539     }
9540
9541   return val;
9542 }
9543
9544 /* If TYPE is an integral type, return an equivalent type which is
9545     unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
9546     return TYPE itself.  */
9547
9548 tree
9549 signed_or_unsigned_type_for (int unsignedp, tree type)
9550 {
9551   tree t = type;
9552   if (POINTER_TYPE_P (type))
9553     t = size_type_node;
9554
9555   if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9556     return t;
9557
9558   return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9559 }
9560
9561 /* Returns unsigned variant of TYPE.  */
9562
9563 tree
9564 unsigned_type_for (tree type)
9565 {
9566   return signed_or_unsigned_type_for (1, type);
9567 }
9568
9569 /* Returns signed variant of TYPE.  */
9570
9571 tree
9572 signed_type_for (tree type)
9573 {
9574   return signed_or_unsigned_type_for (0, type);
9575 }
9576
9577 /* Returns the largest value obtainable by casting something in INNER type to
9578    OUTER type.  */
9579
9580 tree
9581 upper_bound_in_type (tree outer, tree inner)
9582 {
9583   unsigned HOST_WIDE_INT lo, hi;
9584   unsigned int det = 0;
9585   unsigned oprec = TYPE_PRECISION (outer);
9586   unsigned iprec = TYPE_PRECISION (inner);
9587   unsigned prec;
9588
9589   /* Compute a unique number for every combination.  */
9590   det |= (oprec > iprec) ? 4 : 0;
9591   det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9592   det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9593
9594   /* Determine the exponent to use.  */
9595   switch (det)
9596     {
9597     case 0:
9598     case 1:
9599       /* oprec <= iprec, outer: signed, inner: don't care.  */
9600       prec = oprec - 1;
9601       break;
9602     case 2:
9603     case 3:
9604       /* oprec <= iprec, outer: unsigned, inner: don't care.  */
9605       prec = oprec;
9606       break;
9607     case 4:
9608       /* oprec > iprec, outer: signed, inner: signed.  */
9609       prec = iprec - 1;
9610       break;
9611     case 5:
9612       /* oprec > iprec, outer: signed, inner: unsigned.  */
9613       prec = iprec;
9614       break;
9615     case 6:
9616       /* oprec > iprec, outer: unsigned, inner: signed.  */
9617       prec = oprec;
9618       break;
9619     case 7:
9620       /* oprec > iprec, outer: unsigned, inner: unsigned.  */
9621       prec = iprec;
9622       break;
9623     default:
9624       gcc_unreachable ();
9625     }
9626
9627   /* Compute 2^^prec - 1.  */
9628   if (prec <= HOST_BITS_PER_WIDE_INT)
9629     {
9630       hi = 0;
9631       lo = ((~(unsigned HOST_WIDE_INT) 0)
9632             >> (HOST_BITS_PER_WIDE_INT - prec));
9633     }
9634   else
9635     {
9636       hi = ((~(unsigned HOST_WIDE_INT) 0)
9637             >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9638       lo = ~(unsigned HOST_WIDE_INT) 0;
9639     }
9640
9641   return build_int_cst_wide (outer, lo, hi);
9642 }
9643
9644 /* Returns the smallest value obtainable by casting something in INNER type to
9645    OUTER type.  */
9646
9647 tree
9648 lower_bound_in_type (tree outer, tree inner)
9649 {
9650   unsigned HOST_WIDE_INT lo, hi;
9651   unsigned oprec = TYPE_PRECISION (outer);
9652   unsigned iprec = TYPE_PRECISION (inner);
9653
9654   /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
9655      and obtain 0.  */
9656   if (TYPE_UNSIGNED (outer)
9657       /* If we are widening something of an unsigned type, OUTER type
9658          contains all values of INNER type.  In particular, both INNER
9659          and OUTER types have zero in common.  */
9660       || (oprec > iprec && TYPE_UNSIGNED (inner)))
9661     lo = hi = 0;
9662   else
9663     {
9664       /* If we are widening a signed type to another signed type, we
9665          want to obtain -2^^(iprec-1).  If we are keeping the
9666          precision or narrowing to a signed type, we want to obtain
9667          -2^(oprec-1).  */
9668       unsigned prec = oprec > iprec ? iprec : oprec;
9669
9670       if (prec <= HOST_BITS_PER_WIDE_INT)
9671         {
9672           hi = ~(unsigned HOST_WIDE_INT) 0;
9673           lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
9674         }
9675       else
9676         {
9677           hi = ((~(unsigned HOST_WIDE_INT) 0)
9678                 << (prec - HOST_BITS_PER_WIDE_INT - 1));
9679           lo = 0;
9680         }
9681     }
9682
9683   return build_int_cst_wide (outer, lo, hi);
9684 }
9685
9686 /* Return nonzero if two operands that are suitable for PHI nodes are
9687    necessarily equal.  Specifically, both ARG0 and ARG1 must be either
9688    SSA_NAME or invariant.  Note that this is strictly an optimization.
9689    That is, callers of this function can directly call operand_equal_p
9690    and get the same result, only slower.  */
9691
9692 int
9693 operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
9694 {
9695   if (arg0 == arg1)
9696     return 1;
9697   if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
9698     return 0;
9699   return operand_equal_p (arg0, arg1, 0);
9700 }
9701
9702 /* Returns number of zeros at the end of binary representation of X.
9703
9704    ??? Use ffs if available?  */
9705
9706 tree
9707 num_ending_zeros (const_tree x)
9708 {
9709   unsigned HOST_WIDE_INT fr, nfr;
9710   unsigned num, abits;
9711   tree type = TREE_TYPE (x);
9712
9713   if (TREE_INT_CST_LOW (x) == 0)
9714     {
9715       num = HOST_BITS_PER_WIDE_INT;
9716       fr = TREE_INT_CST_HIGH (x);
9717     }
9718   else
9719     {
9720       num = 0;
9721       fr = TREE_INT_CST_LOW (x);
9722     }
9723
9724   for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
9725     {
9726       nfr = fr >> abits;
9727       if (nfr << abits == fr)
9728         {
9729           num += abits;
9730           fr = nfr;
9731         }
9732     }
9733
9734   if (num > TYPE_PRECISION (type))
9735     num = TYPE_PRECISION (type);
9736
9737   return build_int_cst_type (type, num);
9738 }
9739
9740
9741 #define WALK_SUBTREE(NODE)                              \
9742   do                                                    \
9743     {                                                   \
9744       result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
9745       if (result)                                       \
9746         return result;                                  \
9747     }                                                   \
9748   while (0)
9749
9750 /* This is a subroutine of walk_tree that walks field of TYPE that are to
9751    be walked whenever a type is seen in the tree.  Rest of operands and return
9752    value are as for walk_tree.  */
9753
9754 static tree
9755 walk_type_fields (tree type, walk_tree_fn func, void *data,
9756                   struct pointer_set_t *pset, walk_tree_lh lh)
9757 {
9758   tree result = NULL_TREE;
9759
9760   switch (TREE_CODE (type))
9761     {
9762     case POINTER_TYPE:
9763     case REFERENCE_TYPE:
9764       /* We have to worry about mutually recursive pointers.  These can't
9765          be written in C.  They can in Ada.  It's pathological, but
9766          there's an ACATS test (c38102a) that checks it.  Deal with this
9767          by checking if we're pointing to another pointer, that one
9768          points to another pointer, that one does too, and we have no htab.
9769          If so, get a hash table.  We check three levels deep to avoid
9770          the cost of the hash table if we don't need one.  */
9771       if (POINTER_TYPE_P (TREE_TYPE (type))
9772           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
9773           && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
9774           && !pset)
9775         {
9776           result = walk_tree_without_duplicates (&TREE_TYPE (type),
9777                                                  func, data);
9778           if (result)
9779             return result;
9780
9781           break;
9782         }
9783
9784       /* ... fall through ... */
9785
9786     case COMPLEX_TYPE:
9787       WALK_SUBTREE (TREE_TYPE (type));
9788       break;
9789
9790     case METHOD_TYPE:
9791       WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
9792
9793       /* Fall through.  */
9794
9795     case FUNCTION_TYPE:
9796       WALK_SUBTREE (TREE_TYPE (type));
9797       {
9798         tree arg;
9799
9800         /* We never want to walk into default arguments.  */
9801         for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
9802           WALK_SUBTREE (TREE_VALUE (arg));
9803       }
9804       break;
9805
9806     case ARRAY_TYPE:
9807       /* Don't follow this nodes's type if a pointer for fear that
9808          we'll have infinite recursion.  If we have a PSET, then we
9809          need not fear.  */
9810       if (pset
9811           || (!POINTER_TYPE_P (TREE_TYPE (type))
9812               && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
9813         WALK_SUBTREE (TREE_TYPE (type));
9814       WALK_SUBTREE (TYPE_DOMAIN (type));
9815       break;
9816
9817     case OFFSET_TYPE:
9818       WALK_SUBTREE (TREE_TYPE (type));
9819       WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
9820       break;
9821
9822     default:
9823       break;
9824     }
9825
9826   return NULL_TREE;
9827 }
9828
9829 /* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
9830    called with the DATA and the address of each sub-tree.  If FUNC returns a
9831    non-NULL value, the traversal is stopped, and the value returned by FUNC
9832    is returned.  If PSET is non-NULL it is used to record the nodes visited,
9833    and to avoid visiting a node more than once.  */
9834
9835 tree
9836 walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
9837              struct pointer_set_t *pset, walk_tree_lh lh)
9838 {
9839   enum tree_code code;
9840   int walk_subtrees;
9841   tree result;
9842
9843 #define WALK_SUBTREE_TAIL(NODE)                         \
9844   do                                                    \
9845     {                                                   \
9846        tp = & (NODE);                                   \
9847        goto tail_recurse;                               \
9848     }                                                   \
9849   while (0)
9850
9851  tail_recurse:
9852   /* Skip empty subtrees.  */
9853   if (!*tp)
9854     return NULL_TREE;
9855
9856   /* Don't walk the same tree twice, if the user has requested
9857      that we avoid doing so.  */
9858   if (pset && pointer_set_insert (pset, *tp))
9859     return NULL_TREE;
9860
9861   /* Call the function.  */
9862   walk_subtrees = 1;
9863   result = (*func) (tp, &walk_subtrees, data);
9864
9865   /* If we found something, return it.  */
9866   if (result)
9867     return result;
9868
9869   code = TREE_CODE (*tp);
9870
9871   /* Even if we didn't, FUNC may have decided that there was nothing
9872      interesting below this point in the tree.  */
9873   if (!walk_subtrees)
9874     {
9875       /* But we still need to check our siblings.  */
9876       if (code == TREE_LIST)
9877         WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
9878       else if (code == OMP_CLAUSE)
9879         WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
9880       else
9881         return NULL_TREE;
9882     }
9883
9884   if (lh)
9885     {
9886       result = (*lh) (tp, &walk_subtrees, func, data, pset);
9887       if (result || !walk_subtrees)
9888         return result;
9889     }
9890
9891   switch (code)
9892     {
9893     case ERROR_MARK:
9894     case IDENTIFIER_NODE:
9895     case INTEGER_CST:
9896     case REAL_CST:
9897     case FIXED_CST:
9898     case VECTOR_CST:
9899     case STRING_CST:
9900     case BLOCK:
9901     case PLACEHOLDER_EXPR:
9902     case SSA_NAME:
9903     case FIELD_DECL:
9904     case RESULT_DECL:
9905       /* None of these have subtrees other than those already walked
9906          above.  */
9907       break;
9908
9909     case TREE_LIST:
9910       WALK_SUBTREE (TREE_VALUE (*tp));
9911       WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
9912       break;
9913
9914     case TREE_VEC:
9915       {
9916         int len = TREE_VEC_LENGTH (*tp);
9917
9918         if (len == 0)
9919           break;
9920
9921         /* Walk all elements but the first.  */
9922         while (--len)
9923           WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
9924
9925         /* Now walk the first one as a tail call.  */
9926         WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
9927       }
9928
9929     case COMPLEX_CST:
9930       WALK_SUBTREE (TREE_REALPART (*tp));
9931       WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
9932
9933     case CONSTRUCTOR:
9934       {
9935         unsigned HOST_WIDE_INT idx;
9936         constructor_elt *ce;
9937
9938         for (idx = 0;
9939              VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
9940              idx++)
9941           WALK_SUBTREE (ce->value);
9942       }
9943       break;
9944
9945     case SAVE_EXPR:
9946       WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
9947
9948     case BIND_EXPR:
9949       {
9950         tree decl;
9951         for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
9952           {
9953             /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
9954                into declarations that are just mentioned, rather than
9955                declared; they don't really belong to this part of the tree.
9956                And, we can see cycles: the initializer for a declaration
9957                can refer to the declaration itself.  */
9958             WALK_SUBTREE (DECL_INITIAL (decl));
9959             WALK_SUBTREE (DECL_SIZE (decl));
9960             WALK_SUBTREE (DECL_SIZE_UNIT (decl));
9961           }
9962         WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
9963       }
9964
9965     case STATEMENT_LIST:
9966       {
9967         tree_stmt_iterator i;
9968         for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
9969           WALK_SUBTREE (*tsi_stmt_ptr (i));
9970       }
9971       break;
9972
9973     case OMP_CLAUSE:
9974       switch (OMP_CLAUSE_CODE (*tp))
9975         {
9976         case OMP_CLAUSE_PRIVATE:
9977         case OMP_CLAUSE_SHARED:
9978         case OMP_CLAUSE_FIRSTPRIVATE:
9979         case OMP_CLAUSE_COPYIN:
9980         case OMP_CLAUSE_COPYPRIVATE:
9981         case OMP_CLAUSE_IF:
9982         case OMP_CLAUSE_NUM_THREADS:
9983         case OMP_CLAUSE_SCHEDULE:
9984           WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
9985           /* FALLTHRU */
9986
9987         case OMP_CLAUSE_NOWAIT:
9988         case OMP_CLAUSE_ORDERED:
9989         case OMP_CLAUSE_DEFAULT:
9990         case OMP_CLAUSE_UNTIED:
9991           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
9992
9993         case OMP_CLAUSE_LASTPRIVATE:
9994           WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
9995           WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
9996           WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
9997
9998         case OMP_CLAUSE_COLLAPSE:
9999           {
10000             int i;
10001             for (i = 0; i < 3; i++)
10002               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10003             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10004           }
10005
10006         case OMP_CLAUSE_REDUCTION:
10007           {
10008             int i;
10009             for (i = 0; i < 4; i++)
10010               WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10011             WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10012           }
10013
10014         default:
10015           gcc_unreachable ();
10016         }
10017       break;
10018
10019     case TARGET_EXPR:
10020       {
10021         int i, len;
10022
10023         /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10024            But, we only want to walk once.  */
10025         len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10026         for (i = 0; i < len; ++i)
10027           WALK_SUBTREE (TREE_OPERAND (*tp, i));
10028         WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10029       }
10030
10031     case DECL_EXPR:
10032       /* If this is a TYPE_DECL, walk into the fields of the type that it's
10033          defining.  We only want to walk into these fields of a type in this
10034          case and not in the general case of a mere reference to the type.
10035
10036          The criterion is as follows: if the field can be an expression, it
10037          must be walked only here.  This should be in keeping with the fields
10038          that are directly gimplified in gimplify_type_sizes in order for the
10039          mark/copy-if-shared/unmark machinery of the gimplifier to work with
10040          variable-sized types.
10041
10042          Note that DECLs get walked as part of processing the BIND_EXPR.  */
10043       if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10044         {
10045           tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10046           if (TREE_CODE (*type_p) == ERROR_MARK)
10047             return NULL_TREE;
10048
10049           /* Call the function for the type.  See if it returns anything or
10050              doesn't want us to continue.  If we are to continue, walk both
10051              the normal fields and those for the declaration case.  */
10052           result = (*func) (type_p, &walk_subtrees, data);
10053           if (result || !walk_subtrees)
10054             return result;
10055
10056           result = walk_type_fields (*type_p, func, data, pset, lh);
10057           if (result)
10058             return result;
10059
10060           /* If this is a record type, also walk the fields.  */
10061           if (TREE_CODE (*type_p) == RECORD_TYPE
10062               || TREE_CODE (*type_p) == UNION_TYPE
10063               || TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10064             {
10065               tree field;
10066
10067               for (field = TYPE_FIELDS (*type_p); field;
10068                    field = TREE_CHAIN (field))
10069                 {
10070                   /* We'd like to look at the type of the field, but we can
10071                      easily get infinite recursion.  So assume it's pointed
10072                      to elsewhere in the tree.  Also, ignore things that
10073                      aren't fields.  */
10074                   if (TREE_CODE (field) != FIELD_DECL)
10075                     continue;
10076
10077                   WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10078                   WALK_SUBTREE (DECL_SIZE (field));
10079                   WALK_SUBTREE (DECL_SIZE_UNIT (field));
10080                   if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10081                     WALK_SUBTREE (DECL_QUALIFIER (field));
10082                 }
10083             }
10084
10085           /* Same for scalar types.  */
10086           else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10087                    || TREE_CODE (*type_p) == ENUMERAL_TYPE
10088                    || TREE_CODE (*type_p) == INTEGER_TYPE
10089                    || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10090                    || TREE_CODE (*type_p) == REAL_TYPE)
10091             {
10092               WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10093               WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10094             }
10095
10096           WALK_SUBTREE (TYPE_SIZE (*type_p));
10097           WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10098         }
10099       /* FALLTHRU */
10100
10101     default:
10102       if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10103         {
10104           int i, len;
10105
10106           /* Walk over all the sub-trees of this operand.  */
10107           len = TREE_OPERAND_LENGTH (*tp);
10108
10109           /* Go through the subtrees.  We need to do this in forward order so
10110              that the scope of a FOR_EXPR is handled properly.  */
10111           if (len)
10112             {
10113               for (i = 0; i < len - 1; ++i)
10114                 WALK_SUBTREE (TREE_OPERAND (*tp, i));
10115               WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10116             }
10117         }
10118       /* If this is a type, walk the needed fields in the type.  */
10119       else if (TYPE_P (*tp))
10120         return walk_type_fields (*tp, func, data, pset, lh);
10121       break;
10122     }
10123
10124   /* We didn't find what we were looking for.  */
10125   return NULL_TREE;
10126
10127 #undef WALK_SUBTREE_TAIL
10128 }
10129 #undef WALK_SUBTREE
10130
10131 /* Like walk_tree, but does not walk duplicate nodes more than once.  */
10132
10133 tree
10134 walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10135                                 walk_tree_lh lh)
10136 {
10137   tree result;
10138   struct pointer_set_t *pset;
10139
10140   pset = pointer_set_create ();
10141   result = walk_tree_1 (tp, func, data, pset, lh);
10142   pointer_set_destroy (pset);
10143   return result;
10144 }
10145
10146
10147 tree *
10148 tree_block (tree t)
10149 {
10150   char const c = TREE_CODE_CLASS (TREE_CODE (t));
10151
10152   if (IS_EXPR_CODE_CLASS (c))
10153     return &t->exp.block;
10154   gcc_unreachable ();
10155   return NULL;
10156 }
10157
10158 /* Build and return a TREE_LIST of arguments in the CALL_EXPR exp.
10159    FIXME: don't use this function.  It exists for compatibility with
10160    the old representation of CALL_EXPRs where a list was used to hold the
10161    arguments.  Places that currently extract the arglist from a CALL_EXPR
10162    ought to be rewritten to use the CALL_EXPR itself.  */
10163 tree
10164 call_expr_arglist (tree exp)
10165 {
10166   tree arglist = NULL_TREE;
10167   int i;
10168   for (i = call_expr_nargs (exp) - 1; i >= 0; i--)
10169     arglist = tree_cons (NULL_TREE, CALL_EXPR_ARG (exp, i), arglist);
10170   return arglist;
10171 }
10172
10173
10174 /* Create a nameless artificial label and put it in the current
10175    function context.  The label has a location of LOC.  Returns the
10176    newly created label.  */
10177
10178 tree
10179 create_artificial_label (location_t loc)
10180 {
10181   tree lab = build_decl (loc,
10182                          LABEL_DECL, NULL_TREE, void_type_node);
10183
10184   DECL_ARTIFICIAL (lab) = 1;
10185   DECL_IGNORED_P (lab) = 1;
10186   DECL_CONTEXT (lab) = current_function_decl;
10187   return lab;
10188 }
10189
10190 /*  Given a tree, try to return a useful variable name that we can use
10191     to prefix a temporary that is being assigned the value of the tree.
10192     I.E. given  <temp> = &A, return A.  */
10193
10194 const char *
10195 get_name (tree t)
10196 {
10197   tree stripped_decl;
10198
10199   stripped_decl = t;
10200   STRIP_NOPS (stripped_decl);
10201   if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10202     return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10203   else
10204     {
10205       switch (TREE_CODE (stripped_decl))
10206         {
10207         case ADDR_EXPR:
10208           return get_name (TREE_OPERAND (stripped_decl, 0));
10209         default:
10210           return NULL;
10211         }
10212     }
10213 }
10214
10215 /* Return true if TYPE has a variable argument list.  */
10216
10217 bool
10218 stdarg_p (tree fntype)
10219 {
10220   function_args_iterator args_iter;
10221   tree n = NULL_TREE, t;
10222
10223   if (!fntype)
10224     return false;
10225
10226   FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10227     {
10228       n = t;
10229     }
10230
10231   return n != NULL_TREE && n != void_type_node;
10232 }
10233
10234 /* Return true if TYPE has a prototype.  */
10235
10236 bool
10237 prototype_p (tree fntype)
10238 {
10239   tree t;
10240
10241   gcc_assert (fntype != NULL_TREE);
10242
10243   t = TYPE_ARG_TYPES (fntype);
10244   return (t != NULL_TREE);
10245 }
10246
10247 /* If BLOCK is inlined from an __attribute__((__artificial__))
10248    routine, return pointer to location from where it has been
10249    called.  */
10250 location_t *
10251 block_nonartificial_location (tree block)
10252 {
10253   location_t *ret = NULL;
10254
10255   while (block && TREE_CODE (block) == BLOCK
10256          && BLOCK_ABSTRACT_ORIGIN (block))
10257     {
10258       tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10259
10260       while (TREE_CODE (ao) == BLOCK
10261              && BLOCK_ABSTRACT_ORIGIN (ao)
10262              && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10263         ao = BLOCK_ABSTRACT_ORIGIN (ao);
10264
10265       if (TREE_CODE (ao) == FUNCTION_DECL)
10266         {
10267           /* If AO is an artificial inline, point RET to the
10268              call site locus at which it has been inlined and continue
10269              the loop, in case AO's caller is also an artificial
10270              inline.  */
10271           if (DECL_DECLARED_INLINE_P (ao)
10272               && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10273             ret = &BLOCK_SOURCE_LOCATION (block);
10274           else
10275             break;
10276         }
10277       else if (TREE_CODE (ao) != BLOCK)
10278         break;
10279
10280       block = BLOCK_SUPERCONTEXT (block);
10281     }
10282   return ret;
10283 }
10284
10285
10286 /* If EXP is inlined from an __attribute__((__artificial__))
10287    function, return the location of the original call expression.  */
10288
10289 location_t
10290 tree_nonartificial_location (tree exp)
10291 {
10292   location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10293
10294   if (loc)
10295     return *loc;
10296   else
10297     return EXPR_LOCATION (exp);
10298 }
10299
10300
10301 /* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10302    nodes.  */
10303
10304 /* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
10305
10306 static hashval_t
10307 cl_option_hash_hash (const void *x)
10308 {
10309   const_tree const t = (const_tree) x;
10310   const char *p;
10311   size_t i;
10312   size_t len = 0;
10313   hashval_t hash = 0;
10314
10315   if (TREE_CODE (t) == OPTIMIZATION_NODE)
10316     {
10317       p = (const char *)TREE_OPTIMIZATION (t);
10318       len = sizeof (struct cl_optimization);
10319     }
10320
10321   else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10322     {
10323       p = (const char *)TREE_TARGET_OPTION (t);
10324       len = sizeof (struct cl_target_option);
10325     }
10326
10327   else
10328     gcc_unreachable ();
10329
10330   /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10331      something else.  */
10332   for (i = 0; i < len; i++)
10333     if (p[i])
10334       hash = (hash << 4) ^ ((i << 2) | p[i]);
10335
10336   return hash;
10337 }
10338
10339 /* Return nonzero if the value represented by *X (an OPTIMIZATION or
10340    TARGET_OPTION tree node) is the same as that given by *Y, which is the
10341    same.  */
10342
10343 static int
10344 cl_option_hash_eq (const void *x, const void *y)
10345 {
10346   const_tree const xt = (const_tree) x;
10347   const_tree const yt = (const_tree) y;
10348   const char *xp;
10349   const char *yp;
10350   size_t len;
10351
10352   if (TREE_CODE (xt) != TREE_CODE (yt))
10353     return 0;
10354
10355   if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10356     {
10357       xp = (const char *)TREE_OPTIMIZATION (xt);
10358       yp = (const char *)TREE_OPTIMIZATION (yt);
10359       len = sizeof (struct cl_optimization);
10360     }
10361
10362   else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10363     {
10364       xp = (const char *)TREE_TARGET_OPTION (xt);
10365       yp = (const char *)TREE_TARGET_OPTION (yt);
10366       len = sizeof (struct cl_target_option);
10367     }
10368
10369   else
10370     gcc_unreachable ();
10371
10372   return (memcmp (xp, yp, len) == 0);
10373 }
10374
10375 /* Build an OPTIMIZATION_NODE based on the current options.  */
10376
10377 tree
10378 build_optimization_node (void)
10379 {
10380   tree t;
10381   void **slot;
10382
10383   /* Use the cache of optimization nodes.  */
10384
10385   cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
10386
10387   slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10388   t = (tree) *slot;
10389   if (!t)
10390     {
10391       /* Insert this one into the hash table.  */
10392       t = cl_optimization_node;
10393       *slot = t;
10394
10395       /* Make a new node for next time round.  */
10396       cl_optimization_node = make_node (OPTIMIZATION_NODE);
10397     }
10398
10399   return t;
10400 }
10401
10402 /* Build a TARGET_OPTION_NODE based on the current options.  */
10403
10404 tree
10405 build_target_option_node (void)
10406 {
10407   tree t;
10408   void **slot;
10409
10410   /* Use the cache of optimization nodes.  */
10411
10412   cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
10413
10414   slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10415   t = (tree) *slot;
10416   if (!t)
10417     {
10418       /* Insert this one into the hash table.  */
10419       t = cl_target_option_node;
10420       *slot = t;
10421
10422       /* Make a new node for next time round.  */
10423       cl_target_option_node = make_node (TARGET_OPTION_NODE);
10424     }
10425
10426   return t;
10427 }
10428
10429 /* Determine the "ultimate origin" of a block.  The block may be an inlined
10430    instance of an inlined instance of a block which is local to an inline
10431    function, so we have to trace all of the way back through the origin chain
10432    to find out what sort of node actually served as the original seed for the
10433    given block.  */
10434
10435 tree
10436 block_ultimate_origin (const_tree block)
10437 {
10438   tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10439
10440   /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10441      nodes in the function to point to themselves; ignore that if
10442      we're trying to output the abstract instance of this function.  */
10443   if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10444     return NULL_TREE;
10445
10446   if (immediate_origin == NULL_TREE)
10447     return NULL_TREE;
10448   else
10449     {
10450       tree ret_val;
10451       tree lookahead = immediate_origin;
10452
10453       do
10454         {
10455           ret_val = lookahead;
10456           lookahead = (TREE_CODE (ret_val) == BLOCK
10457                        ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10458         }
10459       while (lookahead != NULL && lookahead != ret_val);
10460
10461       /* The block's abstract origin chain may not be the *ultimate* origin of
10462          the block. It could lead to a DECL that has an abstract origin set.
10463          If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10464          will give us if it has one).  Note that DECL's abstract origins are
10465          supposed to be the most distant ancestor (or so decl_ultimate_origin
10466          claims), so we don't need to loop following the DECL origins.  */
10467       if (DECL_P (ret_val))
10468         return DECL_ORIGIN (ret_val);
10469
10470       return ret_val;
10471     }
10472 }
10473
10474 /* Return true if T1 and T2 are equivalent lists.  */
10475
10476 bool
10477 list_equal_p (const_tree t1, const_tree t2)
10478 {
10479   for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10480     if (TREE_VALUE (t1) != TREE_VALUE (t2))
10481       return false;
10482   return !t1 && !t2;
10483 }
10484
10485 /* Return true iff conversion in EXP generates no instruction.  Mark
10486    it inline so that we fully inline into the stripping functions even
10487    though we have two uses of this function.  */
10488
10489 static inline bool
10490 tree_nop_conversion (const_tree exp)
10491 {
10492   tree outer_type, inner_type;
10493
10494   if (!CONVERT_EXPR_P (exp)
10495       && TREE_CODE (exp) != NON_LVALUE_EXPR)
10496     return false;
10497   if (TREE_OPERAND (exp, 0) == error_mark_node)
10498     return false;
10499
10500   outer_type = TREE_TYPE (exp);
10501   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10502
10503   /* Use precision rather then machine mode when we can, which gives
10504      the correct answer even for submode (bit-field) types.  */
10505   if ((INTEGRAL_TYPE_P (outer_type)
10506        || POINTER_TYPE_P (outer_type)
10507        || TREE_CODE (outer_type) == OFFSET_TYPE)
10508       && (INTEGRAL_TYPE_P (inner_type)
10509           || POINTER_TYPE_P (inner_type)
10510           || TREE_CODE (inner_type) == OFFSET_TYPE))
10511     return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10512
10513   /* Otherwise fall back on comparing machine modes (e.g. for
10514      aggregate types, floats).  */
10515   return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10516 }
10517
10518 /* Return true iff conversion in EXP generates no instruction.  Don't
10519    consider conversions changing the signedness.  */
10520
10521 static bool
10522 tree_sign_nop_conversion (const_tree exp)
10523 {
10524   tree outer_type, inner_type;
10525
10526   if (!tree_nop_conversion (exp))
10527     return false;
10528
10529   outer_type = TREE_TYPE (exp);
10530   inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10531
10532   return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10533           && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10534 }
10535
10536 /* Strip conversions from EXP according to tree_nop_conversion and
10537    return the resulting expression.  */
10538
10539 tree
10540 tree_strip_nop_conversions (tree exp)
10541 {
10542   while (tree_nop_conversion (exp))
10543     exp = TREE_OPERAND (exp, 0);
10544   return exp;
10545 }
10546
10547 /* Strip conversions from EXP according to tree_sign_nop_conversion
10548    and return the resulting expression.  */
10549
10550 tree
10551 tree_strip_sign_nop_conversions (tree exp)
10552 {
10553   while (tree_sign_nop_conversion (exp))
10554     exp = TREE_OPERAND (exp, 0);
10555   return exp;
10556 }
10557
10558
10559 #include "gt-tree.h"