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