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 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 /* This file contains the low level primitives for operating on tree nodes,
  23    including allocation, list operations, interning of identifiers,
  24    construction of data type nodes and statement nodes,
  25    and construction of type conversion nodes.  It also contains
  26    tables index by tree code that describe how to take apart
  27    nodes of that code.
  28
  29    It is intended to be language-independent, but occasionally
  30    calls language-dependent routines defined (for C) in typecheck.c.  */
  31
  32 #include "config.h"
  33 #include "system.h"
  34 #include "coretypes.h"
  35 #include "tm.h"
  36 #include "flags.h"
  37 #include "tree.h"
  38 #include "real.h"
  39 #include "tm_p.h"
  40 #include "function.h"
  41 #include "obstack.h"
  42 #include "toplev.h"
  43 #include "ggc.h"
  44 #include "hashtab.h"
  45 #include "output.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48
  49 /* obstack.[ch] explicitly declined to prototype this.  */
  50 extern int _obstack_allocated_p PARAMS ((struct obstack *h, void *obj));
  51
  52 #ifdef GATHER_STATISTICS
  53 /* Statistics-gathering stuff.  */
  54 typedef enum
  55 {
  56   d_kind,
  57   t_kind,
  58   b_kind,
  59   s_kind,
  60   r_kind,
  61   e_kind,
  62   c_kind,
  63   id_kind,
  64   perm_list_kind,
  65   temp_list_kind,
  66   vec_kind,
  67   x_kind,
  68   lang_decl,
  69   lang_type,
  70   all_kinds
  71 } tree_node_kind;
  72
  73 int tree_node_counts[(int) all_kinds];
  74 int tree_node_sizes[(int) all_kinds];
  75
  76 static const char * const tree_node_kind_names[] = {
  77   "decls",
  78   "types",
  79   "blocks",
  80   "stmts",
  81   "refs",
  82   "exprs",
  83   "constants",
  84   "identifiers",
  85   "perm_tree_lists",
  86   "temp_tree_lists",
  87   "vecs",
  88   "random kinds",
  89   "lang_decl kinds",
  90   "lang_type kinds"
  91 };
  92 #endif /* GATHER_STATISTICS */
  93
  94 /* Unique id for next decl created.  */
  95 static GTY(()) int next_decl_uid;
  96 /* Unique id for next type created.  */
  97 static GTY(()) int next_type_uid = 1;
  98
  99 /* Since we cannot rehash a type after it is in the table, we have to
 100    keep the hash code.  */
 101
 102 struct type_hash GTY(())
 103 {
 104   unsigned long hash;
 105   tree type;
 106 };
 107
 108 /* Initial size of the hash table (rounded to next prime).  */
 109 #define TYPE_HASH_INITIAL_SIZE 1000
 110
 111 /* Now here is the hash table.  When recording a type, it is added to
 112    the slot whose index is the hash code.  Note that the hash table is
 113    used for several kinds of types (function types, array types and
 114    array index range types, for now).  While all these live in the
 115    same table, they are completely independent, and the hash code is
 116    computed differently for each of these.  */
 117
 118 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
 119      htab_t type_hash_table;
 120
 121 static void set_type_quals PARAMS ((tree, int));
 122 static void append_random_chars PARAMS ((char *));
 123 static int type_hash_eq PARAMS ((const void *, const void *));
 124 static hashval_t type_hash_hash PARAMS ((const void *));
 125 static void print_type_hash_statistics PARAMS((void));
 126 static void finish_vector_type PARAMS((tree));
 127 static tree make_vector PARAMS ((enum machine_mode, tree, int));
 128 static int type_hash_marked_p PARAMS ((const void *));
 129
 130 tree global_trees[TI_MAX];
 131 tree integer_types[itk_none];
 132 \f
 133 /* Init tree.c.  */
 134
 135 void
 136 init_ttree ()
 137 {
 138   /* Initialize the hash table of types.  */
 139   type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
 140                                      type_hash_eq, 0);
 141 }
 142
 143 \f
 144 /* The name of the object as the assembler will see it (but before any
 145    translations made by ASM_OUTPUT_LABELREF).  Often this is the same
 146    as DECL_NAME.  It is an IDENTIFIER_NODE.  */
 147 tree
 148 decl_assembler_name (decl)
 149      tree decl;
 150 {
 151   if (!DECL_ASSEMBLER_NAME_SET_P (decl))
 152     (*lang_hooks.set_decl_assembler_name) (decl);
 153   return DECL_CHECK (decl)->decl.assembler_name;
 154 }
 155
 156 /* Compute the number of bytes occupied by 'node'.  This routine only
 157    looks at TREE_CODE and, if the code is TREE_VEC, TREE_VEC_LENGTH.  */
 158 size_t
 159 tree_size (node)
 160      tree node;
 161 {
 162   enum tree_code code = TREE_CODE (node);
 163
 164   switch (TREE_CODE_CLASS (code))
 165     {
 166     case 'd':  /* A decl node */
 167       return sizeof (struct tree_decl);
 168
 169     case 't':  /* a type node */
 170       return sizeof (struct tree_type);
 171
 172     case 'b':  /* a lexical block node */
 173       return sizeof (struct tree_block);
 174
 175     case 'r':  /* a reference */
 176     case 'e':  /* an expression */
 177     case 's':  /* an expression with side effects */
 178     case '<':  /* a comparison expression */
 179     case '1':  /* a unary arithmetic expression */
 180     case '2':  /* a binary arithmetic expression */
 181       return (sizeof (struct tree_exp)
 182               + TREE_CODE_LENGTH (code) * sizeof (char *) - sizeof (char *));
 183
 184     case 'c':  /* a constant */
 185       switch (code)
 186         {
 187         case INTEGER_CST:       return sizeof (struct tree_int_cst);
 188         case REAL_CST:          return sizeof (struct tree_real_cst);
 189         case COMPLEX_CST:       return sizeof (struct tree_complex);
 190         case VECTOR_CST:        return sizeof (struct tree_vector);
 191         case STRING_CST:        return sizeof (struct tree_string);
 192         default:
 193           return (*lang_hooks.tree_size) (code);
 194         }
 195
 196     case 'x':  /* something random, like an identifier.  */
 197       switch (code)
 198         {
 199         case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
 200         case TREE_LIST:         return sizeof (struct tree_list);
 201         case TREE_VEC:          return (sizeof (struct tree_vec)
 202                                         + TREE_VEC_LENGTH(node) * sizeof(char *)
 203                                         - sizeof (char *));
 204
 205         case ERROR_MARK:
 206         case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
 207
 208         default:
 209           return (*lang_hooks.tree_size) (code);
 210         }
 211
 212     default:
 213       abort ();
 214     }
 215 }
 216
 217 /* Return a newly allocated node of code CODE.
 218    For decl and type nodes, some other fields are initialized.
 219    The rest of the node is initialized to zero.
 220
 221    Achoo!  I got a code in the node.  */
 222
 223 tree
 224 make_node (code)
 225      enum tree_code code;
 226 {
 227   tree t;
 228   int type = TREE_CODE_CLASS (code);
 229   size_t length;
 230 #ifdef GATHER_STATISTICS
 231   tree_node_kind kind;
 232 #endif
 233   struct tree_common ttmp;
 234
 235   /* We can't allocate a TREE_VEC without knowing how many elements
 236      it will have.  */
 237   if (code == TREE_VEC)
 238     abort ();
 239
 240   TREE_SET_CODE ((tree)&ttmp, code);
 241   length = tree_size ((tree)&ttmp);
 242
 243 #ifdef GATHER_STATISTICS
 244   switch (type)
 245     {
 246     case 'd':  /* A decl node */
 247       kind = d_kind;
 248       break;
 249
 250     case 't':  /* a type node */
 251       kind = t_kind;
 252       break;
 253
 254     case 'b':  /* a lexical block */
 255       kind = b_kind;
 256       break;
 257
 258     case 's':  /* an expression with side effects */
 259       kind = s_kind;
 260       break;
 261
 262     case 'r':  /* a reference */
 263       kind = r_kind;
 264       break;
 265
 266     case 'e':  /* an expression */
 267     case '<':  /* a comparison expression */
 268     case '1':  /* a unary arithmetic expression */
 269     case '2':  /* a binary arithmetic expression */
 270       kind = e_kind;
 271       break;
 272
 273     case 'c':  /* a constant */
 274       kind = c_kind;
 275       break;
 276
 277     case 'x':  /* something random, like an identifier.  */
 278       if (code == IDENTIFIER_NODE)
 279         kind = id_kind;
 280       else if (code == TREE_VEC)
 281         kind = vec_kind;
 282       else
 283         kind = x_kind;
 284       break;
 285
 286     default:
 287       abort ();
 288     }
 289
 290   tree_node_counts[(int) kind]++;
 291   tree_node_sizes[(int) kind] += length;
 292 #endif
 293
 294   t = ggc_alloc_tree (length);
 295
 296   memset (t, 0, length);
 297
 298   TREE_SET_CODE (t, code);
 299
 300   switch (type)
 301     {
 302     case 's':
 303       TREE_SIDE_EFFECTS (t) = 1;
 304       break;
 305
 306     case 'd':
 307       if (code != FUNCTION_DECL)
 308         DECL_ALIGN (t) = 1;
 309       DECL_USER_ALIGN (t) = 0;
 310       DECL_IN_SYSTEM_HEADER (t) = in_system_header;
 311       DECL_SOURCE_LOCATION (t) = input_location;
 312       DECL_UID (t) = next_decl_uid++;
 313
 314       /* We have not yet computed the alias set for this declaration.  */
 315       DECL_POINTER_ALIAS_SET (t) = -1;
 316       break;
 317
 318     case 't':
 319       TYPE_UID (t) = next_type_uid++;
 320       TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
 321       TYPE_USER_ALIGN (t) = 0;
 322       TYPE_MAIN_VARIANT (t) = t;
 323
 324       /* Default to no attributes for type, but let target change that.  */
 325       TYPE_ATTRIBUTES (t) = NULL_TREE;
 326       (*targetm.set_default_type_attributes) (t);
 327
 328       /* We have not yet computed the alias set for this type.  */
 329       TYPE_ALIAS_SET (t) = -1;
 330       break;
 331
 332     case 'c':
 333       TREE_CONSTANT (t) = 1;
 334       break;
 335
 336     case 'e':
 337       switch (code)
 338         {
 339         case INIT_EXPR:
 340         case MODIFY_EXPR:
 341         case VA_ARG_EXPR:
 342         case RTL_EXPR:
 343         case PREDECREMENT_EXPR:
 344         case PREINCREMENT_EXPR:
 345         case POSTDECREMENT_EXPR:
 346         case POSTINCREMENT_EXPR:
 347           /* All of these have side-effects, no matter what their
 348              operands are.  */
 349           TREE_SIDE_EFFECTS (t) = 1;
 350           break;
 351
 352         default:
 353           break;
 354         }
 355       break;
 356     }
 357
 358   return t;
 359 }
 360 \f
 361 /* Return a new node with the same contents as NODE except that its
 362    TREE_CHAIN is zero and it has a fresh uid.  */
 363
 364 tree
 365 copy_node (node)
 366      tree node;
 367 {
 368   tree t;
 369   enum tree_code code = TREE_CODE (node);
 370   size_t length;
 371
 372   length = tree_size (node);
 373   t = ggc_alloc_tree (length);
 374   memcpy (t, node, length);
 375
 376   TREE_CHAIN (t) = 0;
 377   TREE_ASM_WRITTEN (t) = 0;
 378
 379   if (TREE_CODE_CLASS (code) == 'd')
 380     DECL_UID (t) = next_decl_uid++;
 381   else if (TREE_CODE_CLASS (code) == 't')
 382     {
 383       TYPE_UID (t) = next_type_uid++;
 384       /* The following is so that the debug code for
 385          the copy is different from the original type.
 386          The two statements usually duplicate each other
 387          (because they clear fields of the same union),
 388          but the optimizer should catch that.  */
 389       TYPE_SYMTAB_POINTER (t) = 0;
 390       TYPE_SYMTAB_ADDRESS (t) = 0;
 391     }
 392
 393   return t;
 394 }
 395
 396 /* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
 397    For example, this can copy a list made of TREE_LIST nodes.  */
 398
 399 tree
 400 copy_list (list)
 401      tree list;
 402 {
 403   tree head;
 404   tree prev, next;
 405
 406   if (list == 0)
 407     return 0;
 408
 409   head = prev = copy_node (list);
 410   next = TREE_CHAIN (list);
 411   while (next)
 412     {
 413       TREE_CHAIN (prev) = copy_node (next);
 414       prev = TREE_CHAIN (prev);
 415       next = TREE_CHAIN (next);
 416     }
 417   return head;
 418 }
 419
 420 \f
 421 /* Return a newly constructed INTEGER_CST node whose constant value
 422    is specified by the two ints LOW and HI.
 423    The TREE_TYPE is set to `int'.
 424
 425    This function should be used via the `build_int_2' macro.  */
 426
 427 tree
 428 build_int_2_wide (low, hi)
 429      unsigned HOST_WIDE_INT low;
 430      HOST_WIDE_INT hi;
 431 {
 432   tree t = make_node (INTEGER_CST);
 433
 434   TREE_INT_CST_LOW (t) = low;
 435   TREE_INT_CST_HIGH (t) = hi;
 436   TREE_TYPE (t) = integer_type_node;
 437   return t;
 438 }
 439
 440 /* Return a new VECTOR_CST node whose type is TYPE and whose values
 441    are in a list pointed by VALS.  */
 442
 443 tree
 444 build_vector (type, vals)
 445      tree type, vals;
 446 {
 447   tree v = make_node (VECTOR_CST);
 448   int over1 = 0, over2 = 0;
 449   tree link;
 450
 451   TREE_VECTOR_CST_ELTS (v) = vals;
 452   TREE_TYPE (v) = type;
 453
 454   /* Iterate through elements and check for overflow.  */
 455   for (link = vals; link; link = TREE_CHAIN (link))
 456     {
 457       tree value = TREE_VALUE (link);
 458
 459       over1 |= TREE_OVERFLOW (value);
 460       over2 |= TREE_CONSTANT_OVERFLOW (value);
 461     }
 462
 463   TREE_OVERFLOW (v) = over1;
 464   TREE_CONSTANT_OVERFLOW (v) = over2;
 465
 466   return v;
 467 }
 468
 469 /* Return a new CONSTRUCTOR node whose type is TYPE and whose values
 470    are in a list pointed to by VALS.  */
 471 tree
 472 build_constructor (type, vals)
 473      tree type, vals;
 474 {
 475   tree c = make_node (CONSTRUCTOR);
 476   TREE_TYPE (c) = type;
 477   CONSTRUCTOR_ELTS (c) = vals;
 478
 479   /* ??? May not be necessary.  Mirrors what build does.  */
 480   if (vals)
 481     {
 482       TREE_SIDE_EFFECTS (c) = TREE_SIDE_EFFECTS (vals);
 483       TREE_READONLY (c) = TREE_READONLY (vals);
 484       TREE_CONSTANT (c) = TREE_CONSTANT (vals);
 485     }
 486   else
 487     TREE_CONSTANT (c) = 0;  /* safe side */
 488
 489   return c;
 490 }
 491
 492 /* Return a new REAL_CST node whose type is TYPE and value is D.  */
 493
 494 tree
 495 build_real (type, d)
 496      tree type;
 497      REAL_VALUE_TYPE d;
 498 {
 499   tree v;
 500   REAL_VALUE_TYPE *dp;
 501   int overflow = 0;
 502
 503   /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
 504      Consider doing it via real_convert now.  */
 505
 506   v = make_node (REAL_CST);
 507   dp = ggc_alloc (sizeof (REAL_VALUE_TYPE));
 508   memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
 509
 510   TREE_TYPE (v) = type;
 511   TREE_REAL_CST_PTR (v) = dp;
 512   TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
 513   return v;
 514 }
 515
 516 /* Return a new REAL_CST node whose type is TYPE
 517    and whose value is the integer value of the INTEGER_CST node I.  */
 518
 519 REAL_VALUE_TYPE
 520 real_value_from_int_cst (type, i)
 521      tree type ATTRIBUTE_UNUSED, i;
 522 {
 523   REAL_VALUE_TYPE d;
 524
 525   /* Clear all bits of the real value type so that we can later do
 526      bitwise comparisons to see if two values are the same.  */
 527   memset ((char *) &d, 0, sizeof d);
 528
 529   if (! TREE_UNSIGNED (TREE_TYPE (i)))
 530     REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
 531                          TYPE_MODE (type));
 532   else
 533     REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
 534                                   TREE_INT_CST_HIGH (i), TYPE_MODE (type));
 535   return d;
 536 }
 537
 538 /* Given a tree representing an integer constant I, return a tree
 539    representing the same value as a floating-point constant of type TYPE.  */
 540
 541 tree
 542 build_real_from_int_cst (type, i)
 543      tree type;
 544      tree i;
 545 {
 546   tree v;
 547   int overflow = TREE_OVERFLOW (i);
 548
 549   v = build_real (type, real_value_from_int_cst (type, i));
 550
 551   TREE_OVERFLOW (v) |= overflow;
 552   TREE_CONSTANT_OVERFLOW (v) |= overflow;
 553   return v;
 554 }
 555
 556 /* Return a newly constructed STRING_CST node whose value is
 557    the LEN characters at STR.
 558    The TREE_TYPE is not initialized.  */
 559
 560 tree
 561 build_string (len, str)
 562      int len;
 563      const char *str;
 564 {
 565   tree s = make_node (STRING_CST);
 566
 567   TREE_STRING_LENGTH (s) = len;
 568   TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
 569
 570   return s;
 571 }
 572
 573 /* Return a newly constructed COMPLEX_CST node whose value is
 574    specified by the real and imaginary parts REAL and IMAG.
 575    Both REAL and IMAG should be constant nodes.  TYPE, if specified,
 576    will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
 577
 578 tree
 579 build_complex (type, real, imag)
 580      tree type;
 581      tree real, imag;
 582 {
 583   tree t = make_node (COMPLEX_CST);
 584
 585   TREE_REALPART (t) = real;
 586   TREE_IMAGPART (t) = imag;
 587   TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
 588   TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
 589   TREE_CONSTANT_OVERFLOW (t)
 590     = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
 591   return t;
 592 }
 593
 594 /* Build a newly constructed TREE_VEC node of length LEN.  */
 595
 596 tree
 597 make_tree_vec (len)
 598      int len;
 599 {
 600   tree t;
 601   int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
 602
 603 #ifdef GATHER_STATISTICS
 604   tree_node_counts[(int) vec_kind]++;
 605   tree_node_sizes[(int) vec_kind] += length;
 606 #endif
 607
 608   t = ggc_alloc_tree (length);
 609
 610   memset (t, 0, length);
 611   TREE_SET_CODE (t, TREE_VEC);
 612   TREE_VEC_LENGTH (t) = len;
 613
 614   return t;
 615 }
 616 \f
 617 /* Return 1 if EXPR is the integer constant zero or a complex constant
 618    of zero.  */
 619
 620 int
 621 integer_zerop (expr)
 622      tree expr;
 623 {
 624   STRIP_NOPS (expr);
 625
 626   return ((TREE_CODE (expr) == INTEGER_CST
 627            && ! TREE_CONSTANT_OVERFLOW (expr)
 628            && TREE_INT_CST_LOW (expr) == 0
 629            && TREE_INT_CST_HIGH (expr) == 0)
 630           || (TREE_CODE (expr) == COMPLEX_CST
 631               && integer_zerop (TREE_REALPART (expr))
 632               && integer_zerop (TREE_IMAGPART (expr))));
 633 }
 634
 635 /* Return 1 if EXPR is the integer constant one or the corresponding
 636    complex constant.  */
 637
 638 int
 639 integer_onep (expr)
 640      tree expr;
 641 {
 642   STRIP_NOPS (expr);
 643
 644   return ((TREE_CODE (expr) == INTEGER_CST
 645            && ! TREE_CONSTANT_OVERFLOW (expr)
 646            && TREE_INT_CST_LOW (expr) == 1
 647            && TREE_INT_CST_HIGH (expr) == 0)
 648           || (TREE_CODE (expr) == COMPLEX_CST
 649               && integer_onep (TREE_REALPART (expr))
 650               && integer_zerop (TREE_IMAGPART (expr))));
 651 }
 652
 653 /* Return 1 if EXPR is an integer containing all 1's in as much precision as
 654    it contains.  Likewise for the corresponding complex constant.  */
 655
 656 int
 657 integer_all_onesp (expr)
 658      tree expr;
 659 {
 660   int prec;
 661   int uns;
 662
 663   STRIP_NOPS (expr);
 664
 665   if (TREE_CODE (expr) == COMPLEX_CST
 666       && integer_all_onesp (TREE_REALPART (expr))
 667       && integer_zerop (TREE_IMAGPART (expr)))
 668     return 1;
 669
 670   else if (TREE_CODE (expr) != INTEGER_CST
 671            || TREE_CONSTANT_OVERFLOW (expr))
 672     return 0;
 673
 674   uns = TREE_UNSIGNED (TREE_TYPE (expr));
 675   if (!uns)
 676     return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
 677             && TREE_INT_CST_HIGH (expr) == -1);
 678
 679   /* Note that using TYPE_PRECISION here is wrong.  We care about the
 680      actual bits, not the (arbitrary) range of the type.  */
 681   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
 682   if (prec >= HOST_BITS_PER_WIDE_INT)
 683     {
 684       HOST_WIDE_INT high_value;
 685       int shift_amount;
 686
 687       shift_amount = prec - HOST_BITS_PER_WIDE_INT;
 688
 689       if (shift_amount > HOST_BITS_PER_WIDE_INT)
 690         /* Can not handle precisions greater than twice the host int size.  */
 691         abort ();
 692       else if (shift_amount == HOST_BITS_PER_WIDE_INT)
 693         /* Shifting by the host word size is undefined according to the ANSI
 694            standard, so we must handle this as a special case.  */
 695         high_value = -1;
 696       else
 697         high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
 698
 699       return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
 700               && TREE_INT_CST_HIGH (expr) == high_value);
 701     }
 702   else
 703     return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
 704 }
 705
 706 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
 707    one bit on).  */
 708
 709 int
 710 integer_pow2p (expr)
 711      tree expr;
 712 {
 713   int prec;
 714   HOST_WIDE_INT high, low;
 715
 716   STRIP_NOPS (expr);
 717
 718   if (TREE_CODE (expr) == COMPLEX_CST
 719       && integer_pow2p (TREE_REALPART (expr))
 720       && integer_zerop (TREE_IMAGPART (expr)))
 721     return 1;
 722
 723   if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
 724     return 0;
 725
 726   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
 727           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
 728   high = TREE_INT_CST_HIGH (expr);
 729   low = TREE_INT_CST_LOW (expr);
 730
 731   /* First clear all bits that are beyond the type's precision in case
 732      we've been sign extended.  */
 733
 734   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 735     ;
 736   else if (prec > HOST_BITS_PER_WIDE_INT)
 737     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 738   else
 739     {
 740       high = 0;
 741       if (prec < HOST_BITS_PER_WIDE_INT)
 742         low &= ~((HOST_WIDE_INT) (-1) << prec);
 743     }
 744
 745   if (high == 0 && low == 0)
 746     return 0;
 747
 748   return ((high == 0 && (low & (low - 1)) == 0)
 749           || (low == 0 && (high & (high - 1)) == 0));
 750 }
 751
 752 /* Return 1 if EXPR is an integer constant other than zero or a
 753    complex constant other than zero.  */
 754
 755 int
 756 integer_nonzerop (expr)
 757      tree expr;
 758 {
 759   STRIP_NOPS (expr);
 760
 761   return ((TREE_CODE (expr) == INTEGER_CST
 762            && ! TREE_CONSTANT_OVERFLOW (expr)
 763            && (TREE_INT_CST_LOW (expr) != 0
 764                || TREE_INT_CST_HIGH (expr) != 0))
 765           || (TREE_CODE (expr) == COMPLEX_CST
 766               && (integer_nonzerop (TREE_REALPART (expr))
 767                   || integer_nonzerop (TREE_IMAGPART (expr)))));
 768 }
 769
 770 /* Return the power of two represented by a tree node known to be a
 771    power of two.  */
 772
 773 int
 774 tree_log2 (expr)
 775      tree expr;
 776 {
 777   int prec;
 778   HOST_WIDE_INT high, low;
 779
 780   STRIP_NOPS (expr);
 781
 782   if (TREE_CODE (expr) == COMPLEX_CST)
 783     return tree_log2 (TREE_REALPART (expr));
 784
 785   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
 786           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
 787
 788   high = TREE_INT_CST_HIGH (expr);
 789   low = TREE_INT_CST_LOW (expr);
 790
 791   /* First clear all bits that are beyond the type's precision in case
 792      we've been sign extended.  */
 793
 794   if (prec == 2 * HOST_BITS_PER_WIDE_INT)
 795     ;
 796   else if (prec > HOST_BITS_PER_WIDE_INT)
 797     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 798   else
 799     {
 800       high = 0;
 801       if (prec < HOST_BITS_PER_WIDE_INT)
 802         low &= ~((HOST_WIDE_INT) (-1) << prec);
 803     }
 804
 805   return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
 806           : exact_log2 (low));
 807 }
 808
 809 /* Similar, but return the largest integer Y such that 2 ** Y is less
 810    than or equal to EXPR.  */
 811
 812 int
 813 tree_floor_log2 (expr)
 814      tree expr;
 815 {
 816   int prec;
 817   HOST_WIDE_INT high, low;
 818
 819   STRIP_NOPS (expr);
 820
 821   if (TREE_CODE (expr) == COMPLEX_CST)
 822     return tree_log2 (TREE_REALPART (expr));
 823
 824   prec = (POINTER_TYPE_P (TREE_TYPE (expr))
 825           ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
 826
 827   high = TREE_INT_CST_HIGH (expr);
 828   low = TREE_INT_CST_LOW (expr);
 829
 830   /* First clear all bits that are beyond the type's precision in case
 831      we've been sign extended.  Ignore if type's precision hasn't been set
 832      since what we are doing is setting it.  */
 833
 834   if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
 835     ;
 836   else if (prec > HOST_BITS_PER_WIDE_INT)
 837     high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
 838   else
 839     {
 840       high = 0;
 841       if (prec < HOST_BITS_PER_WIDE_INT)
 842         low &= ~((HOST_WIDE_INT) (-1) << prec);
 843     }
 844
 845   return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
 846           : floor_log2 (low));
 847 }
 848
 849 /* Return 1 if EXPR is the real constant zero.  */
 850
 851 int
 852 real_zerop (expr)
 853      tree expr;
 854 {
 855   STRIP_NOPS (expr);
 856
 857   return ((TREE_CODE (expr) == REAL_CST
 858            && ! TREE_CONSTANT_OVERFLOW (expr)
 859            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
 860           || (TREE_CODE (expr) == COMPLEX_CST
 861               && real_zerop (TREE_REALPART (expr))
 862               && real_zerop (TREE_IMAGPART (expr))));
 863 }
 864
 865 /* Return 1 if EXPR is the real constant one in real or complex form.  */
 866
 867 int
 868 real_onep (expr)
 869      tree expr;
 870 {
 871   STRIP_NOPS (expr);
 872
 873   return ((TREE_CODE (expr) == REAL_CST
 874            && ! TREE_CONSTANT_OVERFLOW (expr)
 875            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
 876           || (TREE_CODE (expr) == COMPLEX_CST
 877               && real_onep (TREE_REALPART (expr))
 878               && real_zerop (TREE_IMAGPART (expr))));
 879 }
 880
 881 /* Return 1 if EXPR is the real constant two.  */
 882
 883 int
 884 real_twop (expr)
 885      tree expr;
 886 {
 887   STRIP_NOPS (expr);
 888
 889   return ((TREE_CODE (expr) == REAL_CST
 890            && ! TREE_CONSTANT_OVERFLOW (expr)
 891            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
 892           || (TREE_CODE (expr) == COMPLEX_CST
 893               && real_twop (TREE_REALPART (expr))
 894               && real_zerop (TREE_IMAGPART (expr))));
 895 }
 896
 897 /* Return 1 if EXPR is the real constant minus one.  */
 898
 899 int
 900 real_minus_onep (expr)
 901      tree expr;
 902 {
 903   STRIP_NOPS (expr);
 904
 905   return ((TREE_CODE (expr) == REAL_CST
 906            && ! TREE_CONSTANT_OVERFLOW (expr)
 907            && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
 908           || (TREE_CODE (expr) == COMPLEX_CST
 909               && real_minus_onep (TREE_REALPART (expr))
 910               && real_zerop (TREE_IMAGPART (expr))));
 911 }
 912
 913 /* Nonzero if EXP is a constant or a cast of a constant.  */
 914
 915 int
 916 really_constant_p (exp)
 917      tree exp;
 918 {
 919   /* This is not quite the same as STRIP_NOPS.  It does more.  */
 920   while (TREE_CODE (exp) == NOP_EXPR
 921          || TREE_CODE (exp) == CONVERT_EXPR
 922          || TREE_CODE (exp) == NON_LVALUE_EXPR)
 923     exp = TREE_OPERAND (exp, 0);
 924   return TREE_CONSTANT (exp);
 925 }
 926 \f
 927 /* Return first list element whose TREE_VALUE is ELEM.
 928    Return 0 if ELEM is not in LIST.  */
 929
 930 tree
 931 value_member (elem, list)
 932      tree elem, list;
 933 {
 934   while (list)
 935     {
 936       if (elem == TREE_VALUE (list))
 937         return list;
 938       list = TREE_CHAIN (list);
 939     }
 940   return NULL_TREE;
 941 }
 942
 943 /* Return first list element whose TREE_PURPOSE is ELEM.
 944    Return 0 if ELEM is not in LIST.  */
 945
 946 tree
 947 purpose_member (elem, list)
 948      tree elem, list;
 949 {
 950   while (list)
 951     {
 952       if (elem == TREE_PURPOSE (list))
 953         return list;
 954       list = TREE_CHAIN (list);
 955     }
 956   return NULL_TREE;
 957 }
 958
 959 /* Return first list element whose BINFO_TYPE is ELEM.
 960    Return 0 if ELEM is not in LIST.  */
 961
 962 tree
 963 binfo_member (elem, list)
 964      tree elem, list;
 965 {
 966   while (list)
 967     {
 968       if (elem == BINFO_TYPE (list))
 969         return list;
 970       list = TREE_CHAIN (list);
 971     }
 972   return NULL_TREE;
 973 }
 974
 975 /* Return nonzero if ELEM is part of the chain CHAIN.  */
 976
 977 int
 978 chain_member (elem, chain)
 979      tree elem, chain;
 980 {
 981   while (chain)
 982     {
 983       if (elem == chain)
 984         return 1;
 985       chain = TREE_CHAIN (chain);
 986     }
 987
 988   return 0;
 989 }
 990
 991 /* Return the length of a chain of nodes chained through TREE_CHAIN.
 992    We expect a null pointer to mark the end of the chain.
 993    This is the Lisp primitive `length'.  */
 994
 995 int
 996 list_length (t)
 997      tree t;
 998 {
 999   tree tail;
1000   int len = 0;
1001
1002   for (tail = t; tail; tail = TREE_CHAIN (tail))
1003     len++;
1004
1005   return len;
1006 }
1007
1008 /* Returns the number of FIELD_DECLs in TYPE.  */
1009
1010 int
1011 fields_length (type)
1012      tree type;
1013 {
1014   tree t = TYPE_FIELDS (type);
1015   int count = 0;
1016
1017   for (; t; t = TREE_CHAIN (t))
1018     if (TREE_CODE (t) == FIELD_DECL)
1019       ++count;
1020
1021   return count;
1022 }
1023
1024 /* Concatenate two chains of nodes (chained through TREE_CHAIN)
1025    by modifying the last node in chain 1 to point to chain 2.
1026    This is the Lisp primitive `nconc'.  */
1027
1028 tree
1029 chainon (op1, op2)
1030      tree op1, op2;
1031 {
1032   tree t1;
1033
1034   if (!op1)
1035     return op2;
1036   if (!op2)
1037     return op1;
1038
1039   for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
1040     continue;
1041   TREE_CHAIN (t1) = op2;
1042
1043 #ifdef ENABLE_TREE_CHECKING
1044   {
1045     tree t2;
1046     for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
1047       if (t2 == t1)
1048         abort ();  /* Circularity created.  */
1049   }
1050 #endif
1051
1052   return op1;
1053 }
1054
1055 /* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
1056
1057 tree
1058 tree_last (chain)
1059      tree chain;
1060 {
1061   tree next;
1062   if (chain)
1063     while ((next = TREE_CHAIN (chain)))
1064       chain = next;
1065   return chain;
1066 }
1067
1068 /* Reverse the order of elements in the chain T,
1069    and return the new head of the chain (old last element).  */
1070
1071 tree
1072 nreverse (t)
1073      tree t;
1074 {
1075   tree prev = 0, decl, next;
1076   for (decl = t; decl; decl = next)
1077     {
1078       next = TREE_CHAIN (decl);
1079       TREE_CHAIN (decl) = prev;
1080       prev = decl;
1081     }
1082   return prev;
1083 }
1084 \f
1085 /* Return a newly created TREE_LIST node whose
1086    purpose and value fields are PARM and VALUE.  */
1087
1088 tree
1089 build_tree_list (parm, value)
1090      tree parm, value;
1091 {
1092   tree t = make_node (TREE_LIST);
1093   TREE_PURPOSE (t) = parm;
1094   TREE_VALUE (t) = value;
1095   return t;
1096 }
1097
1098 /* Return a newly created TREE_LIST node whose
1099    purpose and value fields are PURPOSE and VALUE
1100    and whose TREE_CHAIN is CHAIN.  */
1101
1102 tree
1103 tree_cons (purpose, value, chain)
1104      tree purpose, value, chain;
1105 {
1106   tree node;
1107
1108   node = ggc_alloc_tree (sizeof (struct tree_list));
1109
1110   memset (node, 0, sizeof (struct tree_common));
1111
1112 #ifdef GATHER_STATISTICS
1113   tree_node_counts[(int) x_kind]++;
1114   tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
1115 #endif
1116
1117   TREE_SET_CODE (node, TREE_LIST);
1118   TREE_CHAIN (node) = chain;
1119   TREE_PURPOSE (node) = purpose;
1120   TREE_VALUE (node) = value;
1121   return node;
1122 }
1123
1124 /* Return the first expression in a sequence of COMPOUND_EXPRs.  */
1125
1126 tree
1127 expr_first (tree expr)
1128 {
1129   if (expr == NULL_TREE)
1130     return expr;
1131   while (TREE_CODE (expr) == COMPOUND_EXPR)
1132     expr = TREE_OPERAND (expr, 0);
1133   return expr;
1134 }
1135
1136 /* Return the last expression in a sequence of COMPOUND_EXPRs.  */
1137
1138 tree
1139 expr_last (tree expr)
1140 {
1141   if (expr == NULL_TREE)
1142     return expr;
1143   while (TREE_CODE (expr) == COMPOUND_EXPR)
1144     expr = TREE_OPERAND (expr, 1);
1145   return expr;
1146 }
1147
1148 /* Return the number of subexpressions in a sequence of COMPOUND_EXPRs.  */
1149
1150 int
1151 expr_length (tree expr)
1152 {
1153   int len = 0;
1154
1155   if (expr == NULL_TREE)
1156     return 0;
1157   for (; TREE_CODE (expr) == COMPOUND_EXPR; expr = TREE_OPERAND (expr, 1))
1158     len += expr_length (TREE_OPERAND (expr, 0));
1159   ++len;
1160   return len;
1161 }
1162 \f
1163 /* Return the size nominally occupied by an object of type TYPE
1164    when it resides in memory.  The value is measured in units of bytes,
1165    and its data type is that normally used for type sizes
1166    (which is the first type created by make_signed_type or
1167    make_unsigned_type).  */
1168
1169 tree
1170 size_in_bytes (type)
1171      tree type;
1172 {
1173   tree t;
1174
1175   if (type == error_mark_node)
1176     return integer_zero_node;
1177
1178   type = TYPE_MAIN_VARIANT (type);
1179   t = TYPE_SIZE_UNIT (type);
1180
1181   if (t == 0)
1182     {
1183       (*lang_hooks.types.incomplete_type_error) (NULL_TREE, type);
1184       return size_zero_node;
1185     }
1186
1187   if (TREE_CODE (t) == INTEGER_CST)
1188     force_fit_type (t, 0);
1189
1190   return t;
1191 }
1192
1193 /* Return the size of TYPE (in bytes) as a wide integer
1194    or return -1 if the size can vary or is larger than an integer.  */
1195
1196 HOST_WIDE_INT
1197 int_size_in_bytes (type)
1198      tree type;
1199 {
1200   tree t;
1201
1202   if (type == error_mark_node)
1203     return 0;
1204
1205   type = TYPE_MAIN_VARIANT (type);
1206   t = TYPE_SIZE_UNIT (type);
1207   if (t == 0
1208       || TREE_CODE (t) != INTEGER_CST
1209       || TREE_OVERFLOW (t)
1210       || TREE_INT_CST_HIGH (t) != 0
1211       /* If the result would appear negative, it's too big to represent.  */
1212       || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
1213     return -1;
1214
1215   return TREE_INT_CST_LOW (t);
1216 }
1217 \f
1218 /* Return the bit position of FIELD, in bits from the start of the record.
1219    This is a tree of type bitsizetype.  */
1220
1221 tree
1222 bit_position (field)
1223      tree field;
1224 {
1225   return bit_from_pos (DECL_FIELD_OFFSET (field),
1226                        DECL_FIELD_BIT_OFFSET (field));
1227 }
1228
1229 /* Likewise, but return as an integer.  Abort if it cannot be represented
1230    in that way (since it could be a signed value, we don't have the option
1231    of returning -1 like int_size_in_byte can.  */
1232
1233 HOST_WIDE_INT
1234 int_bit_position (field)
1235      tree field;
1236 {
1237   return tree_low_cst (bit_position (field), 0);
1238 }
1239 \f
1240 /* Return the byte position of FIELD, in bytes from the start of the record.
1241    This is a tree of type sizetype.  */
1242
1243 tree
1244 byte_position (field)
1245      tree field;
1246 {
1247   return byte_from_pos (DECL_FIELD_OFFSET (field),
1248                         DECL_FIELD_BIT_OFFSET (field));
1249 }
1250
1251 /* Likewise, but return as an integer.  Abort if it cannot be represented
1252    in that way (since it could be a signed value, we don't have the option
1253    of returning -1 like int_size_in_byte can.  */
1254
1255 HOST_WIDE_INT
1256 int_byte_position (field)
1257      tree field;
1258 {
1259   return tree_low_cst (byte_position (field), 0);
1260 }
1261 \f
1262 /* Return the strictest alignment, in bits, that T is known to have.  */
1263
1264 unsigned int
1265 expr_align (t)
1266      tree t;
1267 {
1268   unsigned int align0, align1;
1269
1270   switch (TREE_CODE (t))
1271     {
1272     case NOP_EXPR:  case CONVERT_EXPR:  case NON_LVALUE_EXPR:
1273       /* If we have conversions, we know that the alignment of the
1274          object must meet each of the alignments of the types.  */
1275       align0 = expr_align (TREE_OPERAND (t, 0));
1276       align1 = TYPE_ALIGN (TREE_TYPE (t));
1277       return MAX (align0, align1);
1278
1279     case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
1280     case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
1281     case WITH_RECORD_EXPR:  case CLEANUP_POINT_EXPR:  case UNSAVE_EXPR:
1282       /* These don't change the alignment of an object.  */
1283       return expr_align (TREE_OPERAND (t, 0));
1284
1285     case COND_EXPR:
1286       /* The best we can do is say that the alignment is the least aligned
1287          of the two arms.  */
1288       align0 = expr_align (TREE_OPERAND (t, 1));
1289       align1 = expr_align (TREE_OPERAND (t, 2));
1290       return MIN (align0, align1);
1291
1292     case LABEL_DECL:     case CONST_DECL:
1293     case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
1294       if (DECL_ALIGN (t) != 0)
1295         return DECL_ALIGN (t);
1296       break;
1297
1298     case FUNCTION_DECL:
1299       return FUNCTION_BOUNDARY;
1300
1301     default:
1302       break;
1303     }
1304
1305   /* Otherwise take the alignment from that of the type.  */
1306   return TYPE_ALIGN (TREE_TYPE (t));
1307 }
1308 \f
1309 /* Return, as a tree node, the number of elements for TYPE (which is an
1310    ARRAY_TYPE) minus one. This counts only elements of the top array.  */
1311
1312 tree
1313 array_type_nelts (type)
1314      tree type;
1315 {
1316   tree index_type, min, max;
1317
1318   /* If they did it with unspecified bounds, then we should have already
1319      given an error about it before we got here.  */
1320   if (! TYPE_DOMAIN (type))
1321     return error_mark_node;
1322
1323   index_type = TYPE_DOMAIN (type);
1324   min = TYPE_MIN_VALUE (index_type);
1325   max = TYPE_MAX_VALUE (index_type);
1326
1327   return (integer_zerop (min)
1328           ? max
1329           : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
1330 }
1331 \f
1332 /* Return nonzero if arg is static -- a reference to an object in
1333    static storage.  This is not the same as the C meaning of `static'.  */
1334
1335 int
1336 staticp (arg)
1337      tree arg;
1338 {
1339   switch (TREE_CODE (arg))
1340     {
1341     case FUNCTION_DECL:
1342       /* Nested functions aren't static, since taking their address
1343          involves a trampoline.  */
1344       return ((decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
1345               && ! DECL_NON_ADDR_CONST_P (arg));
1346
1347     case VAR_DECL:
1348       return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
1349               && ! DECL_THREAD_LOCAL (arg)
1350               && ! DECL_NON_ADDR_CONST_P (arg));
1351
1352     case CONSTRUCTOR:
1353       return TREE_STATIC (arg);
1354
1355     case LABEL_DECL:
1356     case STRING_CST:
1357       return 1;
1358
1359       /* If we are referencing a bitfield, we can't evaluate an
1360          ADDR_EXPR at compile time and so it isn't a constant.  */
1361     case COMPONENT_REF:
1362       return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
1363               && staticp (TREE_OPERAND (arg, 0)));
1364
1365     case BIT_FIELD_REF:
1366       return 0;
1367
1368 #if 0
1369        /* This case is technically correct, but results in setting
1370           TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
1371           compile time.  */
1372     case INDIRECT_REF:
1373       return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1374 #endif
1375
1376     case ARRAY_REF:
1377     case ARRAY_RANGE_REF:
1378       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1379           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1380         return staticp (TREE_OPERAND (arg, 0));
1381
1382     default:
1383       if ((unsigned int) TREE_CODE (arg)
1384           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
1385         return (*lang_hooks.staticp) (arg);
1386       else
1387         return 0;
1388     }
1389 }
1390 \f
1391 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1392    Do this to any expression which may be used in more than one place,
1393    but must be evaluated only once.
1394
1395    Normally, expand_expr would reevaluate the expression each time.
1396    Calling save_expr produces something that is evaluated and recorded
1397    the first time expand_expr is called on it.  Subsequent calls to
1398    expand_expr just reuse the recorded value.
1399
1400    The call to expand_expr that generates code that actually computes
1401    the value is the first call *at compile time*.  Subsequent calls
1402    *at compile time* generate code to use the saved value.
1403    This produces correct result provided that *at run time* control
1404    always flows through the insns made by the first expand_expr
1405    before reaching the other places where the save_expr was evaluated.
1406    You, the caller of save_expr, must make sure this is so.
1407
1408    Constants, and certain read-only nodes, are returned with no
1409    SAVE_EXPR because that is safe.  Expressions containing placeholders
1410    are not touched; see tree.def for an explanation of what these
1411    are used for.  */
1412
1413 tree
1414 save_expr (expr)
1415      tree expr;
1416 {
1417   tree t = fold (expr);
1418   tree inner;
1419
1420   /* If the tree evaluates to a constant, then we don't want to hide that
1421      fact (i.e. this allows further folding, and direct checks for constants).
1422      However, a read-only object that has side effects cannot be bypassed.
1423      Since it is no problem to reevaluate literals, we just return the
1424      literal node.  */
1425   inner = skip_simple_arithmetic (t);
1426   if (TREE_CONSTANT (inner)
1427       || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
1428       || TREE_CODE (inner) == SAVE_EXPR
1429       || TREE_CODE (inner) == ERROR_MARK)
1430     return t;
1431
1432   /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1433      it means that the size or offset of some field of an object depends on
1434      the value within another field.
1435
1436      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1437      and some variable since it would then need to be both evaluated once and
1438      evaluated more than once.  Front-ends must assure this case cannot
1439      happen by surrounding any such subexpressions in their own SAVE_EXPR
1440      and forcing evaluation at the proper time.  */
1441   if (contains_placeholder_p (inner))
1442     return t;
1443
1444   t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
1445
1446   /* This expression might be placed ahead of a jump to ensure that the
1447      value was computed on both sides of the jump.  So make sure it isn't
1448      eliminated as dead.  */
1449   TREE_SIDE_EFFECTS (t) = 1;
1450   TREE_READONLY (t) = 1;
1451   return t;
1452 }
1453
1454 /* Look inside EXPR and into any simple arithmetic operations.  Return
1455    the innermost non-arithmetic node.  */
1456
1457 tree
1458 skip_simple_arithmetic (expr)
1459      tree expr;
1460 {
1461   tree inner;
1462
1463   /* We don't care about whether this can be used as an lvalue in this
1464      context.  */
1465   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
1466     expr = TREE_OPERAND (expr, 0);
1467
1468   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
1469      a constant, it will be more efficient to not make another SAVE_EXPR since
1470      it will allow better simplification and GCSE will be able to merge the
1471      computations if they actually occur.  */
1472   inner = expr;
1473   while (1)
1474     {
1475       if (TREE_CODE_CLASS (TREE_CODE (inner)) == '1')
1476         inner = TREE_OPERAND (inner, 0);
1477       else if (TREE_CODE_CLASS (TREE_CODE (inner)) == '2')
1478         {
1479           if (TREE_CONSTANT (TREE_OPERAND (inner, 1)))
1480             inner = TREE_OPERAND (inner, 0);
1481           else if (TREE_CONSTANT (TREE_OPERAND (inner, 0)))
1482             inner = TREE_OPERAND (inner, 1);
1483           else
1484             break;
1485         }
1486       else
1487         break;
1488     }
1489
1490   return inner;
1491 }
1492
1493 /* Return TRUE if EXPR is a SAVE_EXPR or wraps simple arithmetic around a
1494    SAVE_EXPR.  Return FALSE otherwise.  */
1495
1496 bool
1497 saved_expr_p (expr)
1498      tree expr;
1499 {
1500   return TREE_CODE (skip_simple_arithmetic (expr)) == SAVE_EXPR;
1501 }
1502
1503 /* Arrange for an expression to be expanded multiple independent
1504    times.  This is useful for cleanup actions, as the backend can
1505    expand them multiple times in different places.  */
1506
1507 tree
1508 unsave_expr (expr)
1509      tree expr;
1510 {
1511   tree t;
1512
1513   /* If this is already protected, no sense in protecting it again.  */
1514   if (TREE_CODE (expr) == UNSAVE_EXPR)
1515     return expr;
1516
1517   t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1518   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1519   return t;
1520 }
1521
1522 /* Returns the index of the first non-tree operand for CODE, or the number
1523    of operands if all are trees.  */
1524
1525 int
1526 first_rtl_op (code)
1527      enum tree_code code;
1528 {
1529   switch (code)
1530     {
1531     case SAVE_EXPR:
1532       return 2;
1533     case GOTO_SUBROUTINE_EXPR:
1534     case RTL_EXPR:
1535       return 0;
1536     case WITH_CLEANUP_EXPR:
1537       return 2;
1538     case METHOD_CALL_EXPR:
1539       return 3;
1540     default:
1541       return TREE_CODE_LENGTH (code);
1542     }
1543 }
1544
1545 /* Return which tree structure is used by T.  */
1546
1547 enum tree_node_structure_enum
1548 tree_node_structure (t)
1549      tree t;
1550 {
1551   enum tree_code code = TREE_CODE (t);
1552
1553   switch (TREE_CODE_CLASS (code))
1554     {
1555     case 'd':   return TS_DECL;
1556     case 't':   return TS_TYPE;
1557     case 'b':   return TS_BLOCK;
1558     case 'r': case '<': case '1': case '2': case 'e': case 's':
1559       return TS_EXP;
1560     default:  /* 'c' and 'x' */
1561       break;
1562     }
1563   switch (code)
1564     {
1565       /* 'c' cases.  */
1566     case INTEGER_CST:           return TS_INT_CST;
1567     case REAL_CST:              return TS_REAL_CST;
1568     case COMPLEX_CST:           return TS_COMPLEX;
1569     case VECTOR_CST:            return TS_VECTOR;
1570     case STRING_CST:            return TS_STRING;
1571       /* 'x' cases.  */
1572     case ERROR_MARK:            return TS_COMMON;
1573     case IDENTIFIER_NODE:       return TS_IDENTIFIER;
1574     case TREE_LIST:             return TS_LIST;
1575     case TREE_VEC:              return TS_VEC;
1576     case PLACEHOLDER_EXPR:      return TS_COMMON;
1577
1578     default:
1579       abort ();
1580     }
1581 }
1582
1583 /* Perform any modifications to EXPR required when it is unsaved.  Does
1584    not recurse into EXPR's subtrees.  */
1585
1586 void
1587 unsave_expr_1 (expr)
1588      tree expr;
1589 {
1590   switch (TREE_CODE (expr))
1591     {
1592     case SAVE_EXPR:
1593       if (! SAVE_EXPR_PERSISTENT_P (expr))
1594         SAVE_EXPR_RTL (expr) = 0;
1595       break;
1596
1597     case TARGET_EXPR:
1598       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
1599          It's OK for this to happen if it was part of a subtree that
1600          isn't immediately expanded, such as operand 2 of another
1601          TARGET_EXPR.  */
1602       if (TREE_OPERAND (expr, 1))
1603         break;
1604
1605       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
1606       TREE_OPERAND (expr, 3) = NULL_TREE;
1607       break;
1608
1609     case RTL_EXPR:
1610       /* I don't yet know how to emit a sequence multiple times.  */
1611       if (RTL_EXPR_SEQUENCE (expr) != 0)
1612         abort ();
1613       break;
1614
1615     default:
1616       break;
1617     }
1618 }
1619
1620 /* Default lang hook for "unsave_expr_now".  */
1621
1622 tree
1623 lhd_unsave_expr_now (expr)
1624      tree expr;
1625 {
1626   enum tree_code code;
1627
1628   /* There's nothing to do for NULL_TREE.  */
1629   if (expr == 0)
1630     return expr;
1631
1632   unsave_expr_1 (expr);
1633
1634   code = TREE_CODE (expr);
1635   switch (TREE_CODE_CLASS (code))
1636     {
1637     case 'c':  /* a constant */
1638     case 't':  /* a type node */
1639     case 'd':  /* A decl node */
1640     case 'b':  /* A block node */
1641       break;
1642
1643     case 'x':  /* miscellaneous: e.g., identifier, TREE_LIST or ERROR_MARK.  */
1644       if (code == TREE_LIST)
1645         {
1646           lhd_unsave_expr_now (TREE_VALUE (expr));
1647           lhd_unsave_expr_now (TREE_CHAIN (expr));
1648         }
1649       break;
1650
1651     case 'e':  /* an expression */
1652     case 'r':  /* a reference */
1653     case 's':  /* an expression with side effects */
1654     case '<':  /* a comparison expression */
1655     case '2':  /* a binary arithmetic expression */
1656     case '1':  /* a unary arithmetic expression */
1657       {
1658         int i;
1659
1660         for (i = first_rtl_op (code) - 1; i >= 0; i--)
1661           lhd_unsave_expr_now (TREE_OPERAND (expr, i));
1662       }
1663       break;
1664
1665     default:
1666       abort ();
1667     }
1668
1669   return expr;
1670 }
1671
1672 /* Return 0 if it is safe to evaluate EXPR multiple times,
1673    return 1 if it is safe if EXPR is unsaved afterward, or
1674    return 2 if it is completely unsafe.
1675
1676    This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
1677    an expression tree, so that it safe to unsave them and the surrounding
1678    context will be correct.
1679
1680    SAVE_EXPRs basically *only* appear replicated in an expression tree,
1681    occasionally across the whole of a function.  It is therefore only
1682    safe to unsave a SAVE_EXPR if you know that all occurrences appear
1683    below the UNSAVE_EXPR.
1684
1685    RTL_EXPRs consume their rtl during evaluation.  It is therefore
1686    never possible to unsave them.  */
1687
1688 int
1689 unsafe_for_reeval (expr)
1690      tree expr;
1691 {
1692   int unsafeness = 0;
1693   enum tree_code code;
1694   int i, tmp, tmp2;
1695   tree exp;
1696   int first_rtl;
1697
1698   if (expr == NULL_TREE)
1699     return 1;
1700
1701   code = TREE_CODE (expr);
1702   first_rtl = first_rtl_op (code);
1703
1704   switch (code)
1705     {
1706     case SAVE_EXPR:
1707     case RTL_EXPR:
1708       return 2;
1709
1710     case TREE_LIST:
1711       for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
1712         {
1713           tmp = unsafe_for_reeval (TREE_VALUE (exp));
1714           unsafeness = MAX (tmp, unsafeness);
1715         }
1716
1717       return unsafeness;
1718
1719     case CALL_EXPR:
1720       tmp2 = unsafe_for_reeval (TREE_OPERAND (expr, 0));
1721       tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
1722       return MAX (MAX (tmp, 1), tmp2);
1723
1724     case TARGET_EXPR:
1725       unsafeness = 1;
1726       break;
1727
1728     default:
1729       tmp = (*lang_hooks.unsafe_for_reeval) (expr);
1730       if (tmp >= 0)
1731         return tmp;
1732       break;
1733     }
1734
1735   switch (TREE_CODE_CLASS (code))
1736     {
1737     case 'c':  /* a constant */
1738     case 't':  /* a type node */
1739     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
1740     case 'd':  /* A decl node */
1741     case 'b':  /* A block node */
1742       return 0;
1743
1744     case 'e':  /* an expression */
1745     case 'r':  /* a reference */
1746     case 's':  /* an expression with side effects */
1747     case '<':  /* a comparison expression */
1748     case '2':  /* a binary arithmetic expression */
1749     case '1':  /* a unary arithmetic expression */
1750       for (i = first_rtl - 1; i >= 0; i--)
1751         {
1752           tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
1753           unsafeness = MAX (tmp, unsafeness);
1754         }
1755
1756       return unsafeness;
1757
1758     default:
1759       return 2;
1760     }
1761 }
1762 \f
1763 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
1764    or offset that depends on a field within a record.  */
1765
1766 bool
1767 contains_placeholder_p (exp)
1768      tree exp;
1769 {
1770   enum tree_code code;
1771   int result;
1772
1773   if (!exp)
1774     return 0;
1775
1776   /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
1777      in it since it is supplying a value for it.  */
1778   code = TREE_CODE (exp);
1779   if (code == WITH_RECORD_EXPR)
1780     return 0;
1781   else if (code == PLACEHOLDER_EXPR)
1782     return 1;
1783
1784   switch (TREE_CODE_CLASS (code))
1785     {
1786     case 'r':
1787       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
1788          position computations since they will be converted into a
1789          WITH_RECORD_EXPR involving the reference, which will assume
1790          here will be valid.  */
1791       return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
1792
1793     case 'x':
1794       if (code == TREE_LIST)
1795         return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
1796                 || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
1797       break;
1798
1799     case '1':
1800     case '2':  case '<':
1801     case 'e':
1802       switch (code)
1803         {
1804         case COMPOUND_EXPR:
1805           /* Ignoring the first operand isn't quite right, but works best.  */
1806           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
1807
1808         case RTL_EXPR:
1809         case CONSTRUCTOR:
1810           return 0;
1811
1812         case COND_EXPR:
1813           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
1814                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
1815                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
1816
1817         case SAVE_EXPR:
1818           /* If we already know this doesn't have a placeholder, don't
1819              check again.  */
1820           if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
1821             return 0;
1822
1823           SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
1824           result = CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
1825           if (result)
1826             SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
1827
1828           return result;
1829
1830         case CALL_EXPR:
1831           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
1832
1833         default:
1834           break;
1835         }
1836
1837       switch (TREE_CODE_LENGTH (code))
1838         {
1839         case 1:
1840           return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
1841         case 2:
1842           return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
1843                   || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
1844         default:
1845           return 0;
1846         }
1847
1848     default:
1849       return 0;
1850     }
1851   return 0;
1852 }
1853
1854 /* Return 1 if any part of the computation of TYPE involves a PLACEHOLDER_EXPR.
1855    This includes size, bounds, qualifiers (for QUAL_UNION_TYPE) and field
1856    positions.  */
1857
1858 bool
1859 type_contains_placeholder_p (type)
1860      tree type;
1861 {
1862   /* If the size contains a placeholder or the parent type (component type in
1863      the case of arrays) type involves a placeholder, this type does.  */
1864   if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
1865       || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
1866       || (TREE_TYPE (type) != 0
1867           && type_contains_placeholder_p (TREE_TYPE (type))))
1868     return 1;
1869
1870   /* Now do type-specific checks.  Note that the last part of the check above
1871      greatly limits what we have to do below.  */
1872   switch (TREE_CODE (type))
1873     {
1874     case VOID_TYPE:
1875     case COMPLEX_TYPE:
1876     case VECTOR_TYPE:
1877     case ENUMERAL_TYPE:
1878     case BOOLEAN_TYPE:
1879     case CHAR_TYPE:
1880     case POINTER_TYPE:
1881     case OFFSET_TYPE:
1882     case REFERENCE_TYPE:
1883     case METHOD_TYPE:
1884     case FILE_TYPE:
1885     case FUNCTION_TYPE:
1886       return 0;
1887
1888     case INTEGER_TYPE:
1889     case REAL_TYPE:
1890       /* Here we just check the bounds.  */
1891       return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
1892               || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
1893
1894     case ARRAY_TYPE:
1895     case SET_TYPE:
1896       /* We're already checked the component type (TREE_TYPE), so just check
1897          the index type.  */
1898       return type_contains_placeholder_p (TYPE_DOMAIN (type));
1899
1900     case RECORD_TYPE:
1901     case UNION_TYPE:
1902     case QUAL_UNION_TYPE:
1903       {
1904         static tree seen_types = 0;
1905         tree field;
1906         bool ret = 0;
1907
1908         /* We have to be careful here that we don't end up in infinite
1909            recursions due to a field of a type being a pointer to that type
1910            or to a mutually-recursive type.  So we store a list of record
1911            types that we've seen and see if this type is in them.  To save
1912            memory, we don't use a list for just one type.  Here we check
1913            whether we've seen this type before and store it if not.  */
1914         if (seen_types == 0)
1915           seen_types = type;
1916         else if (TREE_CODE (seen_types) != TREE_LIST)
1917           {
1918             if (seen_types == type)
1919               return 0;
1920
1921             seen_types = tree_cons (NULL_TREE, type,
1922                                     build_tree_list (NULL_TREE, seen_types));
1923           }
1924         else
1925           {
1926             if (value_member (type, seen_types) != 0)
1927               return 0;
1928
1929             seen_types = tree_cons (NULL_TREE, type, seen_types);
1930           }
1931
1932         for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1933           if (TREE_CODE (field) == FIELD_DECL
1934               && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
1935                   || (TREE_CODE (type) == QUAL_UNION_TYPE
1936                       && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
1937                   || type_contains_placeholder_p (TREE_TYPE (field))))
1938             {
1939               ret = true;
1940               break;
1941             }
1942
1943         /* Now remove us from seen_types and return the result.  */
1944         if (seen_types == type)
1945           seen_types = 0;
1946         else
1947           seen_types = TREE_CHAIN (seen_types);
1948
1949         return ret;
1950       }
1951
1952     default:
1953       abort ();
1954     }
1955 }
1956
1957 /* Return 1 if EXP contains any expressions that produce cleanups for an
1958    outer scope to deal with.  Used by fold.  */
1959
1960 int
1961 has_cleanups (exp)
1962      tree exp;
1963 {
1964   int i, nops, cmp;
1965
1966   if (! TREE_SIDE_EFFECTS (exp))
1967     return 0;
1968
1969   switch (TREE_CODE (exp))
1970     {
1971     case TARGET_EXPR:
1972     case GOTO_SUBROUTINE_EXPR:
1973     case WITH_CLEANUP_EXPR:
1974       return 1;
1975
1976     case CLEANUP_POINT_EXPR:
1977       return 0;
1978
1979     case CALL_EXPR:
1980       for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
1981         {
1982           cmp = has_cleanups (TREE_VALUE (exp));
1983           if (cmp)
1984             return cmp;
1985         }
1986       return 0;
1987
1988     default:
1989       break;
1990     }
1991
1992   /* This general rule works for most tree codes.  All exceptions should be
1993      handled above.  If this is a language-specific tree code, we can't
1994      trust what might be in the operand, so say we don't know
1995      the situation.  */
1996   if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
1997     return -1;
1998
1999   nops = first_rtl_op (TREE_CODE (exp));
2000   for (i = 0; i < nops; i++)
2001     if (TREE_OPERAND (exp, i) != 0)
2002       {
2003         int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
2004         if (type == 'e' || type == '<' || type == '1' || type == '2'
2005             || type == 'r' || type == 's')
2006           {
2007             cmp = has_cleanups (TREE_OPERAND (exp, i));
2008             if (cmp)
2009               return cmp;
2010           }
2011       }
2012
2013   return 0;
2014 }
2015 \f
2016 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2017    return a tree with all occurrences of references to F in a
2018    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
2019    contains only arithmetic expressions or a CALL_EXPR with a
2020    PLACEHOLDER_EXPR occurring only in its arglist.  */
2021
2022 tree
2023 substitute_in_expr (exp, f, r)
2024      tree exp;
2025      tree f;
2026      tree r;
2027 {
2028   enum tree_code code = TREE_CODE (exp);
2029   tree op0, op1, op2;
2030   tree new;
2031   tree inner;
2032
2033   switch (TREE_CODE_CLASS (code))
2034     {
2035     case 'c':
2036     case 'd':
2037       return exp;
2038
2039     case 'x':
2040       if (code == PLACEHOLDER_EXPR)
2041         return exp;
2042       else if (code == TREE_LIST)
2043         {
2044           op0 = (TREE_CHAIN (exp) == 0
2045                  ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
2046           op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
2047           if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2048             return exp;
2049
2050           return tree_cons (TREE_PURPOSE (exp), op1, op0);
2051         }
2052
2053       abort ();
2054
2055     case '1':
2056     case '2':
2057     case '<':
2058     case 'e':
2059       switch (TREE_CODE_LENGTH (code))
2060         {
2061         case 1:
2062           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2063           if (op0 == TREE_OPERAND (exp, 0))
2064             return exp;
2065
2066           if (code == NON_LVALUE_EXPR)
2067             return op0;
2068
2069           new = fold (build1 (code, TREE_TYPE (exp), op0));
2070           break;
2071
2072         case 2:
2073           /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
2074              could, but we don't support it.  */
2075           if (code == RTL_EXPR)
2076             return exp;
2077           else if (code == CONSTRUCTOR)
2078             abort ();
2079
2080           op0 = TREE_OPERAND (exp, 0);
2081           op1 = TREE_OPERAND (exp, 1);
2082           if (CONTAINS_PLACEHOLDER_P (op0))
2083             op0 = substitute_in_expr (op0, f, r);
2084           if (CONTAINS_PLACEHOLDER_P (op1))
2085             op1 = substitute_in_expr (op1, f, r);
2086
2087           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
2088             return exp;
2089
2090           new = fold (build (code, TREE_TYPE (exp), op0, op1));
2091           break;
2092
2093         case 3:
2094           /* It cannot be that anything inside a SAVE_EXPR contains a
2095              PLACEHOLDER_EXPR.  */
2096           if (code == SAVE_EXPR)
2097             return exp;
2098
2099           else if (code == CALL_EXPR)
2100             {
2101               op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2102               if (op1 == TREE_OPERAND (exp, 1))
2103                 return exp;
2104
2105               return build (code, TREE_TYPE (exp),
2106                             TREE_OPERAND (exp, 0), op1, NULL_TREE);
2107             }
2108
2109           else if (code != COND_EXPR)
2110             abort ();
2111
2112           op0 = TREE_OPERAND (exp, 0);
2113           op1 = TREE_OPERAND (exp, 1);
2114           op2 = TREE_OPERAND (exp, 2);
2115
2116           if (CONTAINS_PLACEHOLDER_P (op0))
2117             op0 = substitute_in_expr (op0, f, r);
2118           if (CONTAINS_PLACEHOLDER_P (op1))
2119             op1 = substitute_in_expr (op1, f, r);
2120           if (CONTAINS_PLACEHOLDER_P (op2))
2121             op2 = substitute_in_expr (op2, f, r);
2122
2123           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2124               && op2 == TREE_OPERAND (exp, 2))
2125             return exp;
2126
2127           new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2128           break;
2129
2130         default:
2131           abort ();
2132         }
2133
2134       break;
2135
2136     case 'r':
2137       switch (code)
2138         {
2139         case COMPONENT_REF:
2140           /* If this expression is getting a value from a PLACEHOLDER_EXPR
2141              and it is the right field, replace it with R.  */
2142           for (inner = TREE_OPERAND (exp, 0);
2143                TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
2144                inner = TREE_OPERAND (inner, 0))
2145             ;
2146           if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2147               && TREE_OPERAND (exp, 1) == f)
2148             return r;
2149
2150           /* If this expression hasn't been completed let, leave it
2151              alone.  */
2152           if (TREE_CODE (inner) == PLACEHOLDER_EXPR
2153               && TREE_TYPE (inner) == 0)
2154             return exp;
2155
2156           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2157           if (op0 == TREE_OPERAND (exp, 0))
2158             return exp;
2159
2160           new = fold (build (code, TREE_TYPE (exp), op0,
2161                              TREE_OPERAND (exp, 1)));
2162           break;
2163
2164         case BIT_FIELD_REF:
2165           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2166           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
2167           op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
2168           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
2169               && op2 == TREE_OPERAND (exp, 2))
2170             return exp;
2171
2172           new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
2173           break;
2174
2175         case INDIRECT_REF:
2176         case BUFFER_REF:
2177           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
2178           if (op0 == TREE_OPERAND (exp, 0))
2179             return exp;
2180
2181           new = fold (build1 (code, TREE_TYPE (exp), op0));
2182           break;
2183
2184         default:
2185           abort ();
2186         }
2187       break;
2188
2189     default:
2190       abort ();
2191     }
2192
2193   TREE_READONLY (new) = TREE_READONLY (exp);
2194   return new;
2195 }
2196 \f
2197 /* Stabilize a reference so that we can use it any number of times
2198    without causing its operands to be evaluated more than once.
2199    Returns the stabilized reference.  This works by means of save_expr,
2200    so see the caveats in the comments about save_expr.
2201
2202    Also allows conversion expressions whose operands are references.
2203    Any other kind of expression is returned unchanged.  */
2204
2205 tree
2206 stabilize_reference (ref)
2207      tree ref;
2208 {
2209   tree result;
2210   enum tree_code code = TREE_CODE (ref);
2211
2212   switch (code)
2213     {
2214     case VAR_DECL:
2215     case PARM_DECL:
2216     case RESULT_DECL:
2217       /* No action is needed in this case.  */
2218       return ref;
2219
2220     case NOP_EXPR:
2221     case CONVERT_EXPR:
2222     case FLOAT_EXPR:
2223     case FIX_TRUNC_EXPR:
2224     case FIX_FLOOR_EXPR:
2225     case FIX_ROUND_EXPR:
2226     case FIX_CEIL_EXPR:
2227       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2228       break;
2229
2230     case INDIRECT_REF:
2231       result = build_nt (INDIRECT_REF,
2232                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2233       break;
2234
2235     case COMPONENT_REF:
2236       result = build_nt (COMPONENT_REF,
2237                          stabilize_reference (TREE_OPERAND (ref, 0)),
2238                          TREE_OPERAND (ref, 1));
2239       break;
2240
2241     case BIT_FIELD_REF:
2242       result = build_nt (BIT_FIELD_REF,
2243                          stabilize_reference (TREE_OPERAND (ref, 0)),
2244                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2245                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2246       break;
2247
2248     case ARRAY_REF:
2249       result = build_nt (ARRAY_REF,
2250                          stabilize_reference (TREE_OPERAND (ref, 0)),
2251                          stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2252       break;
2253
2254     case ARRAY_RANGE_REF:
2255       result = build_nt (ARRAY_RANGE_REF,
2256                          stabilize_reference (TREE_OPERAND (ref, 0)),
2257                          stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2258       break;
2259
2260     case COMPOUND_EXPR:
2261       /* We cannot wrap the first expression in a SAVE_EXPR, as then
2262          it wouldn't be ignored.  This matters when dealing with
2263          volatiles.  */
2264       return stabilize_reference_1 (ref);
2265
2266     case RTL_EXPR:
2267       result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2268                        save_expr (build1 (ADDR_EXPR,
2269                                           build_pointer_type (TREE_TYPE (ref)),
2270                                           ref)));
2271       break;
2272
2273       /* If arg isn't a kind of lvalue we recognize, make no change.
2274          Caller should recognize the error for an invalid lvalue.  */
2275     default:
2276       return ref;
2277
2278     case ERROR_MARK:
2279       return error_mark_node;
2280     }
2281
2282   TREE_TYPE (result) = TREE_TYPE (ref);
2283   TREE_READONLY (result) = TREE_READONLY (ref);
2284   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2285   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2286
2287   return result;
2288 }
2289
2290 /* Subroutine of stabilize_reference; this is called for subtrees of
2291    references.  Any expression with side-effects must be put in a SAVE_EXPR
2292    to ensure that it is only evaluated once.
2293
2294    We don't put SAVE_EXPR nodes around everything, because assigning very
2295    simple expressions to temporaries causes us to miss good opportunities
2296    for optimizations.  Among other things, the opportunity to fold in the
2297    addition of a constant into an addressing mode often gets lost, e.g.
2298    "y[i+1] += x;".  In general, we take the approach that we should not make
2299    an assignment unless we are forced into it - i.e., that any non-side effect
2300    operator should be allowed, and that cse should take care of coalescing
2301    multiple utterances of the same expression should that prove fruitful.  */
2302
2303 tree
2304 stabilize_reference_1 (e)
2305      tree e;
2306 {
2307   tree result;
2308   enum tree_code code = TREE_CODE (e);
2309
2310   /* We cannot ignore const expressions because it might be a reference
2311      to a const array but whose index contains side-effects.  But we can
2312      ignore things that are actual constant or that already have been
2313      handled by this function.  */
2314
2315   if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2316     return e;
2317
2318   switch (TREE_CODE_CLASS (code))
2319     {
2320     case 'x':
2321     case 't':
2322     case 'd':
2323     case 'b':
2324     case '<':
2325     case 's':
2326     case 'e':
2327     case 'r':
2328       /* If the expression has side-effects, then encase it in a SAVE_EXPR
2329          so that it will only be evaluated once.  */
2330       /* The reference (r) and comparison (<) classes could be handled as
2331          below, but it is generally faster to only evaluate them once.  */
2332       if (TREE_SIDE_EFFECTS (e))
2333         return save_expr (e);
2334       return e;
2335
2336     case 'c':
2337       /* Constants need no processing.  In fact, we should never reach
2338          here.  */
2339       return e;
2340
2341     case '2':
2342       /* Division is slow and tends to be compiled with jumps,
2343          especially the division by powers of 2 that is often
2344          found inside of an array reference.  So do it just once.  */
2345       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2346           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2347           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2348           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2349         return save_expr (e);
2350       /* Recursively stabilize each operand.  */
2351       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2352                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
2353       break;
2354
2355     case '1':
2356       /* Recursively stabilize each operand.  */
2357       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2358       break;
2359
2360     default:
2361       abort ();
2362     }
2363
2364   TREE_TYPE (result) = TREE_TYPE (e);
2365   TREE_READONLY (result) = TREE_READONLY (e);
2366   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2367   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2368
2369   return result;
2370 }
2371 \f
2372 /* Low-level constructors for expressions.  */
2373
2374 /* Build an expression of code CODE, data type TYPE,
2375    and operands as specified by the arguments ARG1 and following arguments.
2376    Expressions and reference nodes can be created this way.
2377    Constants, decls, types and misc nodes cannot be.  */
2378
2379 tree
2380 build (enum tree_code code, tree tt, ...)
2381 {
2382   tree t;
2383   int length;
2384   int i;
2385   int fro;
2386   int constant;
2387   va_list p;
2388
2389   va_start (p, tt);
2390
2391   t = make_node (code);
2392   length = TREE_CODE_LENGTH (code);
2393   TREE_TYPE (t) = tt;
2394
2395   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2396      result based on those same flags for the arguments.  But if the
2397      arguments aren't really even `tree' expressions, we shouldn't be trying
2398      to do this.  */
2399   fro = first_rtl_op (code);
2400
2401   /* Expressions without side effects may be constant if their
2402      arguments are as well.  */
2403   constant = (TREE_CODE_CLASS (code) == '<'
2404               || TREE_CODE_CLASS (code) == '1'
2405               || TREE_CODE_CLASS (code) == '2'
2406               || TREE_CODE_CLASS (code) == 'c');
2407
2408   if (length == 2)
2409     {
2410       /* This is equivalent to the loop below, but faster.  */
2411       tree arg0 = va_arg (p, tree);
2412       tree arg1 = va_arg (p, tree);
2413
2414       TREE_OPERAND (t, 0) = arg0;
2415       TREE_OPERAND (t, 1) = arg1;
2416       TREE_READONLY (t) = 1;
2417       if (arg0 && fro > 0)
2418         {
2419           if (TREE_SIDE_EFFECTS (arg0))
2420             TREE_SIDE_EFFECTS (t) = 1;
2421           if (!TREE_READONLY (arg0))
2422             TREE_READONLY (t) = 0;
2423           if (!TREE_CONSTANT (arg0))
2424             constant = 0;
2425         }
2426
2427       if (arg1 && fro > 1)
2428         {
2429           if (TREE_SIDE_EFFECTS (arg1))
2430             TREE_SIDE_EFFECTS (t) = 1;
2431           if (!TREE_READONLY (arg1))
2432             TREE_READONLY (t) = 0;
2433           if (!TREE_CONSTANT (arg1))
2434             constant = 0;
2435         }
2436     }
2437   else if (length == 1)
2438     {
2439       tree arg0 = va_arg (p, tree);
2440
2441       /* The only one-operand cases we handle here are those with side-effects.
2442          Others are handled with build1.  So don't bother checked if the
2443          arg has side-effects since we'll already have set it.
2444
2445          ??? This really should use build1 too.  */
2446       if (TREE_CODE_CLASS (code) != 's')
2447         abort ();
2448       TREE_OPERAND (t, 0) = arg0;
2449     }
2450   else
2451     {
2452       for (i = 0; i < length; i++)
2453         {
2454           tree operand = va_arg (p, tree);
2455
2456           TREE_OPERAND (t, i) = operand;
2457           if (operand && fro > i)
2458             {
2459               if (TREE_SIDE_EFFECTS (operand))
2460                 TREE_SIDE_EFFECTS (t) = 1;
2461               if (!TREE_CONSTANT (operand))
2462                 constant = 0;
2463             }
2464         }
2465     }
2466   va_end (p);
2467
2468   TREE_CONSTANT (t) = constant;
2469   return t;
2470 }
2471
2472 /* Same as above, but only builds for unary operators.
2473    Saves lions share of calls to `build'; cuts down use
2474    of varargs, which is expensive for RISC machines.  */
2475
2476 tree
2477 build1 (code, type, node)
2478      enum tree_code code;
2479      tree type;
2480      tree node;
2481 {
2482   int length = sizeof (struct tree_exp);
2483 #ifdef GATHER_STATISTICS
2484   tree_node_kind kind;
2485 #endif
2486   tree t;
2487
2488 #ifdef GATHER_STATISTICS
2489   switch (TREE_CODE_CLASS (code))
2490     {
2491     case 's':  /* an expression with side effects */
2492       kind = s_kind;
2493       break;
2494     case 'r':  /* a reference */
2495       kind = r_kind;
2496       break;
2497     default:
2498       kind = e_kind;
2499       break;
2500     }
2501
2502   tree_node_counts[(int) kind]++;
2503   tree_node_sizes[(int) kind] += length;
2504 #endif
2505
2506 #ifdef ENABLE_CHECKING
2507   if (TREE_CODE_CLASS (code) == '2'
2508       || TREE_CODE_CLASS (code) == '<'
2509       || TREE_CODE_LENGTH (code) != 1)
2510     abort ();
2511 #endif /* ENABLE_CHECKING */
2512
2513   t = ggc_alloc_tree (length);
2514
2515   memset (t, 0, sizeof (struct tree_common));
2516
2517   TREE_SET_CODE (t, code);
2518
2519   TREE_TYPE (t) = type;
2520   TREE_COMPLEXITY (t) = 0;
2521   TREE_OPERAND (t, 0) = node;
2522   if (node && first_rtl_op (code) != 0)
2523     {
2524       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2525       TREE_READONLY (t) = TREE_READONLY (node);
2526     }
2527
2528   if (TREE_CODE_CLASS (code) == 's')
2529     TREE_SIDE_EFFECTS (t) = 1;
2530   else switch (code)
2531     {
2532     case INIT_EXPR:
2533     case MODIFY_EXPR:
2534     case VA_ARG_EXPR:
2535     case RTL_EXPR:
2536     case PREDECREMENT_EXPR:
2537     case PREINCREMENT_EXPR:
2538     case POSTDECREMENT_EXPR:
2539     case POSTINCREMENT_EXPR:
2540       /* All of these have side-effects, no matter what their
2541          operands are.  */
2542       TREE_SIDE_EFFECTS (t) = 1;
2543       TREE_READONLY (t) = 0;
2544       break;
2545
2546     case INDIRECT_REF:
2547       /* Whether a dereference is readonly has nothing to do with whether
2548          its operand is readonly.  */
2549       TREE_READONLY (t) = 0;
2550       break;
2551
2552     default:
2553       if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
2554         TREE_CONSTANT (t) = 1;
2555       break;
2556     }
2557
2558   return t;
2559 }
2560
2561 /* Similar except don't specify the TREE_TYPE
2562    and leave the TREE_SIDE_EFFECTS as 0.
2563    It is permissible for arguments to be null,
2564    or even garbage if their values do not matter.  */
2565
2566 tree
2567 build_nt (enum tree_code code, ...)
2568 {
2569   tree t;
2570   int length;
2571   int i;
2572   va_list p;
2573
2574   va_start (p, code);
2575
2576   t = make_node (code);
2577   length = TREE_CODE_LENGTH (code);
2578
2579   for (i = 0; i < length; i++)
2580     TREE_OPERAND (t, i) = va_arg (p, tree);
2581
2582   va_end (p);
2583   return t;
2584 }
2585 \f
2586 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2587    We do NOT enter this node in any sort of symbol table.
2588
2589    layout_decl is used to set up the decl's storage layout.
2590    Other slots are initialized to 0 or null pointers.  */
2591
2592 tree
2593 build_decl (code, name, type)
2594      enum tree_code code;
2595      tree name, type;
2596 {
2597   tree t;
2598
2599   t = make_node (code);
2600
2601 /*  if (type == error_mark_node)
2602     type = integer_type_node; */
2603 /* That is not done, deliberately, so that having error_mark_node
2604    as the type can suppress useless errors in the use of this variable.  */
2605
2606   DECL_NAME (t) = name;
2607   TREE_TYPE (t) = type;
2608
2609   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2610     layout_decl (t, 0);
2611   else if (code == FUNCTION_DECL)
2612     DECL_MODE (t) = FUNCTION_MODE;
2613
2614   return t;
2615 }
2616 \f
2617 /* BLOCK nodes are used to represent the structure of binding contours
2618    and declarations, once those contours have been exited and their contents
2619    compiled.  This information is used for outputting debugging info.  */
2620
2621 tree
2622 build_block (vars, tags, subblocks, supercontext, chain)
2623      tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
2624 {
2625   tree block = make_node (BLOCK);
2626
2627   BLOCK_VARS (block) = vars;
2628   BLOCK_SUBBLOCKS (block) = subblocks;
2629   BLOCK_SUPERCONTEXT (block) = supercontext;
2630   BLOCK_CHAIN (block) = chain;
2631   return block;
2632 }
2633
2634 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
2635    location where an expression or an identifier were encountered. It
2636    is necessary for languages where the frontend parser will handle
2637    recursively more than one file (Java is one of them).  */
2638
2639 tree
2640 build_expr_wfl (node, file, line, col)
2641      tree node;
2642      const char *file;
2643      int line, col;
2644 {
2645   static const char *last_file = 0;
2646   static tree last_filenode = NULL_TREE;
2647   tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
2648
2649   EXPR_WFL_NODE (wfl) = node;
2650   EXPR_WFL_SET_LINECOL (wfl, line, col);
2651   if (file != last_file)
2652     {
2653       last_file = file;
2654       last_filenode = file ? get_identifier (file) : NULL_TREE;
2655     }
2656
2657   EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
2658   if (node)
2659     {
2660       TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
2661       TREE_TYPE (wfl) = TREE_TYPE (node);
2662     }
2663
2664   return wfl;
2665 }
2666 \f
2667 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
2668    is ATTRIBUTE.  */
2669
2670 tree
2671 build_decl_attribute_variant (ddecl, attribute)
2672      tree ddecl, attribute;
2673 {
2674   DECL_ATTRIBUTES (ddecl) = attribute;
2675   return ddecl;
2676 }
2677
2678 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
2679    is ATTRIBUTE.
2680
2681    Record such modified types already made so we don't make duplicates.  */
2682
2683 tree
2684 build_type_attribute_variant (ttype, attribute)
2685      tree ttype, attribute;
2686 {
2687   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
2688     {
2689       unsigned int hashcode;
2690       tree ntype;
2691
2692       ntype = copy_node (ttype);
2693
2694       TYPE_POINTER_TO (ntype) = 0;
2695       TYPE_REFERENCE_TO (ntype) = 0;
2696       TYPE_ATTRIBUTES (ntype) = attribute;
2697
2698       /* Create a new main variant of TYPE.  */
2699       TYPE_MAIN_VARIANT (ntype) = ntype;
2700       TYPE_NEXT_VARIANT (ntype) = 0;
2701       set_type_quals (ntype, TYPE_UNQUALIFIED);
2702
2703       hashcode = (TYPE_HASH (TREE_CODE (ntype))
2704                   + TYPE_HASH (TREE_TYPE (ntype))
2705                   + attribute_hash_list (attribute));
2706
2707       switch (TREE_CODE (ntype))
2708         {
2709         case FUNCTION_TYPE:
2710           hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
2711           break;
2712         case ARRAY_TYPE:
2713           hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
2714           break;
2715         case INTEGER_TYPE:
2716           hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
2717           break;
2718         case REAL_TYPE:
2719           hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
2720           break;
2721         default:
2722           break;
2723         }
2724
2725       ntype = type_hash_canon (hashcode, ntype);
2726       ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
2727     }
2728
2729   return ttype;
2730 }
2731
2732 /* Return nonzero if IDENT is a valid name for attribute ATTR,
2733    or zero if not.
2734
2735    We try both `text' and `__text__', ATTR may be either one.  */
2736 /* ??? It might be a reasonable simplification to require ATTR to be only
2737    `text'.  One might then also require attribute lists to be stored in
2738    their canonicalized form.  */
2739
2740 int
2741 is_attribute_p (attr, ident)
2742      const char *attr;
2743      tree ident;
2744 {
2745   int ident_len, attr_len;
2746   const char *p;
2747
2748   if (TREE_CODE (ident) != IDENTIFIER_NODE)
2749     return 0;
2750
2751   if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
2752     return 1;
2753
2754   p = IDENTIFIER_POINTER (ident);
2755   ident_len = strlen (p);
2756   attr_len = strlen (attr);
2757
2758   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
2759   if (attr[0] == '_')
2760     {
2761       if (attr[1] != '_'
2762           || attr[attr_len - 2] != '_'
2763           || attr[attr_len - 1] != '_')
2764         abort ();
2765       if (ident_len == attr_len - 4
2766           && strncmp (attr + 2, p, attr_len - 4) == 0)
2767         return 1;
2768     }
2769   else
2770     {
2771       if (ident_len == attr_len + 4
2772           && p[0] == '_' && p[1] == '_'
2773           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
2774           && strncmp (attr, p + 2, attr_len) == 0)
2775         return 1;
2776     }
2777
2778   return 0;
2779 }
2780
2781 /* Given an attribute name and a list of attributes, return a pointer to the
2782    attribute's list element if the attribute is part of the list, or NULL_TREE
2783    if not found.  If the attribute appears more than once, this only
2784    returns the first occurrence; the TREE_CHAIN of the return value should
2785    be passed back in if further occurrences are wanted.  */
2786
2787 tree
2788 lookup_attribute (attr_name, list)
2789      const char *attr_name;
2790      tree list;
2791 {
2792   tree l;
2793
2794   for (l = list; l; l = TREE_CHAIN (l))
2795     {
2796       if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
2797         abort ();
2798       if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
2799         return l;
2800     }
2801
2802   return NULL_TREE;
2803 }
2804
2805 /* Return an attribute list that is the union of a1 and a2.  */
2806
2807 tree
2808 merge_attributes (a1, a2)
2809      tree a1, a2;
2810 {
2811   tree attributes;
2812
2813   /* Either one unset?  Take the set one.  */
2814
2815   if ((attributes = a1) == 0)
2816     attributes = a2;
2817
2818   /* One that completely contains the other?  Take it.  */
2819
2820   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
2821     {
2822       if (attribute_list_contained (a2, a1))
2823         attributes = a2;
2824       else
2825         {
2826           /* Pick the longest list, and hang on the other list.  */
2827
2828           if (list_length (a1) < list_length (a2))
2829             attributes = a2, a2 = a1;
2830
2831           for (; a2 != 0; a2 = TREE_CHAIN (a2))
2832             {
2833               tree a;
2834               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2835                                          attributes);
2836                    a != NULL_TREE;
2837                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2838                                          TREE_CHAIN (a)))
2839                 {
2840                   if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
2841                     break;
2842                 }
2843               if (a == NULL_TREE)
2844                 {
2845                   a1 = copy_node (a2);
2846                   TREE_CHAIN (a1) = attributes;
2847                   attributes = a1;
2848                 }
2849             }
2850         }
2851     }
2852   return attributes;
2853 }
2854
2855 /* Given types T1 and T2, merge their attributes and return
2856   the result.  */
2857
2858 tree
2859 merge_type_attributes (t1, t2)
2860      tree t1, t2;
2861 {
2862   return merge_attributes (TYPE_ATTRIBUTES (t1),
2863                            TYPE_ATTRIBUTES (t2));
2864 }
2865
2866 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
2867    the result.  */
2868
2869 tree
2870 merge_decl_attributes (olddecl, newdecl)
2871      tree olddecl, newdecl;
2872 {
2873   return merge_attributes (DECL_ATTRIBUTES (olddecl),
2874                            DECL_ATTRIBUTES (newdecl));
2875 }
2876
2877 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
2878
2879 /* Specialization of merge_decl_attributes for various Windows targets.
2880
2881    This handles the following situation:
2882
2883      __declspec (dllimport) int foo;
2884      int foo;
2885
2886    The second instance of `foo' nullifies the dllimport.  */
2887
2888 tree
2889 merge_dllimport_decl_attributes (old, new)
2890      tree old;
2891      tree new;
2892 {
2893   tree a;
2894   int delete_dllimport_p;
2895
2896   old = DECL_ATTRIBUTES (old);
2897   new = DECL_ATTRIBUTES (new);
2898
2899   /* What we need to do here is remove from `old' dllimport if it doesn't
2900      appear in `new'.  dllimport behaves like extern: if a declaration is
2901      marked dllimport and a definition appears later, then the object
2902      is not dllimport'd.  */
2903   if (lookup_attribute ("dllimport", old) != NULL_TREE
2904       && lookup_attribute ("dllimport", new) == NULL_TREE)
2905     delete_dllimport_p = 1;
2906   else
2907     delete_dllimport_p = 0;
2908
2909   a = merge_attributes (old, new);
2910
2911   if (delete_dllimport_p)
2912     {
2913       tree prev, t;
2914
2915       /* Scan the list for dllimport and delete it.  */
2916       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
2917         {
2918           if (is_attribute_p ("dllimport", TREE_PURPOSE (t)))
2919             {
2920               if (prev == NULL_TREE)
2921                 a = TREE_CHAIN (a);
2922               else
2923                 TREE_CHAIN (prev) = TREE_CHAIN (t);
2924               break;
2925             }
2926         }
2927     }
2928
2929   return a;
2930 }
2931
2932 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
2933 \f
2934 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
2935    of the various TYPE_QUAL values.  */
2936
2937 static void
2938 set_type_quals (type, type_quals)
2939      tree type;
2940      int type_quals;
2941 {
2942   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
2943   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
2944   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
2945 }
2946
2947 /* Return a version of the TYPE, qualified as indicated by the
2948    TYPE_QUALS, if one exists.  If no qualified version exists yet,
2949    return NULL_TREE.  */
2950
2951 tree
2952 get_qualified_type (type, type_quals)
2953      tree type;
2954      int type_quals;
2955 {
2956   tree t;
2957
2958   /* Search the chain of variants to see if there is already one there just
2959      like the one we need to have.  If so, use that existing one.  We must
2960      preserve the TYPE_NAME, since there is code that depends on this.  */
2961   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2962     if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type)
2963         && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
2964       return t;
2965
2966   return NULL_TREE;
2967 }
2968
2969 /* Like get_qualified_type, but creates the type if it does not
2970    exist.  This function never returns NULL_TREE.  */
2971
2972 tree
2973 build_qualified_type (type, type_quals)
2974      tree type;
2975      int type_quals;
2976 {
2977   tree t;
2978
2979   /* See if we already have the appropriate qualified variant.  */
2980   t = get_qualified_type (type, type_quals);
2981
2982   /* If not, build it.  */
2983   if (!t)
2984     {
2985       t = build_type_copy (type);
2986       set_type_quals (t, type_quals);
2987     }
2988
2989   return t;
2990 }
2991
2992 /* Create a new variant of TYPE, equivalent but distinct.
2993    This is so the caller can modify it.  */
2994
2995 tree
2996 build_type_copy (type)
2997      tree type;
2998 {
2999   tree t, m = TYPE_MAIN_VARIANT (type);
3000
3001   t = copy_node (type);
3002
3003   TYPE_POINTER_TO (t) = 0;
3004   TYPE_REFERENCE_TO (t) = 0;
3005
3006   /* Add this type to the chain of variants of TYPE.  */
3007   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
3008   TYPE_NEXT_VARIANT (m) = t;
3009
3010   return t;
3011 }
3012 \f
3013 /* Hashing of types so that we don't make duplicates.
3014    The entry point is `type_hash_canon'.  */
3015
3016 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
3017    with types in the TREE_VALUE slots), by adding the hash codes
3018    of the individual types.  */
3019
3020 unsigned int
3021 type_hash_list (list)
3022      tree list;
3023 {
3024   unsigned int hashcode;
3025   tree tail;
3026
3027   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3028     hashcode += TYPE_HASH (TREE_VALUE (tail));
3029
3030   return hashcode;
3031 }
3032
3033 /* These are the Hashtable callback functions.  */
3034
3035 /* Returns true if the types are equal.  */
3036
3037 static int
3038 type_hash_eq (va, vb)
3039      const void *va;
3040      const void *vb;
3041 {
3042   const struct type_hash *a = va, *b = vb;
3043   if (a->hash == b->hash
3044       && TREE_CODE (a->type) == TREE_CODE (b->type)
3045       && TREE_TYPE (a->type) == TREE_TYPE (b->type)
3046       && attribute_list_equal (TYPE_ATTRIBUTES (a->type),
3047                                TYPE_ATTRIBUTES (b->type))
3048       && TYPE_ALIGN (a->type) == TYPE_ALIGN (b->type)
3049       && (TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
3050           || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
3051                                  TYPE_MAX_VALUE (b->type)))
3052       && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
3053           || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
3054                                  TYPE_MIN_VALUE (b->type)))
3055       /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE.  */
3056       && (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
3057           || (TYPE_DOMAIN (a->type)
3058               && TREE_CODE (TYPE_DOMAIN (a->type)) == TREE_LIST
3059               && TYPE_DOMAIN (b->type)
3060               && TREE_CODE (TYPE_DOMAIN (b->type)) == TREE_LIST
3061               && type_list_equal (TYPE_DOMAIN (a->type),
3062                                   TYPE_DOMAIN (b->type)))))
3063     return 1;
3064   return 0;
3065 }
3066
3067 /* Return the cached hash value.  */
3068
3069 static hashval_t
3070 type_hash_hash (item)
3071      const void *item;
3072 {
3073   return ((const struct type_hash *) item)->hash;
3074 }
3075
3076 /* Look in the type hash table for a type isomorphic to TYPE.
3077    If one is found, return it.  Otherwise return 0.  */
3078
3079 tree
3080 type_hash_lookup (hashcode, type)
3081      unsigned int hashcode;
3082      tree type;
3083 {
3084   struct type_hash *h, in;
3085
3086   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
3087      must call that routine before comparing TYPE_ALIGNs.  */
3088   layout_type (type);
3089
3090   in.hash = hashcode;
3091   in.type = type;
3092
3093   h = htab_find_with_hash (type_hash_table, &in, hashcode);
3094   if (h)
3095     return h->type;
3096   return NULL_TREE;
3097 }
3098
3099 /* Add an entry to the type-hash-table
3100    for a type TYPE whose hash code is HASHCODE.  */
3101
3102 void
3103 type_hash_add (hashcode, type)
3104      unsigned int hashcode;
3105      tree type;
3106 {
3107   struct type_hash *h;
3108   void **loc;
3109
3110   h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash));
3111   h->hash = hashcode;
3112   h->type = type;
3113   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
3114   *(struct type_hash **) loc = h;
3115 }
3116
3117 /* Given TYPE, and HASHCODE its hash code, return the canonical
3118    object for an identical type if one already exists.
3119    Otherwise, return TYPE, and record it as the canonical object
3120    if it is a permanent object.
3121
3122    To use this function, first create a type of the sort you want.
3123    Then compute its hash code from the fields of the type that
3124    make it different from other similar types.
3125    Then call this function and use the value.
3126    This function frees the type you pass in if it is a duplicate.  */
3127
3128 /* Set to 1 to debug without canonicalization.  Never set by program.  */
3129 int debug_no_type_hash = 0;
3130
3131 tree
3132 type_hash_canon (hashcode, type)
3133      unsigned int hashcode;
3134      tree type;
3135 {
3136   tree t1;
3137
3138   if (debug_no_type_hash)
3139     return type;
3140
3141   /* See if the type is in the hash table already.  If so, return it.
3142      Otherwise, add the type.  */
3143   t1 = type_hash_lookup (hashcode, type);
3144   if (t1 != 0)
3145     {
3146 #ifdef GATHER_STATISTICS
3147       tree_node_counts[(int) t_kind]--;
3148       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
3149 #endif
3150       return t1;
3151     }
3152   else
3153     {
3154       type_hash_add (hashcode, type);
3155       return type;
3156     }
3157 }
3158
3159 /* See if the data pointed to by the type hash table is marked.  We consider
3160    it marked if the type is marked or if a debug type number or symbol
3161    table entry has been made for the type.  This reduces the amount of
3162    debugging output and eliminates that dependency of the debug output on
3163    the number of garbage collections.  */
3164
3165 static int
3166 type_hash_marked_p (p)
3167      const void *p;
3168 {
3169   tree type = ((struct type_hash *) p)->type;
3170
3171   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
3172 }
3173
3174 static void
3175 print_type_hash_statistics ()
3176 {
3177   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
3178            (long) htab_size (type_hash_table),
3179            (long) htab_elements (type_hash_table),
3180            htab_collisions (type_hash_table));
3181 }
3182
3183 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3184    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3185    by adding the hash codes of the individual attributes.  */
3186
3187 unsigned int
3188 attribute_hash_list (list)
3189      tree list;
3190 {
3191   unsigned int hashcode;
3192   tree tail;
3193
3194   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3195     /* ??? Do we want to add in TREE_VALUE too? */
3196     hashcode += TYPE_HASH (TREE_PURPOSE (tail));
3197   return hashcode;
3198 }
3199
3200 /* Given two lists of attributes, return true if list l2 is
3201    equivalent to l1.  */
3202
3203 int
3204 attribute_list_equal (l1, l2)
3205      tree l1, l2;
3206 {
3207   return attribute_list_contained (l1, l2)
3208          && attribute_list_contained (l2, l1);
3209 }
3210
3211 /* Given two lists of attributes, return true if list L2 is
3212    completely contained within L1.  */
3213 /* ??? This would be faster if attribute names were stored in a canonicalized
3214    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3215    must be used to show these elements are equivalent (which they are).  */
3216 /* ??? It's not clear that attributes with arguments will always be handled
3217    correctly.  */
3218
3219 int
3220 attribute_list_contained (l1, l2)
3221      tree l1, l2;
3222 {
3223   tree t1, t2;
3224
3225   /* First check the obvious, maybe the lists are identical.  */
3226   if (l1 == l2)
3227     return 1;
3228
3229   /* Maybe the lists are similar.  */
3230   for (t1 = l1, t2 = l2;
3231        t1 != 0 && t2 != 0
3232         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3233         && TREE_VALUE (t1) == TREE_VALUE (t2);
3234        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3235
3236   /* Maybe the lists are equal.  */
3237   if (t1 == 0 && t2 == 0)
3238     return 1;
3239
3240   for (; t2 != 0; t2 = TREE_CHAIN (t2))
3241     {
3242       tree attr;
3243       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3244            attr != NULL_TREE;
3245            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
3246                                     TREE_CHAIN (attr)))
3247         {
3248           if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
3249             break;
3250         }
3251
3252       if (attr == 0)
3253         return 0;
3254
3255       if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3256         return 0;
3257     }
3258
3259   return 1;
3260 }
3261
3262 /* Given two lists of types
3263    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3264    return 1 if the lists contain the same types in the same order.
3265    Also, the TREE_PURPOSEs must match.  */
3266
3267 int
3268 type_list_equal (l1, l2)
3269      tree l1, l2;
3270 {
3271   tree t1, t2;
3272
3273   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3274     if (TREE_VALUE (t1) != TREE_VALUE (t2)
3275         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3276             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3277                   && (TREE_TYPE (TREE_PURPOSE (t1))
3278                       == TREE_TYPE (TREE_PURPOSE (t2))))))
3279       return 0;
3280
3281   return t1 == t2;
3282 }
3283
3284 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
3285    given by TYPE.  If the argument list accepts variable arguments,
3286    then this function counts only the ordinary arguments.  */
3287
3288 int
3289 type_num_arguments (type)
3290      tree type;
3291 {
3292   int i = 0;
3293   tree t;
3294
3295   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
3296     /* If the function does not take a variable number of arguments,
3297        the last element in the list will have type `void'.  */
3298     if (VOID_TYPE_P (TREE_VALUE (t)))
3299       break;
3300     else
3301       ++i;
3302
3303   return i;
3304 }
3305
3306 /* Nonzero if integer constants T1 and T2
3307    represent the same constant value.  */
3308
3309 int
3310 tree_int_cst_equal (t1, t2)
3311      tree t1, t2;
3312 {
3313   if (t1 == t2)
3314     return 1;
3315
3316   if (t1 == 0 || t2 == 0)
3317     return 0;
3318
3319   if (TREE_CODE (t1) == INTEGER_CST
3320       && TREE_CODE (t2) == INTEGER_CST
3321       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3322       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3323     return 1;
3324
3325   return 0;
3326 }
3327
3328 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3329    The precise way of comparison depends on their data type.  */
3330
3331 int
3332 tree_int_cst_lt (t1, t2)
3333      tree t1, t2;
3334 {
3335   if (t1 == t2)
3336     return 0;
3337
3338   if (TREE_UNSIGNED (TREE_TYPE (t1)) != TREE_UNSIGNED (TREE_TYPE (t2)))
3339     {
3340       int t1_sgn = tree_int_cst_sgn (t1);
3341       int t2_sgn = tree_int_cst_sgn (t2);
3342
3343       if (t1_sgn < t2_sgn)
3344         return 1;
3345       else if (t1_sgn > t2_sgn)
3346         return 0;
3347       /* Otherwise, both are non-negative, so we compare them as
3348          unsigned just in case one of them would overflow a signed
3349          type.  */
3350     }
3351   else if (! TREE_UNSIGNED (TREE_TYPE (t1)))
3352     return INT_CST_LT (t1, t2);
3353
3354   return INT_CST_LT_UNSIGNED (t1, t2);
3355 }
3356
3357 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
3358
3359 int
3360 tree_int_cst_compare (t1, t2)
3361      tree t1;
3362      tree t2;
3363 {
3364   if (tree_int_cst_lt (t1, t2))
3365     return -1;
3366   else if (tree_int_cst_lt (t2, t1))
3367     return 1;
3368   else
3369     return 0;
3370 }
3371
3372 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
3373    the host.  If POS is zero, the value can be represented in a single
3374    HOST_WIDE_INT.  If POS is nonzero, the value must be positive and can
3375    be represented in a single unsigned HOST_WIDE_INT.  */
3376
3377 int
3378 host_integerp (t, pos)
3379      tree t;
3380      int pos;
3381 {
3382   return (TREE_CODE (t) == INTEGER_CST
3383           && ! TREE_OVERFLOW (t)
3384           && ((TREE_INT_CST_HIGH (t) == 0
3385                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
3386               || (! pos && TREE_INT_CST_HIGH (t) == -1
3387                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
3388                   && ! TREE_UNSIGNED (TREE_TYPE (t)))
3389               || (pos && TREE_INT_CST_HIGH (t) == 0)));
3390 }
3391
3392 /* Return the HOST_WIDE_INT least significant bits of T if it is an
3393    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
3394    be positive.  Abort if we cannot satisfy the above conditions.  */
3395
3396 HOST_WIDE_INT
3397 tree_low_cst (t, pos)
3398      tree t;
3399      int pos;
3400 {
3401   if (host_integerp (t, pos))
3402     return TREE_INT_CST_LOW (t);
3403   else
3404     abort ();
3405 }
3406
3407 /* Return the most significant bit of the integer constant T.  */
3408
3409 int
3410 tree_int_cst_msb (t)
3411      tree t;
3412 {
3413   int prec;
3414   HOST_WIDE_INT h;
3415   unsigned HOST_WIDE_INT l;
3416
3417   /* Note that using TYPE_PRECISION here is wrong.  We care about the
3418      actual bits, not the (arbitrary) range of the type.  */
3419   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
3420   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
3421                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
3422   return (l & 1) == 1;
3423 }
3424
3425 /* Return an indication of the sign of the integer constant T.
3426    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3427    Note that -1 will never be returned it T's type is unsigned.  */
3428
3429 int
3430 tree_int_cst_sgn (t)
3431      tree t;
3432 {
3433   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3434     return 0;
3435   else if (TREE_UNSIGNED (TREE_TYPE (t)))
3436     return 1;
3437   else if (TREE_INT_CST_HIGH (t) < 0)
3438     return -1;
3439   else
3440     return 1;
3441 }
3442
3443 /* Compare two constructor-element-type constants.  Return 1 if the lists
3444    are known to be equal; otherwise return 0.  */
3445
3446 int
3447 simple_cst_list_equal (l1, l2)
3448      tree l1, l2;
3449 {
3450   while (l1 != NULL_TREE && l2 != NULL_TREE)
3451     {
3452       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3453         return 0;
3454
3455       l1 = TREE_CHAIN (l1);
3456       l2 = TREE_CHAIN (l2);
3457     }
3458
3459   return l1 == l2;
3460 }
3461
3462 /* Return truthvalue of whether T1 is the same tree structure as T2.
3463    Return 1 if they are the same.
3464    Return 0 if they are understandably different.
3465    Return -1 if either contains tree structure not understood by
3466    this function.  */
3467
3468 int
3469 simple_cst_equal (t1, t2)
3470      tree t1, t2;
3471 {
3472   enum tree_code code1, code2;
3473   int cmp;
3474   int i;
3475
3476   if (t1 == t2)
3477     return 1;
3478   if (t1 == 0 || t2 == 0)
3479     return 0;
3480
3481   code1 = TREE_CODE (t1);
3482   code2 = TREE_CODE (t2);
3483
3484   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3485     {
3486       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3487           || code2 == NON_LVALUE_EXPR)
3488         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3489       else
3490         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
3491     }
3492
3493   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3494            || code2 == NON_LVALUE_EXPR)
3495     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
3496
3497   if (code1 != code2)
3498     return 0;
3499
3500   switch (code1)
3501     {
3502     case INTEGER_CST:
3503       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3504               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
3505
3506     case REAL_CST:
3507       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3508
3509     case STRING_CST:
3510       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3511               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3512                          TREE_STRING_LENGTH (t1)));
3513
3514     case CONSTRUCTOR:
3515       if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
3516         return 1;
3517       else
3518         abort ();
3519
3520     case SAVE_EXPR:
3521       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3522
3523     case CALL_EXPR:
3524       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3525       if (cmp <= 0)
3526         return cmp;
3527       return
3528         simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3529
3530     case TARGET_EXPR:
3531       /* Special case: if either target is an unallocated VAR_DECL,
3532          it means that it's going to be unified with whatever the
3533          TARGET_EXPR is really supposed to initialize, so treat it
3534          as being equivalent to anything.  */
3535       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
3536            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
3537            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
3538           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
3539               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
3540               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
3541         cmp = 1;
3542       else
3543         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3544
3545       if (cmp <= 0)
3546         return cmp;
3547
3548       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3549
3550     case WITH_CLEANUP_EXPR:
3551       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3552       if (cmp <= 0)
3553         return cmp;
3554
3555       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
3556
3557     case COMPONENT_REF:
3558       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
3559         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3560
3561       return 0;
3562
3563     case VAR_DECL:
3564     case PARM_DECL:
3565     case CONST_DECL:
3566     case FUNCTION_DECL:
3567       return 0;
3568
3569     default:
3570       break;
3571     }
3572
3573   /* This general rule works for most tree codes.  All exceptions should be
3574      handled above.  If this is a language-specific tree code, we can't
3575      trust what might be in the operand, so say we don't know
3576      the situation.  */
3577   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
3578     return -1;
3579
3580   switch (TREE_CODE_CLASS (code1))
3581     {
3582     case '1':
3583     case '2':
3584     case '<':
3585     case 'e':
3586     case 'r':
3587     case 's':
3588       cmp = 1;
3589       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
3590         {
3591           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
3592           if (cmp <= 0)
3593             return cmp;
3594         }
3595
3596       return cmp;
3597
3598     default:
3599       return -1;
3600     }
3601 }
3602
3603 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
3604    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
3605    than U, respectively.  */
3606
3607 int
3608 compare_tree_int (t, u)
3609      tree t;
3610      unsigned HOST_WIDE_INT u;
3611 {
3612   if (tree_int_cst_sgn (t) < 0)
3613     return -1;
3614   else if (TREE_INT_CST_HIGH (t) != 0)
3615     return 1;
3616   else if (TREE_INT_CST_LOW (t) == u)
3617     return 0;
3618   else if (TREE_INT_CST_LOW (t) < u)
3619     return -1;
3620   else
3621     return 1;
3622 }
3623
3624 /* Generate a hash value for an expression.  This can be used iteratively
3625    by passing a previous result as the "val" argument.
3626
3627    This function is intended to produce the same hash for expressions which
3628    would compare equal using operand_equal_p.  */
3629
3630 hashval_t
3631 iterative_hash_expr (tree t, hashval_t val)
3632 {
3633   int i;
3634   enum tree_code code;
3635   char class;
3636
3637   if (t == NULL_TREE)
3638     return iterative_hash_object (t, val);
3639
3640   code = TREE_CODE (t);
3641   class = TREE_CODE_CLASS (code);
3642
3643   if (class == 'd')
3644     {
3645       /* Decls we can just compare by pointer.  */
3646       val = iterative_hash_object (t, val);
3647     }
3648   else if (class == 'c')
3649     {
3650       /* Alas, constants aren't shared, so we can't rely on pointer
3651          identity.  */
3652       if (code == INTEGER_CST)
3653         {
3654           val = iterative_hash_object (TREE_INT_CST_LOW (t), val);
3655           val = iterative_hash_object (TREE_INT_CST_HIGH (t), val);
3656         }
3657       else if (code == REAL_CST)
3658         val = iterative_hash (TREE_REAL_CST_PTR (t),
3659                               sizeof (REAL_VALUE_TYPE), val);
3660       else if (code == STRING_CST)
3661         val = iterative_hash (TREE_STRING_POINTER (t),
3662                               TREE_STRING_LENGTH (t), val);
3663       else if (code == COMPLEX_CST)
3664         {
3665           val = iterative_hash_expr (TREE_REALPART (t), val);
3666           val = iterative_hash_expr (TREE_IMAGPART (t), val);
3667         }
3668       else if (code == VECTOR_CST)
3669         val = iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
3670       else
3671         abort ();
3672     }
3673   else if (IS_EXPR_CODE_CLASS (class) || class == 'r')
3674     {
3675       val = iterative_hash_object (code, val);
3676
3677       if (code == NOP_EXPR || code == CONVERT_EXPR
3678           || code == NON_LVALUE_EXPR)
3679         val = iterative_hash_object (TREE_TYPE (t), val);
3680
3681       if (code == PLUS_EXPR || code == MULT_EXPR || code == MIN_EXPR
3682           || code == MAX_EXPR || code == BIT_IOR_EXPR || code == BIT_XOR_EXPR
3683           || code == BIT_AND_EXPR || code == NE_EXPR || code == EQ_EXPR)
3684         {
3685           /* It's a commutative expression.  We want to hash it the same
3686              however it appears.  We do this by first hashing both operands
3687              and then rehashing based on the order of their independent
3688              hashes.  */
3689           hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
3690           hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
3691           hashval_t t;
3692
3693           if (one > two)
3694             t = one, one = two, two = t;
3695
3696           val = iterative_hash_object (one, val);
3697           val = iterative_hash_object (two, val);
3698         }
3699       else
3700         for (i = first_rtl_op (code) - 1; i >= 0; --i)
3701           val = iterative_hash_expr (TREE_OPERAND (t, i), val);
3702     }
3703   else if (code == TREE_LIST)
3704     {
3705       /* A list of expressions, for a CALL_EXPR or as the elements of a
3706          VECTOR_CST.  */
3707       for (; t; t = TREE_CHAIN (t))
3708         val = iterative_hash_expr (TREE_VALUE (t), val);
3709     }
3710   else
3711     abort ();
3712
3713   return val;
3714 }
3715 \f
3716 /* Constructors for pointer, array and function types.
3717    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
3718    constructed by language-dependent code, not here.)  */
3719
3720 /* Construct, lay out and return the type of pointers to TO_TYPE
3721    with mode MODE. If such a type has already been constructed,
3722    reuse it.  */
3723
3724 tree
3725 build_pointer_type_for_mode (to_type, mode)
3726      tree to_type;
3727      enum machine_mode mode;
3728 {
3729   tree t = TYPE_POINTER_TO (to_type);
3730
3731   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
3732   if (t != 0 && mode == ptr_mode)
3733     return t;
3734
3735   t = make_node (POINTER_TYPE);
3736
3737   TREE_TYPE (t) = to_type;
3738   TYPE_MODE (t) = mode;
3739
3740   /* Record this type as the pointer to TO_TYPE.  */
3741   if (mode == ptr_mode)
3742   TYPE_POINTER_TO (to_type) = t;
3743
3744   /* Lay out the type.  This function has many callers that are concerned
3745      with expression-construction, and this simplifies them all.
3746      Also, it guarantees the TYPE_SIZE is in the same obstack as the type.  */
3747   layout_type (t);
3748
3749   return t;
3750 }
3751
3752 /* By default build pointers in ptr_mode.  */
3753
3754 tree
3755 build_pointer_type (to_type)
3756      tree to_type;
3757 {
3758   return build_pointer_type_for_mode (to_type, ptr_mode);
3759 }
3760
3761 /* Construct, lay out and return the type of references to TO_TYPE
3762    with mode MODE. If such a type has already been constructed,
3763    reuse it.  */
3764
3765 tree
3766 build_reference_type_for_mode (to_type, mode)
3767      tree to_type;
3768      enum machine_mode mode;
3769 {
3770   tree t = TYPE_REFERENCE_TO (to_type);
3771
3772   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
3773   if (t != 0 && mode == ptr_mode)
3774     return t;
3775
3776   t = make_node (REFERENCE_TYPE);
3777
3778   TREE_TYPE (t) = to_type;
3779   TYPE_MODE (t) = mode;
3780
3781   /* Record this type as the pointer to TO_TYPE.  */
3782   if (mode == ptr_mode)
3783   TYPE_REFERENCE_TO (to_type) = t;
3784
3785   layout_type (t);
3786
3787   return t;
3788 }
3789
3790
3791 /* Build the node for the type of references-to-TO_TYPE by default
3792    in ptr_mode.  */
3793
3794 tree
3795 build_reference_type (to_type)
3796      tree to_type;
3797 {
3798   return build_reference_type_for_mode (to_type, ptr_mode);
3799 }
3800
3801 /* Build a type that is compatible with t but has no cv quals anywhere
3802    in its type, thus
3803
3804    const char *const *const *  ->  char ***.  */
3805
3806 tree
3807 build_type_no_quals (t)
3808      tree t;
3809 {
3810   switch (TREE_CODE (t))
3811     {
3812     case POINTER_TYPE:
3813       return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
3814     case REFERENCE_TYPE:
3815       return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
3816     default:
3817       return TYPE_MAIN_VARIANT (t);
3818     }
3819 }
3820
3821 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
3822    MAXVAL should be the maximum value in the domain
3823    (one less than the length of the array).
3824
3825    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
3826    We don't enforce this limit, that is up to caller (e.g. language front end).
3827    The limit exists because the result is a signed type and we don't handle
3828    sizes that use more than one HOST_WIDE_INT.  */
3829
3830 tree
3831 build_index_type (maxval)
3832      tree maxval;
3833 {
3834   tree itype = make_node (INTEGER_TYPE);
3835
3836   TREE_TYPE (itype) = sizetype;
3837   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
3838   TYPE_MIN_VALUE (itype) = size_zero_node;
3839   TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
3840   TYPE_MODE (itype) = TYPE_MODE (sizetype);
3841   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
3842   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
3843   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
3844   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
3845
3846   if (host_integerp (maxval, 1))
3847     return type_hash_canon (tree_low_cst (maxval, 1), itype);
3848   else
3849     return itype;
3850 }
3851
3852 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
3853    ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
3854    low bound LOWVAL and high bound HIGHVAL.
3855    if TYPE==NULL_TREE, sizetype is used.  */
3856
3857 tree
3858 build_range_type (type, lowval, highval)
3859      tree type, lowval, highval;
3860 {
3861   tree itype = make_node (INTEGER_TYPE);
3862
3863   TREE_TYPE (itype) = type;
3864   if (type == NULL_TREE)
3865     type = sizetype;
3866
3867   TYPE_MIN_VALUE (itype) = convert (type, lowval);
3868   TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
3869
3870   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
3871   TYPE_MODE (itype) = TYPE_MODE (type);
3872   TYPE_SIZE (itype) = TYPE_SIZE (type);
3873   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
3874   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
3875   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
3876
3877   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
3878     return type_hash_canon (tree_low_cst (highval, 0)
3879                             - tree_low_cst (lowval, 0),
3880                             itype);
3881   else
3882     return itype;
3883 }
3884
3885 /* Just like build_index_type, but takes lowval and highval instead
3886    of just highval (maxval).  */
3887
3888 tree
3889 build_index_2_type (lowval, highval)
3890      tree lowval, highval;
3891 {
3892   return build_range_type (sizetype, lowval, highval);
3893 }
3894
3895 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
3896    and number of elements specified by the range of values of INDEX_TYPE.
3897    If such a type has already been constructed, reuse it.  */
3898
3899 tree
3900 build_array_type (elt_type, index_type)
3901      tree elt_type, index_type;
3902 {
3903   tree t;
3904   unsigned int hashcode;
3905
3906   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
3907     {
3908       error ("arrays of functions are not meaningful");
3909       elt_type = integer_type_node;
3910     }
3911
3912   /* Make sure TYPE_POINTER_TO (elt_type) is filled in.  */
3913   build_pointer_type (elt_type);
3914
3915   /* Allocate the array after the pointer type,
3916      in case we free it in type_hash_canon.  */
3917   t = make_node (ARRAY_TYPE);
3918   TREE_TYPE (t) = elt_type;
3919   TYPE_DOMAIN (t) = index_type;
3920
3921   if (index_type == 0)
3922     {
3923       return t;
3924     }
3925
3926   hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
3927   t = type_hash_canon (hashcode, t);
3928
3929   if (!COMPLETE_TYPE_P (t))
3930     layout_type (t);
3931   return t;
3932 }
3933
3934 /* Return the TYPE of the elements comprising
3935    the innermost dimension of ARRAY.  */
3936
3937 tree
3938 get_inner_array_type (array)
3939      tree array;
3940 {
3941   tree type = TREE_TYPE (array);
3942
3943   while (TREE_CODE (type) == ARRAY_TYPE)
3944     type = TREE_TYPE (type);
3945
3946   return type;
3947 }
3948
3949 /* Construct, lay out and return
3950    the type of functions returning type VALUE_TYPE
3951    given arguments of types ARG_TYPES.
3952    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
3953    are data type nodes for the arguments of the function.
3954    If such a type has already been constructed, reuse it.  */
3955
3956 tree
3957 build_function_type (value_type, arg_types)
3958      tree value_type, arg_types;
3959 {
3960   tree t;
3961   unsigned int hashcode;
3962
3963   if (TREE_CODE (value_type) == FUNCTION_TYPE)
3964     {
3965       error ("function return type cannot be function");
3966       value_type = integer_type_node;
3967     }
3968
3969   /* Make a node of the sort we want.  */
3970   t = make_node (FUNCTION_TYPE);
3971   TREE_TYPE (t) = value_type;
3972   TYPE_ARG_TYPES (t) = arg_types;
3973
3974   /* If we already have such a type, use the old one and free this one.  */
3975   hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
3976   t = type_hash_canon (hashcode, t);
3977
3978   if (!COMPLETE_TYPE_P (t))
3979     layout_type (t);
3980   return t;
3981 }
3982
3983 /* Build a function type.  The RETURN_TYPE is the type retured by the
3984    function.  If additional arguments are provided, they are
3985    additional argument types.  The list of argument types must always
3986    be terminated by NULL_TREE.  */
3987
3988 tree
3989 build_function_type_list (tree return_type, ...)
3990 {
3991   tree t, args, last;
3992   va_list p;
3993
3994   va_start (p, return_type);
3995
3996   t = va_arg (p, tree);
3997   for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree))
3998     args = tree_cons (NULL_TREE, t, args);
3999
4000   last = args;
4001   args = nreverse (args);
4002   TREE_CHAIN (last) = void_list_node;
4003   args = build_function_type (return_type, args);
4004
4005   va_end (p);
4006   return args;
4007 }
4008
4009 /* Construct, lay out and return the type of methods belonging to class
4010    BASETYPE and whose arguments and values are described by TYPE.
4011    If that type exists already, reuse it.
4012    TYPE must be a FUNCTION_TYPE node.  */
4013
4014 tree
4015 build_method_type (basetype, type)
4016      tree basetype, type;
4017 {
4018   tree t;
4019   unsigned int hashcode;
4020
4021   /* Make a node of the sort we want.  */
4022   t = make_node (METHOD_TYPE);
4023
4024   if (TREE_CODE (type) != FUNCTION_TYPE)
4025     abort ();
4026
4027   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
4028   TREE_TYPE (t) = TREE_TYPE (type);
4029
4030   /* The actual arglist for this function includes a "hidden" argument
4031      which is "this".  Put it into the list of argument types.  */
4032
4033   TYPE_ARG_TYPES (t)
4034     = tree_cons (NULL_TREE,
4035                  build_pointer_type (basetype), TYPE_ARG_TYPES (type));
4036
4037   /* If we already have such a type, use the old one and free this one.  */
4038   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
4039   t = type_hash_canon (hashcode, t);
4040
4041   if (!COMPLETE_TYPE_P (t))
4042     layout_type (t);
4043
4044   return t;
4045 }
4046
4047 /* Construct, lay out and return the type of offsets to a value
4048    of type TYPE, within an object of type BASETYPE.
4049    If a suitable offset type exists already, reuse it.  */
4050
4051 tree
4052 build_offset_type (basetype, type)
4053      tree basetype, type;
4054 {
4055   tree t;
4056   unsigned int hashcode;
4057
4058   /* Make a node of the sort we want.  */
4059   t = make_node (OFFSET_TYPE);
4060
4061   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
4062   TREE_TYPE (t) = type;
4063
4064   /* If we already have such a type, use the old one and free this one.  */
4065   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
4066   t = type_hash_canon (hashcode, t);
4067
4068   if (!COMPLETE_TYPE_P (t))
4069     layout_type (t);
4070
4071   return t;
4072 }
4073
4074 /* Create a complex type whose components are COMPONENT_TYPE.  */
4075
4076 tree
4077 build_complex_type (component_type)
4078      tree component_type;
4079 {
4080   tree t;
4081   unsigned int hashcode;
4082
4083   /* Make a node of the sort we want.  */
4084   t = make_node (COMPLEX_TYPE);
4085
4086   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
4087   set_type_quals (t, TYPE_QUALS (component_type));
4088
4089   /* If we already have such a type, use the old one and free this one.  */
4090   hashcode = TYPE_HASH (component_type);
4091   t = type_hash_canon (hashcode, t);
4092
4093   if (!COMPLETE_TYPE_P (t))
4094     layout_type (t);
4095
4096   /* If we are writing Dwarf2 output we need to create a name,
4097      since complex is a fundamental type.  */
4098   if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
4099       && ! TYPE_NAME (t))
4100     {
4101       const char *name;
4102       if (component_type == char_type_node)
4103         name = "complex char";
4104       else if (component_type == signed_char_type_node)
4105         name = "complex signed char";
4106       else if (component_type == unsigned_char_type_node)
4107         name = "complex unsigned char";
4108       else if (component_type == short_integer_type_node)
4109         name = "complex short int";
4110       else if (component_type == short_unsigned_type_node)
4111         name = "complex short unsigned int";
4112       else if (component_type == integer_type_node)
4113         name = "complex int";
4114       else if (component_type == unsigned_type_node)
4115         name = "complex unsigned int";
4116       else if (component_type == long_integer_type_node)
4117         name = "complex long int";
4118       else if (component_type == long_unsigned_type_node)
4119         name = "complex long unsigned int";
4120       else if (component_type == long_long_integer_type_node)
4121         name = "complex long long int";
4122       else if (component_type == long_long_unsigned_type_node)
4123         name = "complex long long unsigned int";
4124       else
4125         name = 0;
4126
4127       if (name != 0)
4128         TYPE_NAME (t) = get_identifier (name);
4129     }
4130
4131   return t;
4132 }
4133 \f
4134 /* Return OP, stripped of any conversions to wider types as much as is safe.
4135    Converting the value back to OP's type makes a value equivalent to OP.
4136
4137    If FOR_TYPE is nonzero, we return a value which, if converted to
4138    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
4139
4140    If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
4141    narrowest type that can hold the value, even if they don't exactly fit.
4142    Otherwise, bit-field references are changed to a narrower type
4143    only if they can be fetched directly from memory in that type.
4144
4145    OP must have integer, real or enumeral type.  Pointers are not allowed!
4146
4147    There are some cases where the obvious value we could return
4148    would regenerate to OP if converted to OP's type,
4149    but would not extend like OP to wider types.
4150    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
4151    For example, if OP is (unsigned short)(signed char)-1,
4152    we avoid returning (signed char)-1 if FOR_TYPE is int,
4153    even though extending that to an unsigned short would regenerate OP,
4154    since the result of extending (signed char)-1 to (int)
4155    is different from (int) OP.  */
4156
4157 tree
4158 get_unwidened (op, for_type)
4159      tree op;
4160      tree for_type;
4161 {
4162   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
4163   tree type = TREE_TYPE (op);
4164   unsigned final_prec
4165     = TYPE_PRECISION (for_type != 0 ? for_type : type);
4166   int uns
4167     = (for_type != 0 && for_type != type
4168        && final_prec > TYPE_PRECISION (type)
4169        && TREE_UNSIGNED (type));
4170   tree win = op;
4171
4172   while (TREE_CODE (op) == NOP_EXPR)
4173     {
4174       int bitschange
4175         = TYPE_PRECISION (TREE_TYPE (op))
4176           - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
4177
4178       /* Truncations are many-one so cannot be removed.
4179          Unless we are later going to truncate down even farther.  */
4180       if (bitschange < 0
4181           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
4182         break;
4183
4184       /* See what's inside this conversion.  If we decide to strip it,
4185          we will set WIN.  */
4186       op = TREE_OPERAND (op, 0);
4187
4188       /* If we have not stripped any zero-extensions (uns is 0),
4189          we can strip any kind of extension.
4190          If we have previously stripped a zero-extension,
4191          only zero-extensions can safely be stripped.
4192          Any extension can be stripped if the bits it would produce
4193          are all going to be discarded later by truncating to FOR_TYPE.  */
4194
4195       if (bitschange > 0)
4196         {
4197           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
4198             win = op;
4199           /* TREE_UNSIGNED says whether this is a zero-extension.
4200              Let's avoid computing it if it does not affect WIN
4201              and if UNS will not be needed again.  */
4202           if ((uns || TREE_CODE (op) == NOP_EXPR)
4203               && TREE_UNSIGNED (TREE_TYPE (op)))
4204             {
4205               uns = 1;
4206               win = op;
4207             }
4208         }
4209     }
4210
4211   if (TREE_CODE (op) == COMPONENT_REF
4212       /* Since type_for_size always gives an integer type.  */
4213       && TREE_CODE (type) != REAL_TYPE
4214       /* Don't crash if field not laid out yet.  */
4215       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
4216       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
4217     {
4218       unsigned int innerprec
4219         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4220       int unsignedp = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4221       type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp);
4222
4223       /* We can get this structure field in the narrowest type it fits in.
4224          If FOR_TYPE is 0, do this only for a field that matches the
4225          narrower type exactly and is aligned for it
4226          The resulting extension to its nominal type (a fullword type)
4227          must fit the same conditions as for other extensions.  */
4228
4229       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4230           && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4231           && (! uns || final_prec <= innerprec || unsignedp)
4232           && type != 0)
4233         {
4234           win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4235                        TREE_OPERAND (op, 1));
4236           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4237           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4238         }
4239     }
4240
4241   return win;
4242 }
4243 \f
4244 /* Return OP or a simpler expression for a narrower value
4245    which can be sign-extended or zero-extended to give back OP.
4246    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4247    or 0 if the value should be sign-extended.  */
4248
4249 tree
4250 get_narrower (op, unsignedp_ptr)
4251      tree op;
4252      int *unsignedp_ptr;
4253 {
4254   int uns = 0;
4255   int first = 1;
4256   tree win = op;
4257
4258   while (TREE_CODE (op) == NOP_EXPR)
4259     {
4260       int bitschange
4261         = (TYPE_PRECISION (TREE_TYPE (op))
4262            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
4263
4264       /* Truncations are many-one so cannot be removed.  */
4265       if (bitschange < 0)
4266         break;
4267
4268       /* See what's inside this conversion.  If we decide to strip it,
4269          we will set WIN.  */
4270
4271       if (bitschange > 0)
4272         {
4273           op = TREE_OPERAND (op, 0);
4274           /* An extension: the outermost one can be stripped,
4275              but remember whether it is zero or sign extension.  */
4276           if (first)
4277             uns = TREE_UNSIGNED (TREE_TYPE (op));
4278           /* Otherwise, if a sign extension has been stripped,
4279              only sign extensions can now be stripped;
4280              if a zero extension has been stripped, only zero-extensions.  */
4281           else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4282             break;
4283           first = 0;
4284         }
4285       else /* bitschange == 0 */
4286         {
4287           /* A change in nominal type can always be stripped, but we must
4288              preserve the unsignedness.  */
4289           if (first)
4290             uns = TREE_UNSIGNED (TREE_TYPE (op));
4291           first = 0;
4292           op = TREE_OPERAND (op, 0);
4293         }
4294
4295       win = op;
4296     }
4297
4298   if (TREE_CODE (op) == COMPONENT_REF
4299       /* Since type_for_size always gives an integer type.  */
4300       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
4301       /* Ensure field is laid out already.  */
4302       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4303     {
4304       unsigned HOST_WIDE_INT innerprec
4305         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4306       tree type = (*lang_hooks.types.type_for_size) (innerprec,
4307                                                      TREE_UNSIGNED (op));
4308
4309       /* We can get this structure field in a narrower type that fits it,
4310          but the resulting extension to its nominal type (a fullword type)
4311          must satisfy the same conditions as for other extensions.
4312
4313          Do this only for fields that are aligned (not bit-fields),
4314          because when bit-field insns will be used there is no
4315          advantage in doing this.  */
4316
4317       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4318           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4319           && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4320           && type != 0)
4321         {
4322           if (first)
4323             uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4324           win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4325                        TREE_OPERAND (op, 1));
4326           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4327           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4328         }
4329     }
4330   *unsignedp_ptr = uns;
4331   return win;
4332 }
4333 \f
4334 /* Nonzero if integer constant C has a value that is permissible
4335    for type TYPE (an INTEGER_TYPE).  */
4336
4337 int
4338 int_fits_type_p (c, type)
4339      tree c, type;
4340 {
4341   tree type_low_bound = TYPE_MIN_VALUE (type);
4342   tree type_high_bound = TYPE_MAX_VALUE (type);
4343   int ok_for_low_bound, ok_for_high_bound;
4344
4345   /* Perform some generic filtering first, which may allow making a decision
4346      even if the bounds are not constant.  First, negative integers never fit
4347      in unsigned types, */
4348   if ((TREE_UNSIGNED (type) && tree_int_cst_sgn (c) < 0)
4349       /* Also, unsigned integers with top bit set never fit signed types.  */
4350       || (! TREE_UNSIGNED (type)
4351           && TREE_UNSIGNED (TREE_TYPE (c)) && tree_int_cst_msb (c)))
4352     return 0;
4353
4354   /* If at least one bound of the type is a constant integer, we can check
4355      ourselves and maybe make a decision. If no such decision is possible, but
4356      this type is a subtype, try checking against that.  Otherwise, use
4357      force_fit_type, which checks against the precision.
4358
4359      Compute the status for each possibly constant bound, and return if we see
4360      one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
4361      for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
4362      for "constant known to fit".  */
4363
4364   ok_for_low_bound = -1;
4365   ok_for_high_bound = -1;
4366
4367   /* Check if C >= type_low_bound.  */
4368   if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
4369     {
4370       ok_for_low_bound = ! tree_int_cst_lt (c, type_low_bound);
4371       if (! ok_for_low_bound)
4372         return 0;
4373     }
4374
4375   /* Check if c <= type_high_bound.  */
4376   if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
4377     {
4378       ok_for_high_bound = ! tree_int_cst_lt (type_high_bound, c);
4379       if (! ok_for_high_bound)
4380         return 0;
4381     }
4382
4383   /* If the constant fits both bounds, the result is known.  */
4384   if (ok_for_low_bound == 1 && ok_for_high_bound == 1)
4385     return 1;
4386
4387   /* If we haven't been able to decide at this point, there nothing more we
4388      can check ourselves here. Look at the base type if we have one.  */
4389   else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0)
4390     return int_fits_type_p (c, TREE_TYPE (type));
4391
4392   /* Or to force_fit_type, if nothing else.  */
4393   else
4394     {
4395       c = copy_node (c);
4396       TREE_TYPE (c) = type;
4397       return !force_fit_type (c, 0);
4398     }
4399 }
4400
4401 /* Returns true if T is, contains, or refers to a type with variable
4402    size.  This concept is more general than that of C99 'variably
4403    modified types': in C99, a struct type is never variably modified
4404    because a VLA may not appear as a structure member.  However, in
4405    GNU C code like:
4406
4407      struct S { int i[f()]; };
4408
4409    is valid, and other languages may define similar constructs.  */
4410
4411 bool
4412 variably_modified_type_p (type)
4413      tree type;
4414 {
4415   if (type == error_mark_node)
4416     return false;
4417
4418   /* If TYPE itself has variable size, it is variably modified.
4419
4420      We do not yet have a representation of the C99 '[*]' syntax.
4421      When a representation is chosen, this function should be modified
4422      to test for that case as well.  */
4423   if (TYPE_SIZE (type)
4424       && TYPE_SIZE (type) != error_mark_node
4425       && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4426     return true;
4427
4428   /* If TYPE is a pointer or reference, it is variably modified if
4429      the type pointed to is variably modified.  */
4430   if ((TREE_CODE (type) == POINTER_TYPE
4431        || TREE_CODE (type) == REFERENCE_TYPE)
4432       && variably_modified_type_p (TREE_TYPE (type)))
4433     return true;
4434
4435   /* If TYPE is an array, it is variably modified if the array
4436      elements are.  (Note that the VLA case has already been checked
4437      above.)  */
4438   if (TREE_CODE (type) == ARRAY_TYPE
4439       && variably_modified_type_p (TREE_TYPE (type)))
4440     return true;
4441
4442   /* If TYPE is a function type, it is variably modified if any of the
4443      parameters or the return type are variably modified.  */
4444   if (TREE_CODE (type) == FUNCTION_TYPE
4445       || TREE_CODE (type) == METHOD_TYPE)
4446     {
4447       tree parm;
4448
4449       if (variably_modified_type_p (TREE_TYPE (type)))
4450         return true;
4451       for (parm = TYPE_ARG_TYPES (type);
4452            parm && parm != void_list_node;
4453            parm = TREE_CHAIN (parm))
4454         if (variably_modified_type_p (TREE_VALUE (parm)))
4455           return true;
4456     }
4457
4458   /* The current language may have other cases to check, but in general,
4459      all other types are not variably modified.  */
4460   return (*lang_hooks.tree_inlining.var_mod_type_p) (type);
4461 }
4462
4463 /* Given a DECL or TYPE, return the scope in which it was declared, or
4464    NULL_TREE if there is no containing scope.  */
4465
4466 tree
4467 get_containing_scope (t)
4468      tree t;
4469 {
4470   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
4471 }
4472
4473 /* Return the innermost context enclosing DECL that is
4474    a FUNCTION_DECL, or zero if none.  */
4475
4476 tree
4477 decl_function_context (decl)
4478      tree decl;
4479 {
4480   tree context;
4481
4482   if (TREE_CODE (decl) == ERROR_MARK)
4483     return 0;
4484
4485   if (TREE_CODE (decl) == SAVE_EXPR)
4486     context = SAVE_EXPR_CONTEXT (decl);
4487
4488   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
4489      where we look up the function at runtime.  Such functions always take
4490      a first argument of type 'pointer to real context'.
4491
4492      C++ should really be fixed to use DECL_CONTEXT for the real context,
4493      and use something else for the "virtual context".  */
4494   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
4495     context
4496       = TYPE_MAIN_VARIANT
4497         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4498   else
4499     context = DECL_CONTEXT (decl);
4500
4501   while (context && TREE_CODE (context) != FUNCTION_DECL)
4502     {
4503       if (TREE_CODE (context) == BLOCK)
4504         context = BLOCK_SUPERCONTEXT (context);
4505       else
4506         context = get_containing_scope (context);
4507     }
4508
4509   return context;
4510 }
4511
4512 /* Return the innermost context enclosing DECL that is
4513    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4514    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
4515
4516 tree
4517 decl_type_context (decl)
4518      tree decl;
4519 {
4520   tree context = DECL_CONTEXT (decl);
4521
4522   while (context)
4523     {
4524       if (TREE_CODE (context) == NAMESPACE_DECL)
4525         return NULL_TREE;
4526
4527       if (TREE_CODE (context) == RECORD_TYPE
4528           || TREE_CODE (context) == UNION_TYPE
4529           || TREE_CODE (context) == QUAL_UNION_TYPE)
4530         return context;
4531
4532       if (TREE_CODE (context) == TYPE_DECL
4533           || TREE_CODE (context) == FUNCTION_DECL)
4534         context = DECL_CONTEXT (context);
4535
4536       else if (TREE_CODE (context) == BLOCK)
4537         context = BLOCK_SUPERCONTEXT (context);
4538
4539       else
4540         /* Unhandled CONTEXT!?  */
4541         abort ();
4542     }
4543   return NULL_TREE;
4544 }
4545
4546 /* CALL is a CALL_EXPR.  Return the declaration for the function
4547    called, or NULL_TREE if the called function cannot be
4548    determined.  */
4549
4550 tree
4551 get_callee_fndecl (call)
4552      tree call;
4553 {
4554   tree addr;
4555
4556   /* It's invalid to call this function with anything but a
4557      CALL_EXPR.  */
4558   if (TREE_CODE (call) != CALL_EXPR)
4559     abort ();
4560
4561   /* The first operand to the CALL is the address of the function
4562      called.  */
4563   addr = TREE_OPERAND (call, 0);
4564
4565   STRIP_NOPS (addr);
4566
4567   /* If this is a readonly function pointer, extract its initial value.  */
4568   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4569       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4570       && DECL_INITIAL (addr))
4571     addr = DECL_INITIAL (addr);
4572
4573   /* If the address is just `&f' for some function `f', then we know
4574      that `f' is being called.  */
4575   if (TREE_CODE (addr) == ADDR_EXPR
4576       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4577     return TREE_OPERAND (addr, 0);
4578
4579   /* We couldn't figure out what was being called.  */
4580   return NULL_TREE;
4581 }
4582
4583 /* Print debugging information about tree nodes generated during the compile,
4584    and any language-specific information.  */
4585
4586 void
4587 dump_tree_statistics ()
4588 {
4589 #ifdef GATHER_STATISTICS
4590   int i;
4591   int total_nodes, total_bytes;
4592 #endif
4593
4594   fprintf (stderr, "\n??? tree nodes created\n\n");
4595 #ifdef GATHER_STATISTICS
4596   fprintf (stderr, "Kind                  Nodes     Bytes\n");
4597   fprintf (stderr, "-------------------------------------\n");
4598   total_nodes = total_bytes = 0;
4599   for (i = 0; i < (int) all_kinds; i++)
4600     {
4601       fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4602                tree_node_counts[i], tree_node_sizes[i]);
4603       total_nodes += tree_node_counts[i];
4604       total_bytes += tree_node_sizes[i];
4605     }
4606   fprintf (stderr, "-------------------------------------\n");
4607   fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4608   fprintf (stderr, "-------------------------------------\n");
4609 #else
4610   fprintf (stderr, "(No per-node statistics)\n");
4611 #endif
4612   print_type_hash_statistics ();
4613   (*lang_hooks.print_statistics) ();
4614 }
4615 \f
4616 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4617
4618 const char *flag_random_seed;
4619
4620 /* Set up a default flag_random_seed value, if there wasn't one already.  */
4621
4622 void
4623 default_flag_random_seed (void)
4624 {
4625   unsigned HOST_WIDE_INT value;
4626   char *new_random_seed;
4627
4628   if (flag_random_seed != NULL)
4629     return;
4630
4631   /* Get some more or less random data.  */
4632 #ifdef HAVE_GETTIMEOFDAY
4633  {
4634    struct timeval tv;
4635
4636    gettimeofday (&tv, NULL);
4637    value = (((unsigned HOST_WIDE_INT) tv.tv_usec << 16)
4638             ^ tv.tv_sec ^ getpid ());
4639  }
4640 #else
4641   value = getpid ();
4642 #endif
4643
4644   /* This slightly overestimates the space required.  */
4645   new_random_seed = xmalloc (HOST_BITS_PER_WIDE_INT / 3 + 2);
4646   sprintf (new_random_seed, HOST_WIDE_INT_PRINT_UNSIGNED, value);
4647   flag_random_seed = new_random_seed;
4648 }
4649
4650 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4651    clashes in cases where we can't reliably choose a unique name.
4652
4653    Derived from mkstemp.c in libiberty.  */
4654
4655 static void
4656 append_random_chars (template)
4657      char *template;
4658 {
4659   static const char letters[]
4660     = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4661   unsigned HOST_WIDE_INT v;
4662   size_t i;
4663
4664   default_flag_random_seed ();
4665
4666   /* This isn't a very good hash, but it does guarantee no collisions
4667      when the random string is generated by the code above and the time
4668      delta is small.  */
4669   v = 0;
4670   for (i = 0; i < strlen (flag_random_seed); i++)
4671     v = (v << 4) ^ (v >> (HOST_BITS_PER_WIDE_INT - 4)) ^ flag_random_seed[i];
4672
4673   template += strlen (template);
4674
4675   /* Fill in the random bits.  */
4676   template[0] = letters[v % 62];
4677   v /= 62;
4678   template[1] = letters[v % 62];
4679   v /= 62;
4680   template[2] = letters[v % 62];
4681   v /= 62;
4682   template[3] = letters[v % 62];
4683   v /= 62;
4684   template[4] = letters[v % 62];
4685   v /= 62;
4686   template[5] = letters[v % 62];
4687
4688   template[6] = '\0';
4689 }
4690
4691 /* P is a string that will be used in a symbol.  Mask out any characters
4692    that are not valid in that context.  */
4693
4694 void
4695 clean_symbol_name (p)
4696      char *p;
4697 {
4698   for (; *p; p++)
4699     if (! (ISALNUM (*p)
4700 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
4701             || *p == '$'
4702 #endif
4703 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
4704             || *p == '.'
4705 #endif
4706            ))
4707       *p = '_';
4708 }
4709
4710 /* Generate a name for a function unique to this translation unit.
4711    TYPE is some string to identify the purpose of this function to the
4712    linker or collect2.  */
4713
4714 tree
4715 get_file_function_name_long (type)
4716      const char *type;
4717 {
4718   char *buf;
4719   const char *p;
4720   char *q;
4721
4722   if (first_global_object_name)
4723     p = first_global_object_name;
4724   else
4725     {
4726       /* We don't have anything that we know to be unique to this translation
4727          unit, so use what we do have and throw in some randomness.  */
4728
4729       const char *name = weak_global_object_name;
4730       const char *file = main_input_filename;
4731
4732       if (! name)
4733         name = "";
4734       if (! file)
4735         file = input_filename;
4736
4737       q = (char *) alloca (7 + strlen (name) + strlen (file));
4738
4739       sprintf (q, "%s%s", name, file);
4740       append_random_chars (q);
4741       p = q;
4742     }
4743
4744   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4745                          + strlen (type));
4746
4747   /* Set up the name of the file-level functions we may need.
4748      Use a global object (which is already required to be unique over
4749      the program) rather than the file name (which imposes extra
4750      constraints).  */
4751   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4752
4753   /* Don't need to pull weird characters out of global names.  */
4754   if (p != first_global_object_name)
4755     clean_symbol_name (buf + 11);
4756
4757   return get_identifier (buf);
4758 }
4759
4760 /* If KIND=='I', return a suitable global initializer (constructor) name.
4761    If KIND=='D', return a suitable global clean-up (destructor) name.  */
4762
4763 tree
4764 get_file_function_name (kind)
4765      int kind;
4766 {
4767   char p[2];
4768
4769   p[0] = kind;
4770   p[1] = 0;
4771
4772   return get_file_function_name_long (p);
4773 }
4774 \f
4775 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4776    The result is placed in BUFFER (which has length BIT_SIZE),
4777    with one bit in each char ('\000' or '\001').
4778
4779    If the constructor is constant, NULL_TREE is returned.
4780    Otherwise, a TREE_LIST of the non-constant elements is emitted.  */
4781
4782 tree
4783 get_set_constructor_bits (init, buffer, bit_size)
4784      tree init;
4785      char *buffer;
4786      int bit_size;
4787 {
4788   int i;
4789   tree vals;
4790   HOST_WIDE_INT domain_min
4791     = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
4792   tree non_const_bits = NULL_TREE;
4793
4794   for (i = 0; i < bit_size; i++)
4795     buffer[i] = 0;
4796
4797   for (vals = TREE_OPERAND (init, 1);
4798        vals != NULL_TREE; vals = TREE_CHAIN (vals))
4799     {
4800       if (!host_integerp (TREE_VALUE (vals), 0)
4801           || (TREE_PURPOSE (vals) != NULL_TREE
4802               && !host_integerp (TREE_PURPOSE (vals), 0)))
4803         non_const_bits
4804           = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
4805       else if (TREE_PURPOSE (vals) != NULL_TREE)
4806         {
4807           /* Set a range of bits to ones.  */
4808           HOST_WIDE_INT lo_index
4809             = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
4810           HOST_WIDE_INT hi_index
4811             = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4812
4813           if (lo_index < 0 || lo_index >= bit_size
4814               || hi_index < 0 || hi_index >= bit_size)
4815             abort ();
4816           for (; lo_index <= hi_index; lo_index++)
4817             buffer[lo_index] = 1;
4818         }
4819       else
4820         {
4821           /* Set a single bit to one.  */
4822           HOST_WIDE_INT index
4823             = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4824           if (index < 0 || index >= bit_size)
4825             {
4826               error ("invalid initializer for bit string");
4827               return NULL_TREE;
4828             }
4829           buffer[index] = 1;
4830         }
4831     }
4832   return non_const_bits;
4833 }
4834
4835 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4836    The result is placed in BUFFER (which is an array of bytes).
4837    If the constructor is constant, NULL_TREE is returned.
4838    Otherwise, a TREE_LIST of the non-constant elements is emitted.  */
4839
4840 tree
4841 get_set_constructor_bytes (init, buffer, wd_size)
4842      tree init;
4843      unsigned char *buffer;
4844      int wd_size;
4845 {
4846   int i;
4847   int set_word_size = BITS_PER_UNIT;
4848   int bit_size = wd_size * set_word_size;
4849   int bit_pos = 0;
4850   unsigned char *bytep = buffer;
4851   char *bit_buffer = (char *) alloca (bit_size);
4852   tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
4853
4854   for (i = 0; i < wd_size; i++)
4855     buffer[i] = 0;
4856
4857   for (i = 0; i < bit_size; i++)
4858     {
4859       if (bit_buffer[i])
4860         {
4861           if (BYTES_BIG_ENDIAN)
4862             *bytep |= (1 << (set_word_size - 1 - bit_pos));
4863           else
4864             *bytep |= 1 << bit_pos;
4865         }
4866       bit_pos++;
4867       if (bit_pos >= set_word_size)
4868         bit_pos = 0, bytep++;
4869     }
4870   return non_const_bits;
4871 }
4872 \f
4873 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4874 /* Complain that the tree code of NODE does not match the expected CODE.
4875    FILE, LINE, and FUNCTION are of the caller.  */
4876
4877 void
4878 tree_check_failed (node, code, file, line, function)
4879      const tree node;
4880      enum tree_code code;
4881      const char *file;
4882      int line;
4883      const char *function;
4884 {
4885   internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
4886                   tree_code_name[code], tree_code_name[TREE_CODE (node)],
4887                   function, trim_filename (file), line);
4888 }
4889
4890 /* Similar to above, except that we check for a class of tree
4891    code, given in CL.  */
4892
4893 void
4894 tree_class_check_failed (node, cl, file, line, function)
4895      const tree node;
4896      int cl;
4897      const char *file;
4898      int line;
4899      const char *function;
4900 {
4901   internal_error
4902     ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
4903      cl, TREE_CODE_CLASS (TREE_CODE (node)),
4904      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
4905 }
4906
4907 /* Similar to above, except that the check is for the bounds of a TREE_VEC's
4908    (dynamically sized) vector.  */
4909
4910 void
4911 tree_vec_elt_check_failed (idx, len, file, line, function)
4912      int idx;
4913      int len;
4914      const char *file;
4915      int line;
4916      const char *function;
4917 {
4918   internal_error
4919     ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
4920      idx + 1, len, function, trim_filename (file), line);
4921 }
4922
4923 /* Similar to above, except that the check is for the bounds of the operand
4924    vector of an expression node.  */
4925
4926 void
4927 tree_operand_check_failed (idx, code, file, line, function)
4928      int idx;
4929      enum tree_code code;
4930      const char *file;
4931      int line;
4932      const char *function;
4933 {
4934   internal_error
4935     ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
4936      idx + 1, tree_code_name[code], TREE_CODE_LENGTH (code),
4937      function, trim_filename (file), line);
4938 }
4939 #endif /* ENABLE_TREE_CHECKING */
4940 \f
4941 /* For a new vector type node T, build the information necessary for
4942    debugging output.  */
4943
4944 static void
4945 finish_vector_type (t)
4946      tree t;
4947 {
4948   layout_type (t);
4949
4950   {
4951     tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4952     tree array = build_array_type (TREE_TYPE (t),
4953                                    build_index_type (index));
4954     tree rt = make_node (RECORD_TYPE);
4955
4956     TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4957     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4958     layout_type (rt);
4959     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4960     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
4961        the representation type, and we want to find that die when looking up
4962        the vector type.  This is most easily achieved by making the TYPE_UID
4963        numbers equal.  */
4964     TYPE_UID (rt) = TYPE_UID (t);
4965   }
4966 }
4967
4968 /* Create nodes for all integer types (and error_mark_node) using the sizes
4969    of C datatypes.  The caller should call set_sizetype soon after calling
4970    this function to select one of the types as sizetype.  */
4971
4972 void
4973 build_common_tree_nodes (signed_char)
4974      int signed_char;
4975 {
4976   error_mark_node = make_node (ERROR_MARK);
4977   TREE_TYPE (error_mark_node) = error_mark_node;
4978
4979   initialize_sizetypes ();
4980
4981   /* Define both `signed char' and `unsigned char'.  */
4982   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4983   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4984
4985   /* Define `char', which is like either `signed char' or `unsigned char'
4986      but not the same as either.  */
4987   char_type_node
4988     = (signed_char
4989        ? make_signed_type (CHAR_TYPE_SIZE)
4990        : make_unsigned_type (CHAR_TYPE_SIZE));
4991
4992   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4993   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4994   integer_type_node = make_signed_type (INT_TYPE_SIZE);
4995   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4996   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4997   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4998   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4999   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
5000
5001   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
5002   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
5003   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
5004   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
5005   intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
5006
5007   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
5008   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
5009   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
5010   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
5011   unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
5012 }
5013
5014 /* Call this function after calling build_common_tree_nodes and set_sizetype.
5015    It will create several other common tree nodes.  */
5016
5017 void
5018 build_common_tree_nodes_2 (short_double)
5019      int short_double;
5020 {
5021   /* Define these next since types below may used them.  */
5022   integer_zero_node = build_int_2 (0, 0);
5023   integer_one_node = build_int_2 (1, 0);
5024   integer_minus_one_node = build_int_2 (-1, -1);
5025
5026   size_zero_node = size_int (0);
5027   size_one_node = size_int (1);
5028   bitsize_zero_node = bitsize_int (0);
5029   bitsize_one_node = bitsize_int (1);
5030   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
5031
5032   void_type_node = make_node (VOID_TYPE);
5033   layout_type (void_type_node);
5034
5035   /* We are not going to have real types in C with less than byte alignment,
5036      so we might as well not have any types that claim to have it.  */
5037   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
5038   TYPE_USER_ALIGN (void_type_node) = 0;
5039
5040   null_pointer_node = build_int_2 (0, 0);
5041   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
5042   layout_type (TREE_TYPE (null_pointer_node));
5043
5044   ptr_type_node = build_pointer_type (void_type_node);
5045   const_ptr_type_node
5046     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
5047
5048   float_type_node = make_node (REAL_TYPE);
5049   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
5050   layout_type (float_type_node);
5051
5052   double_type_node = make_node (REAL_TYPE);
5053   if (short_double)
5054     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
5055   else
5056     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
5057   layout_type (double_type_node);
5058
5059   long_double_type_node = make_node (REAL_TYPE);
5060   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
5061   layout_type (long_double_type_node);
5062
5063   complex_integer_type_node = make_node (COMPLEX_TYPE);
5064   TREE_TYPE (complex_integer_type_node) = integer_type_node;
5065   layout_type (complex_integer_type_node);
5066
5067   complex_float_type_node = make_node (COMPLEX_TYPE);
5068   TREE_TYPE (complex_float_type_node) = float_type_node;
5069   layout_type (complex_float_type_node);
5070
5071   complex_double_type_node = make_node (COMPLEX_TYPE);
5072   TREE_TYPE (complex_double_type_node) = double_type_node;
5073   layout_type (complex_double_type_node);
5074
5075   complex_long_double_type_node = make_node (COMPLEX_TYPE);
5076   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
5077   layout_type (complex_long_double_type_node);
5078
5079   {
5080     tree t;
5081     BUILD_VA_LIST_TYPE (t);
5082
5083     /* Many back-ends define record types without setting TYPE_NAME.
5084        If we copied the record type here, we'd keep the original
5085        record type without a name.  This breaks name mangling.  So,
5086        don't copy record types and let c_common_nodes_and_builtins()
5087        declare the type to be __builtin_va_list.  */
5088     if (TREE_CODE (t) != RECORD_TYPE)
5089       t = build_type_copy (t);
5090
5091     va_list_type_node = t;
5092   }
5093
5094   unsigned_V4SI_type_node
5095     = make_vector (V4SImode, unsigned_intSI_type_node, 1);
5096   unsigned_V2HI_type_node
5097     = make_vector (V2HImode, unsigned_intHI_type_node, 1);
5098   unsigned_V2SI_type_node
5099     = make_vector (V2SImode, unsigned_intSI_type_node, 1);
5100   unsigned_V2DI_type_node
5101     = make_vector (V2DImode, unsigned_intDI_type_node, 1);
5102   unsigned_V4HI_type_node
5103     = make_vector (V4HImode, unsigned_intHI_type_node, 1);
5104   unsigned_V8QI_type_node
5105     = make_vector (V8QImode, unsigned_intQI_type_node, 1);
5106   unsigned_V8HI_type_node
5107     = make_vector (V8HImode, unsigned_intHI_type_node, 1);
5108   unsigned_V16QI_type_node
5109     = make_vector (V16QImode, unsigned_intQI_type_node, 1);
5110   unsigned_V1DI_type_node
5111     = make_vector (V1DImode, unsigned_intDI_type_node, 1);
5112
5113   V16SF_type_node = make_vector (V16SFmode, float_type_node, 0);
5114   V4SF_type_node = make_vector (V4SFmode, float_type_node, 0);
5115   V4SI_type_node = make_vector (V4SImode, intSI_type_node, 0);
5116   V2HI_type_node = make_vector (V2HImode, intHI_type_node, 0);
5117   V2SI_type_node = make_vector (V2SImode, intSI_type_node, 0);
5118   V2DI_type_node = make_vector (V2DImode, intDI_type_node, 0);
5119   V4HI_type_node = make_vector (V4HImode, intHI_type_node, 0);
5120   V8QI_type_node = make_vector (V8QImode, intQI_type_node, 0);
5121   V8HI_type_node = make_vector (V8HImode, intHI_type_node, 0);
5122   V2SF_type_node = make_vector (V2SFmode, float_type_node, 0);
5123   V2DF_type_node = make_vector (V2DFmode, double_type_node, 0);
5124   V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0);
5125   V1DI_type_node = make_vector (V1DImode, intDI_type_node, 0);
5126 }
5127
5128 /* Returns a vector tree node given a vector mode, the inner type, and
5129    the signness.  */
5130
5131 static tree
5132 make_vector (mode, innertype, unsignedp)
5133      enum machine_mode mode;
5134      tree innertype;
5135      int unsignedp;
5136 {
5137   tree t;
5138
5139   t = make_node (VECTOR_TYPE);
5140   TREE_TYPE (t) = innertype;
5141   TYPE_MODE (t) = mode;
5142   TREE_UNSIGNED (TREE_TYPE (t)) = unsignedp;
5143   finish_vector_type (t);
5144
5145   return t;
5146 }
5147
5148 /* Given an initializer INIT, return TRUE if INIT is zero or some
5149    aggregate of zeros.  Otherwise return FALSE.  */
5150
5151 bool
5152 initializer_zerop (init)
5153      tree init;
5154 {
5155   STRIP_NOPS (init);
5156
5157   switch (TREE_CODE (init))
5158     {
5159     case INTEGER_CST:
5160       return integer_zerop (init);
5161     case REAL_CST:
5162       return real_zerop (init)
5163         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
5164     case COMPLEX_CST:
5165       return integer_zerop (init)
5166         || (real_zerop (init)
5167             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
5168             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
5169     case CONSTRUCTOR:
5170       {
5171         if (AGGREGATE_TYPE_P (TREE_TYPE (init)))
5172           {
5173             tree aggr_init = CONSTRUCTOR_ELTS (init);
5174
5175             while (aggr_init)
5176               {
5177                 if (! initializer_zerop (TREE_VALUE (aggr_init)))
5178                   return false;
5179                 aggr_init = TREE_CHAIN (aggr_init);
5180               }
5181             return true;
5182           }
5183         return false;
5184       }
5185     default:
5186       return false;
5187     }
5188 }
5189
5190 #include "gt-tree.h"