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