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_NON_ADDR_CONST_P (arg);
1358
1359     case CONSTRUCTOR:
1360       return TREE_STATIC (arg);
1361
1362     case LABEL_DECL:
1363     case STRING_CST:
1364       return 1;
1365
1366       /* If we are referencing a bitfield, we can't evaluate an
1367          ADDR_EXPR at compile time and so it isn't a constant.  */
1368     case COMPONENT_REF:
1369       return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
1370               && staticp (TREE_OPERAND (arg, 0)));
1371
1372     case BIT_FIELD_REF:
1373       return 0;
1374
1375 #if 0
1376        /* This case is technically correct, but results in setting
1377           TREE_CONSTANT on ADDR_EXPRs that cannot be evaluated at
1378           compile time.  */
1379     case INDIRECT_REF:
1380       return TREE_CONSTANT (TREE_OPERAND (arg, 0));
1381 #endif
1382
1383     case ARRAY_REF:
1384     case ARRAY_RANGE_REF:
1385       if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
1386           && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
1387         return staticp (TREE_OPERAND (arg, 0));
1388
1389     default:
1390       if ((unsigned int) TREE_CODE (arg)
1391           >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
1392         return (*lang_hooks.staticp) (arg);
1393       else
1394         return 0;
1395     }
1396 }
1397 \f
1398 /* Wrap a SAVE_EXPR around EXPR, if appropriate.
1399    Do this to any expression which may be used in more than one place,
1400    but must be evaluated only once.
1401
1402    Normally, expand_expr would reevaluate the expression each time.
1403    Calling save_expr produces something that is evaluated and recorded
1404    the first time expand_expr is called on it.  Subsequent calls to
1405    expand_expr just reuse the recorded value.
1406
1407    The call to expand_expr that generates code that actually computes
1408    the value is the first call *at compile time*.  Subsequent calls
1409    *at compile time* generate code to use the saved value.
1410    This produces correct result provided that *at run time* control
1411    always flows through the insns made by the first expand_expr
1412    before reaching the other places where the save_expr was evaluated.
1413    You, the caller of save_expr, must make sure this is so.
1414
1415    Constants, and certain read-only nodes, are returned with no
1416    SAVE_EXPR because that is safe.  Expressions containing placeholders
1417    are not touched; see tree.def for an explanation of what these
1418    are used for.  */
1419
1420 tree
1421 save_expr (expr)
1422      tree expr;
1423 {
1424   tree t = fold (expr);
1425   tree inner;
1426
1427   /* We don't care about whether this can be used as an lvalue in this
1428      context.  */
1429   while (TREE_CODE (t) == NON_LVALUE_EXPR)
1430     t = TREE_OPERAND (t, 0);
1431
1432   /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
1433      a constant, it will be more efficient to not make another SAVE_EXPR since
1434      it will allow better simplification and GCSE will be able to merge the
1435      computations if they actualy occur.  */
1436   for (inner = t;
1437        (TREE_CODE_CLASS (TREE_CODE (inner)) == '1'
1438         || (TREE_CODE_CLASS (TREE_CODE (inner)) == '2'
1439             && TREE_CONSTANT (TREE_OPERAND (inner, 1))));
1440        inner = TREE_OPERAND (inner, 0))
1441     ;
1442
1443   /* If the tree evaluates to a constant, then we don't want to hide that
1444      fact (i.e. this allows further folding, and direct checks for constants).
1445      However, a read-only object that has side effects cannot be bypassed.
1446      Since it is no problem to reevaluate literals, we just return the
1447      literal node.  */
1448   if (TREE_CONSTANT (inner)
1449       || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
1450       || TREE_CODE (inner) == SAVE_EXPR || TREE_CODE (inner) == ERROR_MARK)
1451     return t;
1452
1453   /* If T contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
1454      it means that the size or offset of some field of an object depends on
1455      the value within another field.
1456
1457      Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
1458      and some variable since it would then need to be both evaluated once and
1459      evaluated more than once.  Front-ends must assure this case cannot
1460      happen by surrounding any such subexpressions in their own SAVE_EXPR
1461      and forcing evaluation at the proper time.  */
1462   if (contains_placeholder_p (t))
1463     return t;
1464
1465   t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
1466
1467   /* This expression might be placed ahead of a jump to ensure that the
1468      value was computed on both sides of the jump.  So make sure it isn't
1469      eliminated as dead.  */
1470   TREE_SIDE_EFFECTS (t) = 1;
1471   TREE_READONLY (t) = 1;
1472   return t;
1473 }
1474
1475 /* Arrange for an expression to be expanded multiple independent
1476    times.  This is useful for cleanup actions, as the backend can
1477    expand them multiple times in different places.  */
1478
1479 tree
1480 unsave_expr (expr)
1481      tree expr;
1482 {
1483   tree t;
1484
1485   /* If this is already protected, no sense in protecting it again.  */
1486   if (TREE_CODE (expr) == UNSAVE_EXPR)
1487     return expr;
1488
1489   t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
1490   TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
1491   return t;
1492 }
1493
1494 /* Returns the index of the first non-tree operand for CODE, or the number
1495    of operands if all are trees.  */
1496
1497 int
1498 first_rtl_op (code)
1499      enum tree_code code;
1500 {
1501   switch (code)
1502     {
1503     case SAVE_EXPR:
1504       return 2;
1505     case GOTO_SUBROUTINE_EXPR:
1506     case RTL_EXPR:
1507       return 0;
1508     case WITH_CLEANUP_EXPR:
1509       return 2;
1510     case METHOD_CALL_EXPR:
1511       return 3;
1512     default:
1513       return TREE_CODE_LENGTH (code);
1514     }
1515 }
1516
1517 /* Perform any modifications to EXPR required when it is unsaved.  Does
1518    not recurse into EXPR's subtrees.  */
1519
1520 void
1521 unsave_expr_1 (expr)
1522      tree expr;
1523 {
1524   switch (TREE_CODE (expr))
1525     {
1526     case SAVE_EXPR:
1527       if (! SAVE_EXPR_PERSISTENT_P (expr))
1528         SAVE_EXPR_RTL (expr) = 0;
1529       break;
1530
1531     case TARGET_EXPR:
1532       /* Don't mess with a TARGET_EXPR that hasn't been expanded.
1533          It's OK for this to happen if it was part of a subtree that
1534          isn't immediately expanded, such as operand 2 of another
1535          TARGET_EXPR.  */
1536       if (TREE_OPERAND (expr, 1))
1537         break;
1538
1539       TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
1540       TREE_OPERAND (expr, 3) = NULL_TREE;
1541       break;
1542
1543     case RTL_EXPR:
1544       /* I don't yet know how to emit a sequence multiple times.  */
1545       if (RTL_EXPR_SEQUENCE (expr) != 0)
1546         abort ();
1547       break;
1548
1549     default:
1550       break;
1551     }
1552 }
1553
1554 /* Default lang hook for "unsave_expr_now".  */
1555
1556 tree
1557 lhd_unsave_expr_now (expr)
1558      tree expr;
1559 {
1560   enum tree_code code;
1561
1562   /* There's nothing to do for NULL_TREE.  */
1563   if (expr == 0)
1564     return expr;
1565
1566   unsave_expr_1 (expr);
1567
1568   code = TREE_CODE (expr);
1569   switch (TREE_CODE_CLASS (code))
1570     {
1571     case 'c':  /* a constant */
1572     case 't':  /* a type node */
1573     case 'd':  /* A decl node */
1574     case 'b':  /* A block node */
1575       break;
1576
1577     case 'x':  /* miscellaneous: e.g., identifier, TREE_LIST or ERROR_MARK.  */
1578       if (code == TREE_LIST)
1579         {
1580           lhd_unsave_expr_now (TREE_VALUE (expr));
1581           lhd_unsave_expr_now (TREE_CHAIN (expr));
1582         }
1583       break;
1584
1585     case 'e':  /* an expression */
1586     case 'r':  /* a reference */
1587     case 's':  /* an expression with side effects */
1588     case '<':  /* a comparison expression */
1589     case '2':  /* a binary arithmetic expression */
1590     case '1':  /* a unary arithmetic expression */
1591       {
1592         int i;
1593
1594         for (i = first_rtl_op (code) - 1; i >= 0; i--)
1595           lhd_unsave_expr_now (TREE_OPERAND (expr, i));
1596       }
1597       break;
1598
1599     default:
1600       abort ();
1601     }
1602
1603   return expr;
1604 }
1605
1606 /* Return 0 if it is safe to evaluate EXPR multiple times,
1607    return 1 if it is safe if EXPR is unsaved afterward, or
1608    return 2 if it is completely unsafe.
1609
1610    This assumes that CALL_EXPRs and TARGET_EXPRs are never replicated in
1611    an expression tree, so that it safe to unsave them and the surrounding
1612    context will be correct.
1613
1614    SAVE_EXPRs basically *only* appear replicated in an expression tree,
1615    occasionally across the whole of a function.  It is therefore only
1616    safe to unsave a SAVE_EXPR if you know that all occurrences appear
1617    below the UNSAVE_EXPR.
1618
1619    RTL_EXPRs consume their rtl during evaluation.  It is therefore
1620    never possible to unsave them.  */
1621
1622 int
1623 unsafe_for_reeval (expr)
1624      tree expr;
1625 {
1626   int unsafeness = 0;
1627   enum tree_code code;
1628   int i, tmp;
1629   tree exp;
1630   int first_rtl;
1631
1632   if (expr == NULL_TREE)
1633     return 1;
1634
1635   code = TREE_CODE (expr);
1636   first_rtl = first_rtl_op (code);
1637
1638   switch (code)
1639     {
1640     case SAVE_EXPR:
1641     case RTL_EXPR:
1642       return 2;
1643
1644     case TREE_LIST:
1645       for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
1646         {
1647           tmp = unsafe_for_reeval (TREE_VALUE (exp));
1648           unsafeness = MAX (tmp, unsafeness);
1649         }
1650
1651       return unsafeness;
1652
1653     case CALL_EXPR:
1654       tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
1655       return MAX (tmp, 1);
1656
1657     case TARGET_EXPR:
1658       unsafeness = 1;
1659       break;
1660
1661     default:
1662       tmp = (*lang_hooks.unsafe_for_reeval) (expr);
1663       if (tmp >= 0)
1664         return tmp;
1665       break;
1666     }
1667
1668   switch (TREE_CODE_CLASS (code))
1669     {
1670     case 'c':  /* a constant */
1671     case 't':  /* a type node */
1672     case 'x':  /* something random, like an identifier or an ERROR_MARK.  */
1673     case 'd':  /* A decl node */
1674     case 'b':  /* A block node */
1675       return 0;
1676
1677     case 'e':  /* an expression */
1678     case 'r':  /* a reference */
1679     case 's':  /* an expression with side effects */
1680     case '<':  /* a comparison expression */
1681     case '2':  /* a binary arithmetic expression */
1682     case '1':  /* a unary arithmetic expression */
1683       for (i = first_rtl - 1; i >= 0; i--)
1684         {
1685           tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
1686           unsafeness = MAX (tmp, unsafeness);
1687         }
1688
1689       return unsafeness;
1690
1691     default:
1692       return 2;
1693     }
1694 }
1695 \f
1696 /* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
1697    or offset that depends on a field within a record.  */
1698
1699 int
1700 contains_placeholder_p (exp)
1701      tree exp;
1702 {
1703   enum tree_code code;
1704   int result;
1705
1706   if (!exp)
1707     return 0;
1708
1709   /* If we have a WITH_RECORD_EXPR, it "cancels" any PLACEHOLDER_EXPR
1710      in it since it is supplying a value for it.  */
1711   code = TREE_CODE (exp);
1712   if (code == WITH_RECORD_EXPR)
1713     return 0;
1714   else if (code == PLACEHOLDER_EXPR)
1715     return 1;
1716
1717   switch (TREE_CODE_CLASS (code))
1718     {
1719     case 'r':
1720       /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
1721          position computations since they will be converted into a
1722          WITH_RECORD_EXPR involving the reference, which will assume
1723          here will be valid.  */
1724       return contains_placeholder_p (TREE_OPERAND (exp, 0));
1725
1726     case 'x':
1727       if (code == TREE_LIST)
1728         return (contains_placeholder_p (TREE_VALUE (exp))
1729                 || (TREE_CHAIN (exp) != 0
1730                     && contains_placeholder_p (TREE_CHAIN (exp))));
1731       break;
1732
1733     case '1':
1734     case '2':  case '<':
1735     case 'e':
1736       switch (code)
1737         {
1738         case COMPOUND_EXPR:
1739           /* Ignoring the first operand isn't quite right, but works best.  */
1740           return contains_placeholder_p (TREE_OPERAND (exp, 1));
1741
1742         case RTL_EXPR:
1743         case CONSTRUCTOR:
1744           return 0;
1745
1746         case COND_EXPR:
1747           return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1748                   || contains_placeholder_p (TREE_OPERAND (exp, 1))
1749                   || contains_placeholder_p (TREE_OPERAND (exp, 2)));
1750
1751         case SAVE_EXPR:
1752           /* If we already know this doesn't have a placeholder, don't
1753              check again.  */
1754           if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
1755             return 0;
1756
1757           SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
1758           result = contains_placeholder_p (TREE_OPERAND (exp, 0));
1759           if (result)
1760             SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
1761
1762           return result;
1763
1764         case CALL_EXPR:
1765           return (TREE_OPERAND (exp, 1) != 0
1766                   && contains_placeholder_p (TREE_OPERAND (exp, 1)));
1767
1768         default:
1769           break;
1770         }
1771
1772       switch (TREE_CODE_LENGTH (code))
1773         {
1774         case 1:
1775           return contains_placeholder_p (TREE_OPERAND (exp, 0));
1776         case 2:
1777           return (contains_placeholder_p (TREE_OPERAND (exp, 0))
1778                   || contains_placeholder_p (TREE_OPERAND (exp, 1)));
1779         default:
1780           return 0;
1781         }
1782
1783     default:
1784       return 0;
1785     }
1786   return 0;
1787 }
1788
1789 /* Return 1 if EXP contains any expressions that produce cleanups for an
1790    outer scope to deal with.  Used by fold.  */
1791
1792 int
1793 has_cleanups (exp)
1794      tree exp;
1795 {
1796   int i, nops, cmp;
1797
1798   if (! TREE_SIDE_EFFECTS (exp))
1799     return 0;
1800
1801   switch (TREE_CODE (exp))
1802     {
1803     case TARGET_EXPR:
1804     case GOTO_SUBROUTINE_EXPR:
1805     case WITH_CLEANUP_EXPR:
1806       return 1;
1807
1808     case CLEANUP_POINT_EXPR:
1809       return 0;
1810
1811     case CALL_EXPR:
1812       for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
1813         {
1814           cmp = has_cleanups (TREE_VALUE (exp));
1815           if (cmp)
1816             return cmp;
1817         }
1818       return 0;
1819
1820     default:
1821       break;
1822     }
1823
1824   /* This general rule works for most tree codes.  All exceptions should be
1825      handled above.  If this is a language-specific tree code, we can't
1826      trust what might be in the operand, so say we don't know
1827      the situation.  */
1828   if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
1829     return -1;
1830
1831   nops = first_rtl_op (TREE_CODE (exp));
1832   for (i = 0; i < nops; i++)
1833     if (TREE_OPERAND (exp, i) != 0)
1834       {
1835         int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
1836         if (type == 'e' || type == '<' || type == '1' || type == '2'
1837             || type == 'r' || type == 's')
1838           {
1839             cmp = has_cleanups (TREE_OPERAND (exp, i));
1840             if (cmp)
1841               return cmp;
1842           }
1843       }
1844
1845   return 0;
1846 }
1847 \f
1848 /* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
1849    return a tree with all occurrences of references to F in a
1850    PLACEHOLDER_EXPR replaced by R.   Note that we assume here that EXP
1851    contains only arithmetic expressions or a CALL_EXPR with a
1852    PLACEHOLDER_EXPR occurring only in its arglist.  */
1853
1854 tree
1855 substitute_in_expr (exp, f, r)
1856      tree exp;
1857      tree f;
1858      tree r;
1859 {
1860   enum tree_code code = TREE_CODE (exp);
1861   tree op0, op1, op2;
1862   tree new;
1863   tree inner;
1864
1865   switch (TREE_CODE_CLASS (code))
1866     {
1867     case 'c':
1868     case 'd':
1869       return exp;
1870
1871     case 'x':
1872       if (code == PLACEHOLDER_EXPR)
1873         return exp;
1874       else if (code == TREE_LIST)
1875         {
1876           op0 = (TREE_CHAIN (exp) == 0
1877                  ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
1878           op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
1879           if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
1880             return exp;
1881
1882           return tree_cons (TREE_PURPOSE (exp), op1, op0);
1883         }
1884
1885       abort ();
1886
1887     case '1':
1888     case '2':
1889     case '<':
1890     case 'e':
1891       switch (TREE_CODE_LENGTH (code))
1892         {
1893         case 1:
1894           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1895           if (op0 == TREE_OPERAND (exp, 0))
1896             return exp;
1897
1898           if (code == NON_LVALUE_EXPR)
1899             return op0;
1900
1901           new = fold (build1 (code, TREE_TYPE (exp), op0));
1902           break;
1903
1904         case 2:
1905           /* An RTL_EXPR cannot contain a PLACEHOLDER_EXPR; a CONSTRUCTOR
1906              could, but we don't support it.  */
1907           if (code == RTL_EXPR)
1908             return exp;
1909           else if (code == CONSTRUCTOR)
1910             abort ();
1911
1912           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1913           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1914           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
1915             return exp;
1916
1917           new = fold (build (code, TREE_TYPE (exp), op0, op1));
1918           break;
1919
1920         case 3:
1921           /* It cannot be that anything inside a SAVE_EXPR contains a
1922              PLACEHOLDER_EXPR.  */
1923           if (code == SAVE_EXPR)
1924             return exp;
1925
1926           else if (code == CALL_EXPR)
1927             {
1928               op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1929               if (op1 == TREE_OPERAND (exp, 1))
1930                 return exp;
1931
1932               return build (code, TREE_TYPE (exp),
1933                             TREE_OPERAND (exp, 0), op1, NULL_TREE);
1934             }
1935
1936           else if (code != COND_EXPR)
1937             abort ();
1938
1939           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1940           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1941           op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
1942           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
1943               && op2 == TREE_OPERAND (exp, 2))
1944             return exp;
1945
1946           new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
1947           break;
1948
1949         default:
1950           abort ();
1951         }
1952
1953       break;
1954
1955     case 'r':
1956       switch (code)
1957         {
1958         case COMPONENT_REF:
1959           /* If this expression is getting a value from a PLACEHOLDER_EXPR
1960              and it is the right field, replace it with R.  */
1961           for (inner = TREE_OPERAND (exp, 0);
1962                TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
1963                inner = TREE_OPERAND (inner, 0))
1964             ;
1965           if (TREE_CODE (inner) == PLACEHOLDER_EXPR
1966               && TREE_OPERAND (exp, 1) == f)
1967             return r;
1968
1969           /* If this expression hasn't been completed let, leave it
1970              alone.  */
1971           if (TREE_CODE (inner) == PLACEHOLDER_EXPR
1972               && TREE_TYPE (inner) == 0)
1973             return exp;
1974
1975           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1976           if (op0 == TREE_OPERAND (exp, 0))
1977             return exp;
1978
1979           new = fold (build (code, TREE_TYPE (exp), op0,
1980                              TREE_OPERAND (exp, 1)));
1981           break;
1982
1983         case BIT_FIELD_REF:
1984           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1985           op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
1986           op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
1987           if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
1988               && op2 == TREE_OPERAND (exp, 2))
1989             return exp;
1990
1991           new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
1992           break;
1993
1994         case INDIRECT_REF:
1995         case BUFFER_REF:
1996           op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
1997           if (op0 == TREE_OPERAND (exp, 0))
1998             return exp;
1999
2000           new = fold (build1 (code, TREE_TYPE (exp), op0));
2001           break;
2002
2003         default:
2004           abort ();
2005         }
2006       break;
2007
2008     default:
2009       abort ();
2010     }
2011
2012   TREE_READONLY (new) = TREE_READONLY (exp);
2013   return new;
2014 }
2015 \f
2016 /* Stabilize a reference so that we can use it any number of times
2017    without causing its operands to be evaluated more than once.
2018    Returns the stabilized reference.  This works by means of save_expr,
2019    so see the caveats in the comments about save_expr.
2020
2021    Also allows conversion expressions whose operands are references.
2022    Any other kind of expression is returned unchanged.  */
2023
2024 tree
2025 stabilize_reference (ref)
2026      tree ref;
2027 {
2028   tree result;
2029   enum tree_code code = TREE_CODE (ref);
2030
2031   switch (code)
2032     {
2033     case VAR_DECL:
2034     case PARM_DECL:
2035     case RESULT_DECL:
2036       /* No action is needed in this case.  */
2037       return ref;
2038
2039     case NOP_EXPR:
2040     case CONVERT_EXPR:
2041     case FLOAT_EXPR:
2042     case FIX_TRUNC_EXPR:
2043     case FIX_FLOOR_EXPR:
2044     case FIX_ROUND_EXPR:
2045     case FIX_CEIL_EXPR:
2046       result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
2047       break;
2048
2049     case INDIRECT_REF:
2050       result = build_nt (INDIRECT_REF,
2051                          stabilize_reference_1 (TREE_OPERAND (ref, 0)));
2052       break;
2053
2054     case COMPONENT_REF:
2055       result = build_nt (COMPONENT_REF,
2056                          stabilize_reference (TREE_OPERAND (ref, 0)),
2057                          TREE_OPERAND (ref, 1));
2058       break;
2059
2060     case BIT_FIELD_REF:
2061       result = build_nt (BIT_FIELD_REF,
2062                          stabilize_reference (TREE_OPERAND (ref, 0)),
2063                          stabilize_reference_1 (TREE_OPERAND (ref, 1)),
2064                          stabilize_reference_1 (TREE_OPERAND (ref, 2)));
2065       break;
2066
2067     case ARRAY_REF:
2068       result = build_nt (ARRAY_REF,
2069                          stabilize_reference (TREE_OPERAND (ref, 0)),
2070                          stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2071       break;
2072
2073     case ARRAY_RANGE_REF:
2074       result = build_nt (ARRAY_RANGE_REF,
2075                          stabilize_reference (TREE_OPERAND (ref, 0)),
2076                          stabilize_reference_1 (TREE_OPERAND (ref, 1)));
2077       break;
2078
2079     case COMPOUND_EXPR:
2080       /* We cannot wrap the first expression in a SAVE_EXPR, as then
2081          it wouldn't be ignored.  This matters when dealing with
2082          volatiles.  */
2083       return stabilize_reference_1 (ref);
2084
2085     case RTL_EXPR:
2086       result = build1 (INDIRECT_REF, TREE_TYPE (ref),
2087                        save_expr (build1 (ADDR_EXPR,
2088                                           build_pointer_type (TREE_TYPE (ref)),
2089                                           ref)));
2090       break;
2091
2092       /* If arg isn't a kind of lvalue we recognize, make no change.
2093          Caller should recognize the error for an invalid lvalue.  */
2094     default:
2095       return ref;
2096
2097     case ERROR_MARK:
2098       return error_mark_node;
2099     }
2100
2101   TREE_TYPE (result) = TREE_TYPE (ref);
2102   TREE_READONLY (result) = TREE_READONLY (ref);
2103   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
2104   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
2105
2106   return result;
2107 }
2108
2109 /* Subroutine of stabilize_reference; this is called for subtrees of
2110    references.  Any expression with side-effects must be put in a SAVE_EXPR
2111    to ensure that it is only evaluated once.
2112
2113    We don't put SAVE_EXPR nodes around everything, because assigning very
2114    simple expressions to temporaries causes us to miss good opportunities
2115    for optimizations.  Among other things, the opportunity to fold in the
2116    addition of a constant into an addressing mode often gets lost, e.g.
2117    "y[i+1] += x;".  In general, we take the approach that we should not make
2118    an assignment unless we are forced into it - i.e., that any non-side effect
2119    operator should be allowed, and that cse should take care of coalescing
2120    multiple utterances of the same expression should that prove fruitful.  */
2121
2122 tree
2123 stabilize_reference_1 (e)
2124      tree e;
2125 {
2126   tree result;
2127   enum tree_code code = TREE_CODE (e);
2128
2129   /* We cannot ignore const expressions because it might be a reference
2130      to a const array but whose index contains side-effects.  But we can
2131      ignore things that are actual constant or that already have been
2132      handled by this function.  */
2133
2134   if (TREE_CONSTANT (e) || code == SAVE_EXPR)
2135     return e;
2136
2137   switch (TREE_CODE_CLASS (code))
2138     {
2139     case 'x':
2140     case 't':
2141     case 'd':
2142     case 'b':
2143     case '<':
2144     case 's':
2145     case 'e':
2146     case 'r':
2147       /* If the expression has side-effects, then encase it in a SAVE_EXPR
2148          so that it will only be evaluated once.  */
2149       /* The reference (r) and comparison (<) classes could be handled as
2150          below, but it is generally faster to only evaluate them once.  */
2151       if (TREE_SIDE_EFFECTS (e))
2152         return save_expr (e);
2153       return e;
2154
2155     case 'c':
2156       /* Constants need no processing.  In fact, we should never reach
2157          here.  */
2158       return e;
2159
2160     case '2':
2161       /* Division is slow and tends to be compiled with jumps,
2162          especially the division by powers of 2 that is often
2163          found inside of an array reference.  So do it just once.  */
2164       if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
2165           || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
2166           || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
2167           || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
2168         return save_expr (e);
2169       /* Recursively stabilize each operand.  */
2170       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
2171                          stabilize_reference_1 (TREE_OPERAND (e, 1)));
2172       break;
2173
2174     case '1':
2175       /* Recursively stabilize each operand.  */
2176       result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
2177       break;
2178
2179     default:
2180       abort ();
2181     }
2182
2183   TREE_TYPE (result) = TREE_TYPE (e);
2184   TREE_READONLY (result) = TREE_READONLY (e);
2185   TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
2186   TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
2187
2188   return result;
2189 }
2190 \f
2191 /* Low-level constructors for expressions.  */
2192
2193 /* Build an expression of code CODE, data type TYPE,
2194    and operands as specified by the arguments ARG1 and following arguments.
2195    Expressions and reference nodes can be created this way.
2196    Constants, decls, types and misc nodes cannot be.  */
2197
2198 tree
2199 build VPARAMS ((enum tree_code code, tree tt, ...))
2200 {
2201   tree t;
2202   int length;
2203   int i;
2204   int fro;
2205   int constant;
2206
2207   VA_OPEN (p, tt);
2208   VA_FIXEDARG (p, enum tree_code, code);
2209   VA_FIXEDARG (p, tree, tt);
2210
2211   t = make_node (code);
2212   length = TREE_CODE_LENGTH (code);
2213   TREE_TYPE (t) = tt;
2214
2215   /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
2216      result based on those same flags for the arguments.  But if the
2217      arguments aren't really even `tree' expressions, we shouldn't be trying
2218      to do this.  */
2219   fro = first_rtl_op (code);
2220
2221   /* Expressions without side effects may be constant if their
2222      arguments are as well.  */
2223   constant = (TREE_CODE_CLASS (code) == '<'
2224               || TREE_CODE_CLASS (code) == '1'
2225               || TREE_CODE_CLASS (code) == '2'
2226               || TREE_CODE_CLASS (code) == 'c');
2227
2228   if (length == 2)
2229     {
2230       /* This is equivalent to the loop below, but faster.  */
2231       tree arg0 = va_arg (p, tree);
2232       tree arg1 = va_arg (p, tree);
2233
2234       TREE_OPERAND (t, 0) = arg0;
2235       TREE_OPERAND (t, 1) = arg1;
2236       TREE_READONLY (t) = 1;
2237       if (arg0 && fro > 0)
2238         {
2239           if (TREE_SIDE_EFFECTS (arg0))
2240             TREE_SIDE_EFFECTS (t) = 1;
2241           if (!TREE_READONLY (arg0))
2242             TREE_READONLY (t) = 0;
2243           if (!TREE_CONSTANT (arg0))
2244             constant = 0;
2245         }
2246
2247       if (arg1 && fro > 1)
2248         {
2249           if (TREE_SIDE_EFFECTS (arg1))
2250             TREE_SIDE_EFFECTS (t) = 1;
2251           if (!TREE_READONLY (arg1))
2252             TREE_READONLY (t) = 0;
2253           if (!TREE_CONSTANT (arg1))
2254             constant = 0;
2255         }
2256     }
2257   else if (length == 1)
2258     {
2259       tree arg0 = va_arg (p, tree);
2260
2261       /* The only one-operand cases we handle here are those with side-effects.
2262          Others are handled with build1.  So don't bother checked if the
2263          arg has side-effects since we'll already have set it.
2264
2265          ??? This really should use build1 too.  */
2266       if (TREE_CODE_CLASS (code) != 's')
2267         abort ();
2268       TREE_OPERAND (t, 0) = arg0;
2269     }
2270   else
2271     {
2272       for (i = 0; i < length; i++)
2273         {
2274           tree operand = va_arg (p, tree);
2275
2276           TREE_OPERAND (t, i) = operand;
2277           if (operand && fro > i)
2278             {
2279               if (TREE_SIDE_EFFECTS (operand))
2280                 TREE_SIDE_EFFECTS (t) = 1;
2281               if (!TREE_CONSTANT (operand))
2282                 constant = 0;
2283             }
2284         }
2285     }
2286   VA_CLOSE (p);
2287
2288   TREE_CONSTANT (t) = constant;
2289   return t;
2290 }
2291
2292 /* Same as above, but only builds for unary operators.
2293    Saves lions share of calls to `build'; cuts down use
2294    of varargs, which is expensive for RISC machines.  */
2295
2296 tree
2297 build1 (code, type, node)
2298      enum tree_code code;
2299      tree type;
2300      tree node;
2301 {
2302   int length;
2303 #ifdef GATHER_STATISTICS
2304   tree_node_kind kind;
2305 #endif
2306   tree t;
2307
2308 #ifdef GATHER_STATISTICS
2309   if (TREE_CODE_CLASS (code) == 'r')
2310     kind = r_kind;
2311   else
2312     kind = e_kind;
2313 #endif
2314
2315 #ifdef ENABLE_CHECKING
2316   if (TREE_CODE_CLASS (code) == '2'
2317       || TREE_CODE_CLASS (code) == '<'
2318       || TREE_CODE_LENGTH (code) != 1)
2319     abort ();
2320 #endif /* ENABLE_CHECKING */
2321
2322   length = sizeof (struct tree_exp);
2323
2324   t = ggc_alloc_tree (length);
2325
2326   memset ((PTR) t, 0, sizeof (struct tree_common));
2327
2328 #ifdef GATHER_STATISTICS
2329   tree_node_counts[(int) kind]++;
2330   tree_node_sizes[(int) kind] += length;
2331 #endif
2332
2333   TREE_SET_CODE (t, code);
2334
2335   TREE_TYPE (t) = type;
2336   TREE_COMPLEXITY (t) = 0;
2337   TREE_OPERAND (t, 0) = node;
2338   if (node && first_rtl_op (code) != 0)
2339     {
2340       TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
2341       TREE_READONLY (t) = TREE_READONLY (node);
2342     }
2343
2344   switch (code)
2345     {
2346     case INIT_EXPR:
2347     case MODIFY_EXPR:
2348     case VA_ARG_EXPR:
2349     case RTL_EXPR:
2350     case PREDECREMENT_EXPR:
2351     case PREINCREMENT_EXPR:
2352     case POSTDECREMENT_EXPR:
2353     case POSTINCREMENT_EXPR:
2354       /* All of these have side-effects, no matter what their
2355          operands are.  */
2356       TREE_SIDE_EFFECTS (t) = 1;
2357       TREE_READONLY (t) = 0;
2358       break;
2359
2360     case INDIRECT_REF:
2361       /* Whether a dereference is readonly has nothing to do with whether
2362          its operand is readonly.  */
2363       TREE_READONLY (t) = 0;
2364       break;
2365
2366     default:
2367       if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
2368         TREE_CONSTANT (t) = 1;
2369       break;
2370     }
2371
2372   return t;
2373 }
2374
2375 /* Similar except don't specify the TREE_TYPE
2376    and leave the TREE_SIDE_EFFECTS as 0.
2377    It is permissible for arguments to be null,
2378    or even garbage if their values do not matter.  */
2379
2380 tree
2381 build_nt VPARAMS ((enum tree_code code, ...))
2382 {
2383   tree t;
2384   int length;
2385   int i;
2386
2387   VA_OPEN (p, code);
2388   VA_FIXEDARG (p, enum tree_code, code);
2389
2390   t = make_node (code);
2391   length = TREE_CODE_LENGTH (code);
2392
2393   for (i = 0; i < length; i++)
2394     TREE_OPERAND (t, i) = va_arg (p, tree);
2395
2396   VA_CLOSE (p);
2397   return t;
2398 }
2399 \f
2400 /* Create a DECL_... node of code CODE, name NAME and data type TYPE.
2401    We do NOT enter this node in any sort of symbol table.
2402
2403    layout_decl is used to set up the decl's storage layout.
2404    Other slots are initialized to 0 or null pointers.  */
2405
2406 tree
2407 build_decl (code, name, type)
2408      enum tree_code code;
2409      tree name, type;
2410 {
2411   tree t;
2412
2413   t = make_node (code);
2414
2415 /*  if (type == error_mark_node)
2416     type = integer_type_node; */
2417 /* That is not done, deliberately, so that having error_mark_node
2418    as the type can suppress useless errors in the use of this variable.  */
2419
2420   DECL_NAME (t) = name;
2421   TREE_TYPE (t) = type;
2422
2423   if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
2424     layout_decl (t, 0);
2425   else if (code == FUNCTION_DECL)
2426     DECL_MODE (t) = FUNCTION_MODE;
2427
2428   return t;
2429 }
2430 \f
2431 /* BLOCK nodes are used to represent the structure of binding contours
2432    and declarations, once those contours have been exited and their contents
2433    compiled.  This information is used for outputting debugging info.  */
2434
2435 tree
2436 build_block (vars, tags, subblocks, supercontext, chain)
2437      tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
2438 {
2439   tree block = make_node (BLOCK);
2440
2441   BLOCK_VARS (block) = vars;
2442   BLOCK_SUBBLOCKS (block) = subblocks;
2443   BLOCK_SUPERCONTEXT (block) = supercontext;
2444   BLOCK_CHAIN (block) = chain;
2445   return block;
2446 }
2447
2448 /* EXPR_WITH_FILE_LOCATION are used to keep track of the exact
2449    location where an expression or an identifier were encountered. It
2450    is necessary for languages where the frontend parser will handle
2451    recursively more than one file (Java is one of them).  */
2452
2453 tree
2454 build_expr_wfl (node, file, line, col)
2455      tree node;
2456      const char *file;
2457      int line, col;
2458 {
2459   static const char *last_file = 0;
2460   static tree last_filenode = NULL_TREE;
2461   tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
2462
2463   EXPR_WFL_NODE (wfl) = node;
2464   EXPR_WFL_SET_LINECOL (wfl, line, col);
2465   if (file != last_file)
2466     {
2467       last_file = file;
2468       last_filenode = file ? get_identifier (file) : NULL_TREE;
2469     }
2470
2471   EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
2472   if (node)
2473     {
2474       TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
2475       TREE_TYPE (wfl) = TREE_TYPE (node);
2476     }
2477
2478   return wfl;
2479 }
2480 \f
2481 /* Return a declaration like DDECL except that its DECL_ATTRIBUTES
2482    is ATTRIBUTE.  */
2483
2484 tree
2485 build_decl_attribute_variant (ddecl, attribute)
2486      tree ddecl, attribute;
2487 {
2488   DECL_ATTRIBUTES (ddecl) = attribute;
2489   return ddecl;
2490 }
2491
2492 /* Return a type like TTYPE except that its TYPE_ATTRIBUTE
2493    is ATTRIBUTE.
2494
2495    Record such modified types already made so we don't make duplicates.  */
2496
2497 tree
2498 build_type_attribute_variant (ttype, attribute)
2499      tree ttype, attribute;
2500 {
2501   if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
2502     {
2503       unsigned int hashcode;
2504       tree ntype;
2505
2506       ntype = copy_node (ttype);
2507
2508       TYPE_POINTER_TO (ntype) = 0;
2509       TYPE_REFERENCE_TO (ntype) = 0;
2510       TYPE_ATTRIBUTES (ntype) = attribute;
2511
2512       /* Create a new main variant of TYPE.  */
2513       TYPE_MAIN_VARIANT (ntype) = ntype;
2514       TYPE_NEXT_VARIANT (ntype) = 0;
2515       set_type_quals (ntype, TYPE_UNQUALIFIED);
2516
2517       hashcode = (TYPE_HASH (TREE_CODE (ntype))
2518                   + TYPE_HASH (TREE_TYPE (ntype))
2519                   + attribute_hash_list (attribute));
2520
2521       switch (TREE_CODE (ntype))
2522         {
2523         case FUNCTION_TYPE:
2524           hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
2525           break;
2526         case ARRAY_TYPE:
2527           hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
2528           break;
2529         case INTEGER_TYPE:
2530           hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
2531           break;
2532         case REAL_TYPE:
2533           hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
2534           break;
2535         default:
2536           break;
2537         }
2538
2539       ntype = type_hash_canon (hashcode, ntype);
2540       ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
2541     }
2542
2543   return ttype;
2544 }
2545
2546 /* Default registration of target-specific CPP built-ins.  */
2547 void
2548 default_register_cpp_builtins (pfile)
2549      struct cpp_reader *pfile ATTRIBUTE_UNUSED;
2550 {
2551 }
2552
2553 /* Default value of targetm.comp_type_attributes that always returns 1.  */
2554
2555 int
2556 default_comp_type_attributes (type1, type2)
2557      tree type1 ATTRIBUTE_UNUSED;
2558      tree type2 ATTRIBUTE_UNUSED;
2559 {
2560   return 1;
2561 }
2562
2563 /* Default version of targetm.set_default_type_attributes that always does
2564    nothing.  */
2565
2566 void
2567 default_set_default_type_attributes (type)
2568      tree type ATTRIBUTE_UNUSED;
2569 {
2570 }
2571
2572 /* Default version of targetm.insert_attributes that always does nothing.  */
2573 void
2574 default_insert_attributes (decl, attr_ptr)
2575      tree decl ATTRIBUTE_UNUSED;
2576      tree *attr_ptr ATTRIBUTE_UNUSED;
2577 {
2578 }
2579
2580 /* Default value of targetm.function_attribute_inlinable_p that always
2581    returns false.  */
2582 bool
2583 default_function_attribute_inlinable_p (fndecl)
2584      tree fndecl ATTRIBUTE_UNUSED;
2585 {
2586   /* By default, functions with machine attributes cannot be inlined.  */
2587   return false;
2588 }
2589
2590 /* Default value of targetm.ms_bitfield_layout_p that always returns
2591    false.  */
2592 bool
2593 default_ms_bitfield_layout_p (record)
2594      tree record ATTRIBUTE_UNUSED;
2595 {
2596   /* By default, GCC does not use the MS VC++ bitfield layout rules.  */
2597   return false;
2598 }
2599
2600 /* Return non-zero if IDENT is a valid name for attribute ATTR,
2601    or zero if not.
2602
2603    We try both `text' and `__text__', ATTR may be either one.  */
2604 /* ??? It might be a reasonable simplification to require ATTR to be only
2605    `text'.  One might then also require attribute lists to be stored in
2606    their canonicalized form.  */
2607
2608 int
2609 is_attribute_p (attr, ident)
2610      const char *attr;
2611      tree ident;
2612 {
2613   int ident_len, attr_len;
2614   const char *p;
2615
2616   if (TREE_CODE (ident) != IDENTIFIER_NODE)
2617     return 0;
2618
2619   if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
2620     return 1;
2621
2622   p = IDENTIFIER_POINTER (ident);
2623   ident_len = strlen (p);
2624   attr_len = strlen (attr);
2625
2626   /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
2627   if (attr[0] == '_')
2628     {
2629       if (attr[1] != '_'
2630           || attr[attr_len - 2] != '_'
2631           || attr[attr_len - 1] != '_')
2632         abort ();
2633       if (ident_len == attr_len - 4
2634           && strncmp (attr + 2, p, attr_len - 4) == 0)
2635         return 1;
2636     }
2637   else
2638     {
2639       if (ident_len == attr_len + 4
2640           && p[0] == '_' && p[1] == '_'
2641           && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
2642           && strncmp (attr, p + 2, attr_len) == 0)
2643         return 1;
2644     }
2645
2646   return 0;
2647 }
2648
2649 /* Given an attribute name and a list of attributes, return a pointer to the
2650    attribute's list element if the attribute is part of the list, or NULL_TREE
2651    if not found.  If the attribute appears more than once, this only
2652    returns the first occurrence; the TREE_CHAIN of the return value should
2653    be passed back in if further occurrences are wanted.  */
2654
2655 tree
2656 lookup_attribute (attr_name, list)
2657      const char *attr_name;
2658      tree list;
2659 {
2660   tree l;
2661
2662   for (l = list; l; l = TREE_CHAIN (l))
2663     {
2664       if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
2665         abort ();
2666       if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
2667         return l;
2668     }
2669
2670   return NULL_TREE;
2671 }
2672
2673 /* Return an attribute list that is the union of a1 and a2.  */
2674
2675 tree
2676 merge_attributes (a1, a2)
2677      tree a1, a2;
2678 {
2679   tree attributes;
2680
2681   /* Either one unset?  Take the set one.  */
2682
2683   if ((attributes = a1) == 0)
2684     attributes = a2;
2685
2686   /* One that completely contains the other?  Take it.  */
2687
2688   else if (a2 != 0 && ! attribute_list_contained (a1, a2))
2689     {
2690       if (attribute_list_contained (a2, a1))
2691         attributes = a2;
2692       else
2693         {
2694           /* Pick the longest list, and hang on the other list.  */
2695
2696           if (list_length (a1) < list_length (a2))
2697             attributes = a2, a2 = a1;
2698
2699           for (; a2 != 0; a2 = TREE_CHAIN (a2))
2700             {
2701               tree a;
2702               for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2703                                          attributes);
2704                    a != NULL_TREE;
2705                    a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
2706                                          TREE_CHAIN (a)))
2707                 {
2708                   if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
2709                     break;
2710                 }
2711               if (a == NULL_TREE)
2712                 {
2713                   a1 = copy_node (a2);
2714                   TREE_CHAIN (a1) = attributes;
2715                   attributes = a1;
2716                 }
2717             }
2718         }
2719     }
2720   return attributes;
2721 }
2722
2723 /* Given types T1 and T2, merge their attributes and return
2724   the result.  */
2725
2726 tree
2727 merge_type_attributes (t1, t2)
2728      tree t1, t2;
2729 {
2730   return merge_attributes (TYPE_ATTRIBUTES (t1),
2731                            TYPE_ATTRIBUTES (t2));
2732 }
2733
2734 /* Given decls OLDDECL and NEWDECL, merge their attributes and return
2735    the result.  */
2736
2737 tree
2738 merge_decl_attributes (olddecl, newdecl)
2739      tree olddecl, newdecl;
2740 {
2741   return merge_attributes (DECL_ATTRIBUTES (olddecl),
2742                            DECL_ATTRIBUTES (newdecl));
2743 }
2744
2745 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
2746
2747 /* Specialization of merge_decl_attributes for various Windows targets.
2748
2749    This handles the following situation:
2750
2751      __declspec (dllimport) int foo;
2752      int foo;
2753
2754    The second instance of `foo' nullifies the dllimport.  */
2755
2756 tree
2757 merge_dllimport_decl_attributes (old, new)
2758      tree old;
2759      tree new;
2760 {
2761   tree a;
2762   int delete_dllimport_p;
2763
2764   old = DECL_ATTRIBUTES (old);
2765   new = DECL_ATTRIBUTES (new);
2766
2767   /* What we need to do here is remove from `old' dllimport if it doesn't
2768      appear in `new'.  dllimport behaves like extern: if a declaration is
2769      marked dllimport and a definition appears later, then the object
2770      is not dllimport'd.  */
2771   if (lookup_attribute ("dllimport", old) != NULL_TREE
2772       && lookup_attribute ("dllimport", new) == NULL_TREE)
2773     delete_dllimport_p = 1;
2774   else
2775     delete_dllimport_p = 0;
2776
2777   a = merge_attributes (old, new);
2778
2779   if (delete_dllimport_p)
2780     {
2781       tree prev, t;
2782
2783       /* Scan the list for dllimport and delete it.  */
2784       for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
2785         {
2786           if (is_attribute_p ("dllimport", TREE_PURPOSE (t)))
2787             {
2788               if (prev == NULL_TREE)
2789                 a = TREE_CHAIN (a);
2790               else
2791                 TREE_CHAIN (prev) = TREE_CHAIN (t);
2792               break;
2793             }
2794         }
2795     }
2796
2797   return a;
2798 }
2799
2800 #endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
2801 \f
2802 /* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
2803    of the various TYPE_QUAL values.  */
2804
2805 static void
2806 set_type_quals (type, type_quals)
2807      tree type;
2808      int type_quals;
2809 {
2810   TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
2811   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
2812   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
2813 }
2814
2815 /* Return a version of the TYPE, qualified as indicated by the
2816    TYPE_QUALS, if one exists.  If no qualified version exists yet,
2817    return NULL_TREE.  */
2818
2819 tree
2820 get_qualified_type (type, type_quals)
2821      tree type;
2822      int type_quals;
2823 {
2824   tree t;
2825
2826   /* Search the chain of variants to see if there is already one there just
2827      like the one we need to have.  If so, use that existing one.  We must
2828      preserve the TYPE_NAME, since there is code that depends on this.  */
2829   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2830     if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type))
2831       return t;
2832
2833   return NULL_TREE;
2834 }
2835
2836 /* Like get_qualified_type, but creates the type if it does not
2837    exist.  This function never returns NULL_TREE.  */
2838
2839 tree
2840 build_qualified_type (type, type_quals)
2841      tree type;
2842      int type_quals;
2843 {
2844   tree t;
2845
2846   /* See if we already have the appropriate qualified variant.  */
2847   t = get_qualified_type (type, type_quals);
2848
2849   /* If not, build it.  */
2850   if (!t)
2851     {
2852       t = build_type_copy (type);
2853       set_type_quals (t, type_quals);
2854     }
2855
2856   return t;
2857 }
2858
2859 /* Create a new variant of TYPE, equivalent but distinct.
2860    This is so the caller can modify it.  */
2861
2862 tree
2863 build_type_copy (type)
2864      tree type;
2865 {
2866   tree t, m = TYPE_MAIN_VARIANT (type);
2867
2868   t = copy_node (type);
2869
2870   TYPE_POINTER_TO (t) = 0;
2871   TYPE_REFERENCE_TO (t) = 0;
2872
2873   /* Add this type to the chain of variants of TYPE.  */
2874   TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
2875   TYPE_NEXT_VARIANT (m) = t;
2876
2877   return t;
2878 }
2879 \f
2880 /* Hashing of types so that we don't make duplicates.
2881    The entry point is `type_hash_canon'.  */
2882
2883 /* Compute a hash code for a list of types (chain of TREE_LIST nodes
2884    with types in the TREE_VALUE slots), by adding the hash codes
2885    of the individual types.  */
2886
2887 unsigned int
2888 type_hash_list (list)
2889      tree list;
2890 {
2891   unsigned int hashcode;
2892   tree tail;
2893
2894   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
2895     hashcode += TYPE_HASH (TREE_VALUE (tail));
2896
2897   return hashcode;
2898 }
2899
2900 /* These are the Hashtable callback functions.  */
2901
2902 /* Returns true if the types are equal.  */
2903
2904 static int
2905 type_hash_eq (va, vb)
2906      const void *va;
2907      const void *vb;
2908 {
2909   const struct type_hash *a = va, *b = vb;
2910   if (a->hash == b->hash
2911       && TREE_CODE (a->type) == TREE_CODE (b->type)
2912       && TREE_TYPE (a->type) == TREE_TYPE (b->type)
2913       && attribute_list_equal (TYPE_ATTRIBUTES (a->type),
2914                                TYPE_ATTRIBUTES (b->type))
2915       && TYPE_ALIGN (a->type) == TYPE_ALIGN (b->type)
2916       && (TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
2917           || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
2918                                  TYPE_MAX_VALUE (b->type)))
2919       && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
2920           || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
2921                                  TYPE_MIN_VALUE (b->type)))
2922       /* Note that TYPE_DOMAIN is TYPE_ARG_TYPES for FUNCTION_TYPE.  */
2923       && (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
2924           || (TYPE_DOMAIN (a->type)
2925               && TREE_CODE (TYPE_DOMAIN (a->type)) == TREE_LIST
2926               && TYPE_DOMAIN (b->type)
2927               && TREE_CODE (TYPE_DOMAIN (b->type)) == TREE_LIST
2928               && type_list_equal (TYPE_DOMAIN (a->type),
2929                                   TYPE_DOMAIN (b->type)))))
2930     return 1;
2931   return 0;
2932 }
2933
2934 /* Return the cached hash value.  */
2935
2936 static unsigned int
2937 type_hash_hash (item)
2938      const void *item;
2939 {
2940   return ((const struct type_hash *) item)->hash;
2941 }
2942
2943 /* Look in the type hash table for a type isomorphic to TYPE.
2944    If one is found, return it.  Otherwise return 0.  */
2945
2946 tree
2947 type_hash_lookup (hashcode, type)
2948      unsigned int hashcode;
2949      tree type;
2950 {
2951   struct type_hash *h, in;
2952
2953   /* The TYPE_ALIGN field of a type is set by layout_type(), so we
2954      must call that routine before comparing TYPE_ALIGNs.  */
2955   layout_type (type);
2956
2957   in.hash = hashcode;
2958   in.type = type;
2959
2960   h = htab_find_with_hash (type_hash_table, &in, hashcode);
2961   if (h)
2962     return h->type;
2963   return NULL_TREE;
2964 }
2965
2966 /* Add an entry to the type-hash-table
2967    for a type TYPE whose hash code is HASHCODE.  */
2968
2969 void
2970 type_hash_add (hashcode, type)
2971      unsigned int hashcode;
2972      tree type;
2973 {
2974   struct type_hash *h;
2975   void **loc;
2976
2977   h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash));
2978   h->hash = hashcode;
2979   h->type = type;
2980   loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
2981   *(struct type_hash **) loc = h;
2982 }
2983
2984 /* Given TYPE, and HASHCODE its hash code, return the canonical
2985    object for an identical type if one already exists.
2986    Otherwise, return TYPE, and record it as the canonical object
2987    if it is a permanent object.
2988
2989    To use this function, first create a type of the sort you want.
2990    Then compute its hash code from the fields of the type that
2991    make it different from other similar types.
2992    Then call this function and use the value.
2993    This function frees the type you pass in if it is a duplicate.  */
2994
2995 /* Set to 1 to debug without canonicalization.  Never set by program.  */
2996 int debug_no_type_hash = 0;
2997
2998 tree
2999 type_hash_canon (hashcode, type)
3000      unsigned int hashcode;
3001      tree type;
3002 {
3003   tree t1;
3004
3005   if (debug_no_type_hash)
3006     return type;
3007
3008   /* See if the type is in the hash table already.  If so, return it.
3009      Otherwise, add the type.  */
3010   t1 = type_hash_lookup (hashcode, type);
3011   if (t1 != 0)
3012     {
3013 #ifdef GATHER_STATISTICS
3014       tree_node_counts[(int) t_kind]--;
3015       tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
3016 #endif
3017       return t1;
3018     }
3019   else
3020     {
3021       type_hash_add (hashcode, type);
3022       return type;
3023     }
3024 }
3025
3026 /* See if the data pointed to by the type hash table is marked.  We consider
3027    it marked if the type is marked or if a debug type number or symbol
3028    table entry has been made for the type.  This reduces the amount of
3029    debugging output and eliminates that dependency of the debug output on
3030    the number of garbage collections.  */
3031
3032 static int
3033 type_hash_marked_p (p)
3034      const void *p;
3035 {
3036   tree type = ((struct type_hash *) p)->type;
3037
3038   return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
3039 }
3040
3041 /* Mark the entry in the type hash table the type it points to is marked.
3042    Also mark the type in case we are considering this entry "marked" by
3043    virtue of TYPE_SYMTAB_POINTER being set.  */
3044
3045 static void
3046 type_hash_mark (p)
3047      const void *p;
3048 {
3049   ggc_mark (p);
3050   ggc_mark_tree (((struct type_hash *) p)->type);
3051 }
3052
3053 /* Mark the hashtable slot pointed to by ENTRY (which is really a
3054    `tree**') for GC.  */
3055
3056 static int
3057 mark_tree_hashtable_entry (entry, data)
3058      void **entry;
3059      void *data ATTRIBUTE_UNUSED;
3060 {
3061   ggc_mark_tree ((tree) *entry);
3062   return 1;
3063 }
3064
3065 /* Mark ARG (which is really a htab_t whose slots are trees) for
3066    GC.  */
3067
3068 void
3069 mark_tree_hashtable (arg)
3070      void *arg;
3071 {
3072   htab_t t = *(htab_t *) arg;
3073   htab_traverse (t, mark_tree_hashtable_entry, 0);
3074 }
3075
3076 static void
3077 print_type_hash_statistics ()
3078 {
3079   fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
3080            (long) htab_size (type_hash_table),
3081            (long) htab_elements (type_hash_table),
3082            htab_collisions (type_hash_table));
3083 }
3084
3085 /* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
3086    with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
3087    by adding the hash codes of the individual attributes.  */
3088
3089 unsigned int
3090 attribute_hash_list (list)
3091      tree list;
3092 {
3093   unsigned int hashcode;
3094   tree tail;
3095
3096   for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
3097     /* ??? Do we want to add in TREE_VALUE too? */
3098     hashcode += TYPE_HASH (TREE_PURPOSE (tail));
3099   return hashcode;
3100 }
3101
3102 /* Given two lists of attributes, return true if list l2 is
3103    equivalent to l1.  */
3104
3105 int
3106 attribute_list_equal (l1, l2)
3107      tree l1, l2;
3108 {
3109   return attribute_list_contained (l1, l2)
3110          && attribute_list_contained (l2, l1);
3111 }
3112
3113 /* Given two lists of attributes, return true if list L2 is
3114    completely contained within L1.  */
3115 /* ??? This would be faster if attribute names were stored in a canonicalized
3116    form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
3117    must be used to show these elements are equivalent (which they are).  */
3118 /* ??? It's not clear that attributes with arguments will always be handled
3119    correctly.  */
3120
3121 int
3122 attribute_list_contained (l1, l2)
3123      tree l1, l2;
3124 {
3125   tree t1, t2;
3126
3127   /* First check the obvious, maybe the lists are identical.  */
3128   if (l1 == l2)
3129     return 1;
3130
3131   /* Maybe the lists are similar.  */
3132   for (t1 = l1, t2 = l2;
3133        t1 != 0 && t2 != 0
3134         && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
3135         && TREE_VALUE (t1) == TREE_VALUE (t2);
3136        t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
3137
3138   /* Maybe the lists are equal.  */
3139   if (t1 == 0 && t2 == 0)
3140     return 1;
3141
3142   for (; t2 != 0; t2 = TREE_CHAIN (t2))
3143     {
3144       tree attr;
3145       for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
3146            attr != NULL_TREE;
3147            attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
3148                                     TREE_CHAIN (attr)))
3149         {
3150           if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
3151             break;
3152         }
3153
3154       if (attr == 0)
3155         return 0;
3156
3157       if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
3158         return 0;
3159     }
3160
3161   return 1;
3162 }
3163
3164 /* Given two lists of types
3165    (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
3166    return 1 if the lists contain the same types in the same order.
3167    Also, the TREE_PURPOSEs must match.  */
3168
3169 int
3170 type_list_equal (l1, l2)
3171      tree l1, l2;
3172 {
3173   tree t1, t2;
3174
3175   for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
3176     if (TREE_VALUE (t1) != TREE_VALUE (t2)
3177         || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
3178             && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
3179                   && (TREE_TYPE (TREE_PURPOSE (t1))
3180                       == TREE_TYPE (TREE_PURPOSE (t2))))))
3181       return 0;
3182
3183   return t1 == t2;
3184 }
3185
3186 /* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
3187    given by TYPE.  If the argument list accepts variable arguments,
3188    then this function counts only the ordinary arguments.  */
3189
3190 int
3191 type_num_arguments (type)
3192      tree type;
3193 {
3194   int i = 0;
3195   tree t;
3196
3197   for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
3198     /* If the function does not take a variable number of arguments,
3199        the last element in the list will have type `void'.  */
3200     if (VOID_TYPE_P (TREE_VALUE (t)))
3201       break;
3202     else
3203       ++i;
3204
3205   return i;
3206 }
3207
3208 /* Nonzero if integer constants T1 and T2
3209    represent the same constant value.  */
3210
3211 int
3212 tree_int_cst_equal (t1, t2)
3213      tree t1, t2;
3214 {
3215   if (t1 == t2)
3216     return 1;
3217
3218   if (t1 == 0 || t2 == 0)
3219     return 0;
3220
3221   if (TREE_CODE (t1) == INTEGER_CST
3222       && TREE_CODE (t2) == INTEGER_CST
3223       && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3224       && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
3225     return 1;
3226
3227   return 0;
3228 }
3229
3230 /* Nonzero if integer constants T1 and T2 represent values that satisfy <.
3231    The precise way of comparison depends on their data type.  */
3232
3233 int
3234 tree_int_cst_lt (t1, t2)
3235      tree t1, t2;
3236 {
3237   if (t1 == t2)
3238     return 0;
3239
3240   if (TREE_UNSIGNED (TREE_TYPE (t1)) != TREE_UNSIGNED (TREE_TYPE (t2)))
3241     {
3242       int t1_sgn = tree_int_cst_sgn (t1);
3243       int t2_sgn = tree_int_cst_sgn (t2);
3244
3245       if (t1_sgn < t2_sgn)
3246         return 1;
3247       else if (t1_sgn > t2_sgn)
3248         return 0;
3249       /* Otherwise, both are non-negative, so we compare them as
3250          unsigned just in case one of them would overflow a signed
3251          type.  */
3252     }
3253   else if (! TREE_UNSIGNED (TREE_TYPE (t1)))
3254     return INT_CST_LT (t1, t2);
3255
3256   return INT_CST_LT_UNSIGNED (t1, t2);
3257 }
3258
3259 /* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
3260
3261 int
3262 tree_int_cst_compare (t1, t2)
3263      tree t1;
3264      tree t2;
3265 {
3266   if (tree_int_cst_lt (t1, t2))
3267     return -1;
3268   else if (tree_int_cst_lt (t2, t1))
3269     return 1;
3270   else
3271     return 0;
3272 }
3273
3274 /* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
3275    the host.  If POS is zero, the value can be represented in a single
3276    HOST_WIDE_INT.  If POS is nonzero, the value must be positive and can
3277    be represented in a single unsigned HOST_WIDE_INT.  */
3278
3279 int
3280 host_integerp (t, pos)
3281      tree t;
3282      int pos;
3283 {
3284   return (TREE_CODE (t) == INTEGER_CST
3285           && ! TREE_OVERFLOW (t)
3286           && ((TREE_INT_CST_HIGH (t) == 0
3287                && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
3288               || (! pos && TREE_INT_CST_HIGH (t) == -1
3289                   && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
3290                   && ! TREE_UNSIGNED (TREE_TYPE (t)))
3291               || (pos && TREE_INT_CST_HIGH (t) == 0)));
3292 }
3293
3294 /* Return the HOST_WIDE_INT least significant bits of T if it is an
3295    INTEGER_CST and there is no overflow.  POS is nonzero if the result must
3296    be positive.  Abort if we cannot satisfy the above conditions.  */
3297
3298 HOST_WIDE_INT
3299 tree_low_cst (t, pos)
3300      tree t;
3301      int pos;
3302 {
3303   if (host_integerp (t, pos))
3304     return TREE_INT_CST_LOW (t);
3305   else
3306     abort ();
3307 }
3308
3309 /* Return the most significant bit of the integer constant T.  */
3310
3311 int
3312 tree_int_cst_msb (t)
3313      tree t;
3314 {
3315   int prec;
3316   HOST_WIDE_INT h;
3317   unsigned HOST_WIDE_INT l;
3318
3319   /* Note that using TYPE_PRECISION here is wrong.  We care about the
3320      actual bits, not the (arbitrary) range of the type.  */
3321   prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
3322   rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
3323                  2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
3324   return (l & 1) == 1;
3325 }
3326
3327 /* Return an indication of the sign of the integer constant T.
3328    The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
3329    Note that -1 will never be returned it T's type is unsigned.  */
3330
3331 int
3332 tree_int_cst_sgn (t)
3333      tree t;
3334 {
3335   if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
3336     return 0;
3337   else if (TREE_UNSIGNED (TREE_TYPE (t)))
3338     return 1;
3339   else if (TREE_INT_CST_HIGH (t) < 0)
3340     return -1;
3341   else
3342     return 1;
3343 }
3344
3345 /* Compare two constructor-element-type constants.  Return 1 if the lists
3346    are known to be equal; otherwise return 0.  */
3347
3348 int
3349 simple_cst_list_equal (l1, l2)
3350      tree l1, l2;
3351 {
3352   while (l1 != NULL_TREE && l2 != NULL_TREE)
3353     {
3354       if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
3355         return 0;
3356
3357       l1 = TREE_CHAIN (l1);
3358       l2 = TREE_CHAIN (l2);
3359     }
3360
3361   return l1 == l2;
3362 }
3363
3364 /* Return truthvalue of whether T1 is the same tree structure as T2.
3365    Return 1 if they are the same.
3366    Return 0 if they are understandably different.
3367    Return -1 if either contains tree structure not understood by
3368    this function.  */
3369
3370 int
3371 simple_cst_equal (t1, t2)
3372      tree t1, t2;
3373 {
3374   enum tree_code code1, code2;
3375   int cmp;
3376   int i;
3377
3378   if (t1 == t2)
3379     return 1;
3380   if (t1 == 0 || t2 == 0)
3381     return 0;
3382
3383   code1 = TREE_CODE (t1);
3384   code2 = TREE_CODE (t2);
3385
3386   if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
3387     {
3388       if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3389           || code2 == NON_LVALUE_EXPR)
3390         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3391       else
3392         return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
3393     }
3394
3395   else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
3396            || code2 == NON_LVALUE_EXPR)
3397     return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
3398
3399   if (code1 != code2)
3400     return 0;
3401
3402   switch (code1)
3403     {
3404     case INTEGER_CST:
3405       return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
3406               && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
3407
3408     case REAL_CST:
3409       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3410
3411     case STRING_CST:
3412       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3413               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3414                          TREE_STRING_LENGTH (t1)));
3415
3416     case CONSTRUCTOR:
3417       if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
3418         return 1;
3419       else
3420         abort ();
3421
3422     case SAVE_EXPR:
3423       return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3424
3425     case CALL_EXPR:
3426       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3427       if (cmp <= 0)
3428         return cmp;
3429       return
3430         simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3431
3432     case TARGET_EXPR:
3433       /* Special case: if either target is an unallocated VAR_DECL,
3434          it means that it's going to be unified with whatever the
3435          TARGET_EXPR is really supposed to initialize, so treat it
3436          as being equivalent to anything.  */
3437       if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
3438            && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
3439            && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
3440           || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
3441               && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
3442               && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
3443         cmp = 1;
3444       else
3445         cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3446
3447       if (cmp <= 0)
3448         return cmp;
3449
3450       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
3451
3452     case WITH_CLEANUP_EXPR:
3453       cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3454       if (cmp <= 0)
3455         return cmp;
3456
3457       return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
3458
3459     case COMPONENT_REF:
3460       if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
3461         return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3462
3463       return 0;
3464
3465     case VAR_DECL:
3466     case PARM_DECL:
3467     case CONST_DECL:
3468     case FUNCTION_DECL:
3469       return 0;
3470
3471     default:
3472       break;
3473     }
3474
3475   /* This general rule works for most tree codes.  All exceptions should be
3476      handled above.  If this is a language-specific tree code, we can't
3477      trust what might be in the operand, so say we don't know
3478      the situation.  */
3479   if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
3480     return -1;
3481
3482   switch (TREE_CODE_CLASS (code1))
3483     {
3484     case '1':
3485     case '2':
3486     case '<':
3487     case 'e':
3488     case 'r':
3489     case 's':
3490       cmp = 1;
3491       for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
3492         {
3493           cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
3494           if (cmp <= 0)
3495             return cmp;
3496         }
3497
3498       return cmp;
3499
3500     default:
3501       return -1;
3502     }
3503 }
3504
3505 /* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
3506    Return -1, 0, or 1 if the value of T is less than, equal to, or greater
3507    than U, respectively.  */
3508
3509 int
3510 compare_tree_int (t, u)
3511      tree t;
3512      unsigned HOST_WIDE_INT u;
3513 {
3514   if (tree_int_cst_sgn (t) < 0)
3515     return -1;
3516   else if (TREE_INT_CST_HIGH (t) != 0)
3517     return 1;
3518   else if (TREE_INT_CST_LOW (t) == u)
3519     return 0;
3520   else if (TREE_INT_CST_LOW (t) < u)
3521     return -1;
3522   else
3523     return 1;
3524 }
3525 \f
3526 /* Constructors for pointer, array and function types.
3527    (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
3528    constructed by language-dependent code, not here.)  */
3529
3530 /* Construct, lay out and return the type of pointers to TO_TYPE.
3531    If such a type has already been constructed, reuse it.  */
3532
3533 tree
3534 build_pointer_type (to_type)
3535      tree to_type;
3536 {
3537   tree t = TYPE_POINTER_TO (to_type);
3538
3539   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
3540
3541   if (t != 0)
3542     return t;
3543
3544   /* We need a new one.  */
3545   t = make_node (POINTER_TYPE);
3546
3547   TREE_TYPE (t) = to_type;
3548
3549   /* Record this type as the pointer to TO_TYPE.  */
3550   TYPE_POINTER_TO (to_type) = t;
3551
3552   /* Lay out the type.  This function has many callers that are concerned
3553      with expression-construction, and this simplifies them all.
3554      Also, it guarantees the TYPE_SIZE is in the same obstack as the type.  */
3555   layout_type (t);
3556
3557   return t;
3558 }
3559
3560 /* Build the node for the type of references-to-TO_TYPE.  */
3561
3562 tree
3563 build_reference_type (to_type)
3564      tree to_type;
3565 {
3566   tree t = TYPE_REFERENCE_TO (to_type);
3567
3568   /* First, if we already have a type for pointers to TO_TYPE, use it.  */
3569
3570   if (t)
3571     return t;
3572
3573   /* We need a new one.  */
3574   t = make_node (REFERENCE_TYPE);
3575
3576   TREE_TYPE (t) = to_type;
3577
3578   /* Record this type as the pointer to TO_TYPE.  */
3579   TYPE_REFERENCE_TO (to_type) = t;
3580
3581   layout_type (t);
3582
3583   return t;
3584 }
3585
3586 /* Build a type that is compatible with t but has no cv quals anywhere
3587    in its type, thus
3588
3589    const char *const *const *  ->  char ***.  */
3590
3591 tree
3592 build_type_no_quals (t)
3593      tree t;
3594 {
3595   switch (TREE_CODE (t))
3596     {
3597     case POINTER_TYPE:
3598       return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
3599     case REFERENCE_TYPE:
3600       return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
3601     default:
3602       return TYPE_MAIN_VARIANT (t);
3603     }
3604 }
3605
3606 /* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
3607    MAXVAL should be the maximum value in the domain
3608    (one less than the length of the array).
3609
3610    The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
3611    We don't enforce this limit, that is up to caller (e.g. language front end).
3612    The limit exists because the result is a signed type and we don't handle
3613    sizes that use more than one HOST_WIDE_INT.  */
3614
3615 tree
3616 build_index_type (maxval)
3617      tree maxval;
3618 {
3619   tree itype = make_node (INTEGER_TYPE);
3620
3621   TREE_TYPE (itype) = sizetype;
3622   TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
3623   TYPE_MIN_VALUE (itype) = size_zero_node;
3624   TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
3625   TYPE_MODE (itype) = TYPE_MODE (sizetype);
3626   TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
3627   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
3628   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
3629   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
3630
3631   if (host_integerp (maxval, 1))
3632     return type_hash_canon (tree_low_cst (maxval, 1), itype);
3633   else
3634     return itype;
3635 }
3636
3637 /* Create a range of some discrete type TYPE (an INTEGER_TYPE,
3638    ENUMERAL_TYPE, BOOLEAN_TYPE, or CHAR_TYPE), with
3639    low bound LOWVAL and high bound HIGHVAL.
3640    if TYPE==NULL_TREE, sizetype is used.  */
3641
3642 tree
3643 build_range_type (type, lowval, highval)
3644      tree type, lowval, highval;
3645 {
3646   tree itype = make_node (INTEGER_TYPE);
3647
3648   TREE_TYPE (itype) = type;
3649   if (type == NULL_TREE)
3650     type = sizetype;
3651
3652   TYPE_MIN_VALUE (itype) = convert (type, lowval);
3653   TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
3654
3655   TYPE_PRECISION (itype) = TYPE_PRECISION (type);
3656   TYPE_MODE (itype) = TYPE_MODE (type);
3657   TYPE_SIZE (itype) = TYPE_SIZE (type);
3658   TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
3659   TYPE_ALIGN (itype) = TYPE_ALIGN (type);
3660   TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
3661
3662   if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
3663     return type_hash_canon (tree_low_cst (highval, 0)
3664                             - tree_low_cst (lowval, 0),
3665                             itype);
3666   else
3667     return itype;
3668 }
3669
3670 /* Just like build_index_type, but takes lowval and highval instead
3671    of just highval (maxval).  */
3672
3673 tree
3674 build_index_2_type (lowval, highval)
3675      tree lowval, highval;
3676 {
3677   return build_range_type (sizetype, lowval, highval);
3678 }
3679
3680 /* Return nonzero iff ITYPE1 and ITYPE2 are equal (in the LISP sense).
3681    Needed because when index types are not hashed, equal index types
3682    built at different times appear distinct, even though structurally,
3683    they are not.  */
3684
3685 int
3686 index_type_equal (itype1, itype2)
3687      tree itype1, itype2;
3688 {
3689   if (TREE_CODE (itype1) != TREE_CODE (itype2))
3690     return 0;
3691
3692   if (TREE_CODE (itype1) == INTEGER_TYPE)
3693     {
3694       if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
3695           || TYPE_MODE (itype1) != TYPE_MODE (itype2)
3696           || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
3697           || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
3698         return 0;
3699
3700       if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
3701                                  TYPE_MIN_VALUE (itype2))
3702           && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
3703                                     TYPE_MAX_VALUE (itype2)))
3704         return 1;
3705     }
3706
3707   return 0;
3708 }
3709
3710 /* Construct, lay out and return the type of arrays of elements with ELT_TYPE
3711    and number of elements specified by the range of values of INDEX_TYPE.
3712    If such a type has already been constructed, reuse it.  */
3713
3714 tree
3715 build_array_type (elt_type, index_type)
3716      tree elt_type, index_type;
3717 {
3718   tree t;
3719   unsigned int hashcode;
3720
3721   if (TREE_CODE (elt_type) == FUNCTION_TYPE)
3722     {
3723       error ("arrays of functions are not meaningful");
3724       elt_type = integer_type_node;
3725     }
3726
3727   /* Make sure TYPE_POINTER_TO (elt_type) is filled in.  */
3728   build_pointer_type (elt_type);
3729
3730   /* Allocate the array after the pointer type,
3731      in case we free it in type_hash_canon.  */
3732   t = make_node (ARRAY_TYPE);
3733   TREE_TYPE (t) = elt_type;
3734   TYPE_DOMAIN (t) = index_type;
3735
3736   if (index_type == 0)
3737     {
3738       return t;
3739     }
3740
3741   hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
3742   t = type_hash_canon (hashcode, t);
3743
3744   if (!COMPLETE_TYPE_P (t))
3745     layout_type (t);
3746   return t;
3747 }
3748
3749 /* Return the TYPE of the elements comprising
3750    the innermost dimension of ARRAY.  */
3751
3752 tree
3753 get_inner_array_type (array)
3754      tree array;
3755 {
3756   tree type = TREE_TYPE (array);
3757
3758   while (TREE_CODE (type) == ARRAY_TYPE)
3759     type = TREE_TYPE (type);
3760
3761   return type;
3762 }
3763
3764 /* Construct, lay out and return
3765    the type of functions returning type VALUE_TYPE
3766    given arguments of types ARG_TYPES.
3767    ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
3768    are data type nodes for the arguments of the function.
3769    If such a type has already been constructed, reuse it.  */
3770
3771 tree
3772 build_function_type (value_type, arg_types)
3773      tree value_type, arg_types;
3774 {
3775   tree t;
3776   unsigned int hashcode;
3777
3778   if (TREE_CODE (value_type) == FUNCTION_TYPE)
3779     {
3780       error ("function return type cannot be function");
3781       value_type = integer_type_node;
3782     }
3783
3784   /* Make a node of the sort we want.  */
3785   t = make_node (FUNCTION_TYPE);
3786   TREE_TYPE (t) = value_type;
3787   TYPE_ARG_TYPES (t) = arg_types;
3788
3789   /* If we already have such a type, use the old one and free this one.  */
3790   hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
3791   t = type_hash_canon (hashcode, t);
3792
3793   if (!COMPLETE_TYPE_P (t))
3794     layout_type (t);
3795   return t;
3796 }
3797
3798 /* Construct, lay out and return the type of methods belonging to class
3799    BASETYPE and whose arguments and values are described by TYPE.
3800    If that type exists already, reuse it.
3801    TYPE must be a FUNCTION_TYPE node.  */
3802
3803 tree
3804 build_method_type (basetype, type)
3805      tree basetype, type;
3806 {
3807   tree t;
3808   unsigned int hashcode;
3809
3810   /* Make a node of the sort we want.  */
3811   t = make_node (METHOD_TYPE);
3812
3813   if (TREE_CODE (type) != FUNCTION_TYPE)
3814     abort ();
3815
3816   TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3817   TREE_TYPE (t) = TREE_TYPE (type);
3818
3819   /* The actual arglist for this function includes a "hidden" argument
3820      which is "this".  Put it into the list of argument types.  */
3821
3822   TYPE_ARG_TYPES (t)
3823     = tree_cons (NULL_TREE,
3824                  build_pointer_type (basetype), TYPE_ARG_TYPES (type));
3825
3826   /* If we already have such a type, use the old one and free this one.  */
3827   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3828   t = type_hash_canon (hashcode, t);
3829
3830   if (!COMPLETE_TYPE_P (t))
3831     layout_type (t);
3832
3833   return t;
3834 }
3835
3836 /* Construct, lay out and return the type of offsets to a value
3837    of type TYPE, within an object of type BASETYPE.
3838    If a suitable offset type exists already, reuse it.  */
3839
3840 tree
3841 build_offset_type (basetype, type)
3842      tree basetype, type;
3843 {
3844   tree t;
3845   unsigned int hashcode;
3846
3847   /* Make a node of the sort we want.  */
3848   t = make_node (OFFSET_TYPE);
3849
3850   TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
3851   TREE_TYPE (t) = type;
3852
3853   /* If we already have such a type, use the old one and free this one.  */
3854   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
3855   t = type_hash_canon (hashcode, t);
3856
3857   if (!COMPLETE_TYPE_P (t))
3858     layout_type (t);
3859
3860   return t;
3861 }
3862
3863 /* Create a complex type whose components are COMPONENT_TYPE.  */
3864
3865 tree
3866 build_complex_type (component_type)
3867      tree component_type;
3868 {
3869   tree t;
3870   unsigned int hashcode;
3871
3872   /* Make a node of the sort we want.  */
3873   t = make_node (COMPLEX_TYPE);
3874
3875   TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
3876   set_type_quals (t, TYPE_QUALS (component_type));
3877
3878   /* If we already have such a type, use the old one and free this one.  */
3879   hashcode = TYPE_HASH (component_type);
3880   t = type_hash_canon (hashcode, t);
3881
3882   if (!COMPLETE_TYPE_P (t))
3883     layout_type (t);
3884
3885   /* If we are writing Dwarf2 output we need to create a name,
3886      since complex is a fundamental type.  */
3887   if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
3888       && ! TYPE_NAME (t))
3889     {
3890       const char *name;
3891       if (component_type == char_type_node)
3892         name = "complex char";
3893       else if (component_type == signed_char_type_node)
3894         name = "complex signed char";
3895       else if (component_type == unsigned_char_type_node)
3896         name = "complex unsigned char";
3897       else if (component_type == short_integer_type_node)
3898         name = "complex short int";
3899       else if (component_type == short_unsigned_type_node)
3900         name = "complex short unsigned int";
3901       else if (component_type == integer_type_node)
3902         name = "complex int";
3903       else if (component_type == unsigned_type_node)
3904         name = "complex unsigned int";
3905       else if (component_type == long_integer_type_node)
3906         name = "complex long int";
3907       else if (component_type == long_unsigned_type_node)
3908         name = "complex long unsigned int";
3909       else if (component_type == long_long_integer_type_node)
3910         name = "complex long long int";
3911       else if (component_type == long_long_unsigned_type_node)
3912         name = "complex long long unsigned int";
3913       else
3914         name = 0;
3915
3916       if (name != 0)
3917         TYPE_NAME (t) = get_identifier (name);
3918     }
3919
3920   return t;
3921 }
3922 \f
3923 /* Return OP, stripped of any conversions to wider types as much as is safe.
3924    Converting the value back to OP's type makes a value equivalent to OP.
3925
3926    If FOR_TYPE is nonzero, we return a value which, if converted to
3927    type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
3928
3929    If FOR_TYPE is nonzero, unaligned bit-field references may be changed to the
3930    narrowest type that can hold the value, even if they don't exactly fit.
3931    Otherwise, bit-field references are changed to a narrower type
3932    only if they can be fetched directly from memory in that type.
3933
3934    OP must have integer, real or enumeral type.  Pointers are not allowed!
3935
3936    There are some cases where the obvious value we could return
3937    would regenerate to OP if converted to OP's type,
3938    but would not extend like OP to wider types.
3939    If FOR_TYPE indicates such extension is contemplated, we eschew such values.
3940    For example, if OP is (unsigned short)(signed char)-1,
3941    we avoid returning (signed char)-1 if FOR_TYPE is int,
3942    even though extending that to an unsigned short would regenerate OP,
3943    since the result of extending (signed char)-1 to (int)
3944    is different from (int) OP.  */
3945
3946 tree
3947 get_unwidened (op, for_type)
3948      tree op;
3949      tree for_type;
3950 {
3951   /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
3952   tree type = TREE_TYPE (op);
3953   unsigned final_prec
3954     = TYPE_PRECISION (for_type != 0 ? for_type : type);
3955   int uns
3956     = (for_type != 0 && for_type != type
3957        && final_prec > TYPE_PRECISION (type)
3958        && TREE_UNSIGNED (type));
3959   tree win = op;
3960
3961   while (TREE_CODE (op) == NOP_EXPR)
3962     {
3963       int bitschange
3964         = TYPE_PRECISION (TREE_TYPE (op))
3965           - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
3966
3967       /* Truncations are many-one so cannot be removed.
3968          Unless we are later going to truncate down even farther.  */
3969       if (bitschange < 0
3970           && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
3971         break;
3972
3973       /* See what's inside this conversion.  If we decide to strip it,
3974          we will set WIN.  */
3975       op = TREE_OPERAND (op, 0);
3976
3977       /* If we have not stripped any zero-extensions (uns is 0),
3978          we can strip any kind of extension.
3979          If we have previously stripped a zero-extension,
3980          only zero-extensions can safely be stripped.
3981          Any extension can be stripped if the bits it would produce
3982          are all going to be discarded later by truncating to FOR_TYPE.  */
3983
3984       if (bitschange > 0)
3985         {
3986           if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
3987             win = op;
3988           /* TREE_UNSIGNED says whether this is a zero-extension.
3989              Let's avoid computing it if it does not affect WIN
3990              and if UNS will not be needed again.  */
3991           if ((uns || TREE_CODE (op) == NOP_EXPR)
3992               && TREE_UNSIGNED (TREE_TYPE (op)))
3993             {
3994               uns = 1;
3995               win = op;
3996             }
3997         }
3998     }
3999
4000   if (TREE_CODE (op) == COMPONENT_REF
4001       /* Since type_for_size always gives an integer type.  */
4002       && TREE_CODE (type) != REAL_TYPE
4003       /* Don't crash if field not laid out yet.  */
4004       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
4005       && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
4006     {
4007       unsigned int innerprec
4008         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4009       int unsignedp = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4010       type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp);
4011
4012       /* We can get this structure field in the narrowest type it fits in.
4013          If FOR_TYPE is 0, do this only for a field that matches the
4014          narrower type exactly and is aligned for it
4015          The resulting extension to its nominal type (a fullword type)
4016          must fit the same conditions as for other extensions.  */
4017
4018       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4019           && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
4020           && (! uns || final_prec <= innerprec || unsignedp)
4021           && type != 0)
4022         {
4023           win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4024                        TREE_OPERAND (op, 1));
4025           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4026           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4027         }
4028     }
4029
4030   return win;
4031 }
4032 \f
4033 /* Return OP or a simpler expression for a narrower value
4034    which can be sign-extended or zero-extended to give back OP.
4035    Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
4036    or 0 if the value should be sign-extended.  */
4037
4038 tree
4039 get_narrower (op, unsignedp_ptr)
4040      tree op;
4041      int *unsignedp_ptr;
4042 {
4043   int uns = 0;
4044   int first = 1;
4045   tree win = op;
4046
4047   while (TREE_CODE (op) == NOP_EXPR)
4048     {
4049       int bitschange
4050         = (TYPE_PRECISION (TREE_TYPE (op))
4051            - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
4052
4053       /* Truncations are many-one so cannot be removed.  */
4054       if (bitschange < 0)
4055         break;
4056
4057       /* See what's inside this conversion.  If we decide to strip it,
4058          we will set WIN.  */
4059       op = TREE_OPERAND (op, 0);
4060
4061       if (bitschange > 0)
4062         {
4063           /* An extension: the outermost one can be stripped,
4064              but remember whether it is zero or sign extension.  */
4065           if (first)
4066             uns = TREE_UNSIGNED (TREE_TYPE (op));
4067           /* Otherwise, if a sign extension has been stripped,
4068              only sign extensions can now be stripped;
4069              if a zero extension has been stripped, only zero-extensions.  */
4070           else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
4071             break;
4072           first = 0;
4073         }
4074       else /* bitschange == 0 */
4075         {
4076           /* A change in nominal type can always be stripped, but we must
4077              preserve the unsignedness.  */
4078           if (first)
4079             uns = TREE_UNSIGNED (TREE_TYPE (op));
4080           first = 0;
4081         }
4082
4083       win = op;
4084     }
4085
4086   if (TREE_CODE (op) == COMPONENT_REF
4087       /* Since type_for_size always gives an integer type.  */
4088       && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
4089       /* Ensure field is laid out already.  */
4090       && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
4091     {
4092       unsigned HOST_WIDE_INT innerprec
4093         = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
4094       tree type = (*lang_hooks.types.type_for_size) (innerprec,
4095                                                      TREE_UNSIGNED (op));
4096
4097       /* We can get this structure field in a narrower type that fits it,
4098          but the resulting extension to its nominal type (a fullword type)
4099          must satisfy the same conditions as for other extensions.
4100
4101          Do this only for fields that are aligned (not bit-fields),
4102          because when bit-field insns will be used there is no
4103          advantage in doing this.  */
4104
4105       if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
4106           && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
4107           && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
4108           && type != 0)
4109         {
4110           if (first)
4111             uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
4112           win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
4113                        TREE_OPERAND (op, 1));
4114           TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
4115           TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
4116         }
4117     }
4118   *unsignedp_ptr = uns;
4119   return win;
4120 }
4121 \f
4122 /* Nonzero if integer constant C has a value that is permissible
4123    for type TYPE (an INTEGER_TYPE).  */
4124
4125 int
4126 int_fits_type_p (c, type)
4127      tree c, type;
4128 {
4129   /* If the bounds of the type are integers, we can check ourselves.
4130      If not, but this type is a subtype, try checking against that.
4131      Otherwise, use force_fit_type, which checks against the precision.  */
4132   if (TYPE_MAX_VALUE (type) != NULL_TREE
4133       && TYPE_MIN_VALUE (type) != NULL_TREE
4134       && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
4135       && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
4136     {
4137       if (TREE_UNSIGNED (type))
4138         return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
4139                 && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))
4140                 /* Negative ints never fit unsigned types.  */
4141                 && ! (TREE_INT_CST_HIGH (c) < 0
4142                       && ! TREE_UNSIGNED (TREE_TYPE (c))));
4143       else
4144         return (! INT_CST_LT (TYPE_MAX_VALUE (type), c)
4145                 && ! INT_CST_LT (c, TYPE_MIN_VALUE (type))
4146                 /* Unsigned ints with top bit set never fit signed types.  */
4147                 && ! (TREE_INT_CST_HIGH (c) < 0
4148                       && TREE_UNSIGNED (TREE_TYPE (c))));
4149     }
4150   else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0)
4151     return int_fits_type_p (c, TREE_TYPE (type));
4152   else
4153     {
4154       c = copy_node (c);
4155       TREE_TYPE (c) = type;
4156       return !force_fit_type (c, 0);
4157     }
4158 }
4159
4160 /* Given a DECL or TYPE, return the scope in which it was declared, or
4161    NULL_TREE if there is no containing scope.  */
4162
4163 tree
4164 get_containing_scope (t)
4165      tree t;
4166 {
4167   return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
4168 }
4169
4170 /* Return the innermost context enclosing DECL that is
4171    a FUNCTION_DECL, or zero if none.  */
4172
4173 tree
4174 decl_function_context (decl)
4175      tree decl;
4176 {
4177   tree context;
4178
4179   if (TREE_CODE (decl) == ERROR_MARK)
4180     return 0;
4181
4182   if (TREE_CODE (decl) == SAVE_EXPR)
4183     context = SAVE_EXPR_CONTEXT (decl);
4184
4185   /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
4186      where we look up the function at runtime.  Such functions always take
4187      a first argument of type 'pointer to real context'.
4188
4189      C++ should really be fixed to use DECL_CONTEXT for the real context,
4190      and use something else for the "virtual context".  */
4191   else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
4192     context
4193       = TYPE_MAIN_VARIANT
4194         (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4195   else
4196     context = DECL_CONTEXT (decl);
4197
4198   while (context && TREE_CODE (context) != FUNCTION_DECL)
4199     {
4200       if (TREE_CODE (context) == BLOCK)
4201         context = BLOCK_SUPERCONTEXT (context);
4202       else
4203         context = get_containing_scope (context);
4204     }
4205
4206   return context;
4207 }
4208
4209 /* Return the innermost context enclosing DECL that is
4210    a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
4211    TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
4212
4213 tree
4214 decl_type_context (decl)
4215      tree decl;
4216 {
4217   tree context = DECL_CONTEXT (decl);
4218
4219   while (context)
4220     {
4221       if (TREE_CODE (context) == RECORD_TYPE
4222           || TREE_CODE (context) == UNION_TYPE
4223           || TREE_CODE (context) == QUAL_UNION_TYPE)
4224         return context;
4225
4226       if (TREE_CODE (context) == TYPE_DECL
4227           || TREE_CODE (context) == FUNCTION_DECL)
4228         context = DECL_CONTEXT (context);
4229
4230       else if (TREE_CODE (context) == BLOCK)
4231         context = BLOCK_SUPERCONTEXT (context);
4232
4233       else
4234         /* Unhandled CONTEXT!?  */
4235         abort ();
4236     }
4237   return NULL_TREE;
4238 }
4239
4240 /* CALL is a CALL_EXPR.  Return the declaration for the function
4241    called, or NULL_TREE if the called function cannot be
4242    determined.  */
4243
4244 tree
4245 get_callee_fndecl (call)
4246      tree call;
4247 {
4248   tree addr;
4249
4250   /* It's invalid to call this function with anything but a
4251      CALL_EXPR.  */
4252   if (TREE_CODE (call) != CALL_EXPR)
4253     abort ();
4254
4255   /* The first operand to the CALL is the address of the function
4256      called.  */
4257   addr = TREE_OPERAND (call, 0);
4258
4259   STRIP_NOPS (addr);
4260
4261   /* If this is a readonly function pointer, extract its initial value.  */
4262   if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
4263       && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
4264       && DECL_INITIAL (addr))
4265     addr = DECL_INITIAL (addr);
4266
4267   /* If the address is just `&f' for some function `f', then we know
4268      that `f' is being called.  */
4269   if (TREE_CODE (addr) == ADDR_EXPR
4270       && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
4271     return TREE_OPERAND (addr, 0);
4272
4273   /* We couldn't figure out what was being called.  */
4274   return NULL_TREE;
4275 }
4276
4277 /* Print debugging information about the obstack O, named STR.  */
4278
4279 void
4280 print_obstack_statistics (str, o)
4281      const char *str;
4282      struct obstack *o;
4283 {
4284   struct _obstack_chunk *chunk = o->chunk;
4285   int n_chunks = 1;
4286   int n_alloc = 0;
4287
4288   n_alloc += o->next_free - chunk->contents;
4289   chunk = chunk->prev;
4290   while (chunk)
4291     {
4292       n_chunks += 1;
4293       n_alloc += chunk->limit - &chunk->contents[0];
4294       chunk = chunk->prev;
4295     }
4296   fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
4297            str, n_alloc, n_chunks);
4298 }
4299
4300 /* Print debugging information about tree nodes generated during the compile,
4301    and any language-specific information.  */
4302
4303 void
4304 dump_tree_statistics ()
4305 {
4306 #ifdef GATHER_STATISTICS
4307   int i;
4308   int total_nodes, total_bytes;
4309 #endif
4310
4311   fprintf (stderr, "\n??? tree nodes created\n\n");
4312 #ifdef GATHER_STATISTICS
4313   fprintf (stderr, "Kind                  Nodes     Bytes\n");
4314   fprintf (stderr, "-------------------------------------\n");
4315   total_nodes = total_bytes = 0;
4316   for (i = 0; i < (int) all_kinds; i++)
4317     {
4318       fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
4319                tree_node_counts[i], tree_node_sizes[i]);
4320       total_nodes += tree_node_counts[i];
4321       total_bytes += tree_node_sizes[i];
4322     }
4323   fprintf (stderr, "-------------------------------------\n");
4324   fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
4325   fprintf (stderr, "-------------------------------------\n");
4326 #else
4327   fprintf (stderr, "(No per-node statistics)\n");
4328 #endif
4329   print_obstack_statistics ("permanent_obstack", &permanent_obstack);
4330   print_type_hash_statistics ();
4331   (*lang_hooks.print_statistics) ();
4332 }
4333 \f
4334 #define FILE_FUNCTION_PREFIX_LEN 9
4335
4336 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
4337
4338 /* Appends 6 random characters to TEMPLATE to (hopefully) avoid name
4339    clashes in cases where we can't reliably choose a unique name.
4340
4341    Derived from mkstemp.c in libiberty.  */
4342
4343 static void
4344 append_random_chars (template)
4345      char *template;
4346 {
4347   static const char letters[]
4348     = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
4349   static unsigned HOST_WIDE_INT value;
4350   unsigned HOST_WIDE_INT v;
4351
4352   if (! value)
4353     {
4354       struct stat st;
4355
4356       /* VALUE should be unique for each file and must not change between
4357          compiles since this can cause bootstrap comparison errors.  */
4358
4359       if (stat (main_input_filename, &st) < 0)
4360         {
4361           /* This can happen when preprocessed text is shipped between
4362              machines, e.g. with bug reports.  Assume that uniqueness
4363              isn't actually an issue.  */
4364           value = 1;
4365         }
4366       else
4367         {
4368           /* In VMS, ino is an array, so we have to use both values.  We
4369              conditionalize that.  */
4370 #ifdef VMS
4371 #define INO_TO_INT(INO) ((int) (INO)[1] << 16 ^ (int) (INO)[2])
4372 #else
4373 #define INO_TO_INT(INO) INO
4374 #endif
4375           value = st.st_dev ^ INO_TO_INT (st.st_ino) ^ st.st_mtime;
4376         }
4377     }
4378
4379   template += strlen (template);
4380
4381   v = value;
4382
4383   /* Fill in the random bits.  */
4384   template[0] = letters[v % 62];
4385   v /= 62;
4386   template[1] = letters[v % 62];
4387   v /= 62;
4388   template[2] = letters[v % 62];
4389   v /= 62;
4390   template[3] = letters[v % 62];
4391   v /= 62;
4392   template[4] = letters[v % 62];
4393   v /= 62;
4394   template[5] = letters[v % 62];
4395
4396   template[6] = '\0';
4397 }
4398
4399 /* P is a string that will be used in a symbol.  Mask out any characters
4400    that are not valid in that context.  */
4401
4402 void
4403 clean_symbol_name (p)
4404      char *p;
4405 {
4406   for (; *p; p++)
4407     if (! (ISALNUM (*p)
4408 #ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
4409             || *p == '$'
4410 #endif
4411 #ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
4412             || *p == '.'
4413 #endif
4414            ))
4415       *p = '_';
4416 }
4417
4418 /* Generate a name for a function unique to this translation unit.
4419    TYPE is some string to identify the purpose of this function to the
4420    linker or collect2.  */
4421
4422 tree
4423 get_file_function_name_long (type)
4424      const char *type;
4425 {
4426   char *buf;
4427   const char *p;
4428   char *q;
4429
4430   if (first_global_object_name)
4431     p = first_global_object_name;
4432   else
4433     {
4434       /* We don't have anything that we know to be unique to this translation
4435          unit, so use what we do have and throw in some randomness.  */
4436
4437       const char *name = weak_global_object_name;
4438       const char *file = main_input_filename;
4439
4440       if (! name)
4441         name = "";
4442       if (! file)
4443         file = input_filename;
4444
4445       q = (char *) alloca (7 + strlen (name) + strlen (file));
4446
4447       sprintf (q, "%s%s", name, file);
4448       append_random_chars (q);
4449       p = q;
4450     }
4451
4452   buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
4453                          + strlen (type));
4454
4455   /* Set up the name of the file-level functions we may need.
4456      Use a global object (which is already required to be unique over
4457      the program) rather than the file name (which imposes extra
4458      constraints).  */
4459   sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
4460
4461   /* Don't need to pull weird characters out of global names.  */
4462   if (p != first_global_object_name)
4463     clean_symbol_name (buf + 11);
4464
4465   return get_identifier (buf);
4466 }
4467
4468 /* If KIND=='I', return a suitable global initializer (constructor) name.
4469    If KIND=='D', return a suitable global clean-up (destructor) name.  */
4470
4471 tree
4472 get_file_function_name (kind)
4473      int kind;
4474 {
4475   char p[2];
4476
4477   p[0] = kind;
4478   p[1] = 0;
4479
4480   return get_file_function_name_long (p);
4481 }
4482 \f
4483 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4484    The result is placed in BUFFER (which has length BIT_SIZE),
4485    with one bit in each char ('\000' or '\001').
4486
4487    If the constructor is constant, NULL_TREE is returned.
4488    Otherwise, a TREE_LIST of the non-constant elements is emitted.  */
4489
4490 tree
4491 get_set_constructor_bits (init, buffer, bit_size)
4492      tree init;
4493      char *buffer;
4494      int bit_size;
4495 {
4496   int i;
4497   tree vals;
4498   HOST_WIDE_INT domain_min
4499     = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
4500   tree non_const_bits = NULL_TREE;
4501
4502   for (i = 0; i < bit_size; i++)
4503     buffer[i] = 0;
4504
4505   for (vals = TREE_OPERAND (init, 1);
4506        vals != NULL_TREE; vals = TREE_CHAIN (vals))
4507     {
4508       if (!host_integerp (TREE_VALUE (vals), 0)
4509           || (TREE_PURPOSE (vals) != NULL_TREE
4510               && !host_integerp (TREE_PURPOSE (vals), 0)))
4511         non_const_bits
4512           = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
4513       else if (TREE_PURPOSE (vals) != NULL_TREE)
4514         {
4515           /* Set a range of bits to ones.  */
4516           HOST_WIDE_INT lo_index
4517             = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
4518           HOST_WIDE_INT hi_index
4519             = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4520
4521           if (lo_index < 0 || lo_index >= bit_size
4522               || hi_index < 0 || hi_index >= bit_size)
4523             abort ();
4524           for (; lo_index <= hi_index; lo_index++)
4525             buffer[lo_index] = 1;
4526         }
4527       else
4528         {
4529           /* Set a single bit to one.  */
4530           HOST_WIDE_INT index
4531             = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
4532           if (index < 0 || index >= bit_size)
4533             {
4534               error ("invalid initializer for bit string");
4535               return NULL_TREE;
4536             }
4537           buffer[index] = 1;
4538         }
4539     }
4540   return non_const_bits;
4541 }
4542
4543 /* Expand (the constant part of) a SET_TYPE CONSTRUCTOR node.
4544    The result is placed in BUFFER (which is an array of bytes).
4545    If the constructor is constant, NULL_TREE is returned.
4546    Otherwise, a TREE_LIST of the non-constant elements is emitted.  */
4547
4548 tree
4549 get_set_constructor_bytes (init, buffer, wd_size)
4550      tree init;
4551      unsigned char *buffer;
4552      int wd_size;
4553 {
4554   int i;
4555   int set_word_size = BITS_PER_UNIT;
4556   int bit_size = wd_size * set_word_size;
4557   int bit_pos = 0;
4558   unsigned char *bytep = buffer;
4559   char *bit_buffer = (char *) alloca (bit_size);
4560   tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
4561
4562   for (i = 0; i < wd_size; i++)
4563     buffer[i] = 0;
4564
4565   for (i = 0; i < bit_size; i++)
4566     {
4567       if (bit_buffer[i])
4568         {
4569           if (BYTES_BIG_ENDIAN)
4570             *bytep |= (1 << (set_word_size - 1 - bit_pos));
4571           else
4572             *bytep |= 1 << bit_pos;
4573         }
4574       bit_pos++;
4575       if (bit_pos >= set_word_size)
4576         bit_pos = 0, bytep++;
4577     }
4578   return non_const_bits;
4579 }
4580 \f
4581 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
4582 /* Complain that the tree code of NODE does not match the expected CODE.
4583    FILE, LINE, and FUNCTION are of the caller.  */
4584
4585 void
4586 tree_check_failed (node, code, file, line, function)
4587      const tree node;
4588      enum tree_code code;
4589      const char *file;
4590      int line;
4591      const char *function;
4592 {
4593   internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
4594                   tree_code_name[code], tree_code_name[TREE_CODE (node)],
4595                   function, trim_filename (file), line);
4596 }
4597
4598 /* Similar to above, except that we check for a class of tree
4599    code, given in CL.  */
4600
4601 void
4602 tree_class_check_failed (node, cl, file, line, function)
4603      const tree node;
4604      int cl;
4605      const char *file;
4606      int line;
4607      const char *function;
4608 {
4609   internal_error
4610     ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
4611      cl, TREE_CODE_CLASS (TREE_CODE (node)),
4612      tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
4613 }
4614
4615 #endif /* ENABLE_TREE_CHECKING */
4616 \f
4617 /* For a new vector type node T, build the information necessary for
4618    debuggint output.  */
4619
4620 static void
4621 finish_vector_type (t)
4622      tree t;
4623 {
4624   layout_type (t);
4625
4626   {
4627     tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
4628     tree array = build_array_type (TREE_TYPE (t),
4629                                    build_index_type (index));
4630     tree rt = make_node (RECORD_TYPE);
4631
4632     TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
4633     DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
4634     layout_type (rt);
4635     TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
4636     /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
4637        the representation type, and we want to find that die when looking up
4638        the vector type.  This is most easily achieved by making the TYPE_UID
4639        numbers equal.  */
4640     TYPE_UID (rt) = TYPE_UID (t);
4641   }
4642 }
4643
4644 /* Create nodes for all integer types (and error_mark_node) using the sizes
4645    of C datatypes.  The caller should call set_sizetype soon after calling
4646    this function to select one of the types as sizetype.  */
4647
4648 void
4649 build_common_tree_nodes (signed_char)
4650      int signed_char;
4651 {
4652   error_mark_node = make_node (ERROR_MARK);
4653   TREE_TYPE (error_mark_node) = error_mark_node;
4654
4655   initialize_sizetypes ();
4656
4657   /* Define both `signed char' and `unsigned char'.  */
4658   signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
4659   unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
4660
4661   /* Define `char', which is like either `signed char' or `unsigned char'
4662      but not the same as either.  */
4663   char_type_node
4664     = (signed_char
4665        ? make_signed_type (CHAR_TYPE_SIZE)
4666        : make_unsigned_type (CHAR_TYPE_SIZE));
4667
4668   short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
4669   short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
4670   integer_type_node = make_signed_type (INT_TYPE_SIZE);
4671   unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
4672   long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
4673   long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
4674   long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
4675   long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
4676
4677   intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
4678   intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
4679   intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
4680   intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
4681   intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
4682
4683   unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
4684   unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
4685   unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
4686   unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
4687   unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
4688 }
4689
4690 /* Call this function after calling build_common_tree_nodes and set_sizetype.
4691    It will create several other common tree nodes.  */
4692
4693 void
4694 build_common_tree_nodes_2 (short_double)
4695      int short_double;
4696 {
4697   /* Define these next since types below may used them.  */
4698   integer_zero_node = build_int_2 (0, 0);
4699   integer_one_node = build_int_2 (1, 0);
4700   integer_minus_one_node = build_int_2 (-1, -1);
4701
4702   size_zero_node = size_int (0);
4703   size_one_node = size_int (1);
4704   bitsize_zero_node = bitsize_int (0);
4705   bitsize_one_node = bitsize_int (1);
4706   bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
4707
4708   void_type_node = make_node (VOID_TYPE);
4709   layout_type (void_type_node);
4710
4711   /* We are not going to have real types in C with less than byte alignment,
4712      so we might as well not have any types that claim to have it.  */
4713   TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
4714   TYPE_USER_ALIGN (void_type_node) = 0;
4715
4716   null_pointer_node = build_int_2 (0, 0);
4717   TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
4718   layout_type (TREE_TYPE (null_pointer_node));
4719
4720   ptr_type_node = build_pointer_type (void_type_node);
4721   const_ptr_type_node
4722     = build_pointer_type (build_type_variant (void_type_node, 1, 0));
4723
4724   float_type_node = make_node (REAL_TYPE);
4725   TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
4726   layout_type (float_type_node);
4727
4728   double_type_node = make_node (REAL_TYPE);
4729   if (short_double)
4730     TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
4731   else
4732     TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
4733   layout_type (double_type_node);
4734
4735   long_double_type_node = make_node (REAL_TYPE);
4736   TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
4737   layout_type (long_double_type_node);
4738
4739   complex_integer_type_node = make_node (COMPLEX_TYPE);
4740   TREE_TYPE (complex_integer_type_node) = integer_type_node;
4741   layout_type (complex_integer_type_node);
4742
4743   complex_float_type_node = make_node (COMPLEX_TYPE);
4744   TREE_TYPE (complex_float_type_node) = float_type_node;
4745   layout_type (complex_float_type_node);
4746
4747   complex_double_type_node = make_node (COMPLEX_TYPE);
4748   TREE_TYPE (complex_double_type_node) = double_type_node;
4749   layout_type (complex_double_type_node);
4750
4751   complex_long_double_type_node = make_node (COMPLEX_TYPE);
4752   TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
4753   layout_type (complex_long_double_type_node);
4754
4755   {
4756     tree t;
4757     BUILD_VA_LIST_TYPE (t);
4758
4759     /* Many back-ends define record types without seting TYPE_NAME.
4760        If we copied the record type here, we'd keep the original
4761        record type without a name.  This breaks name mangling.  So,
4762        don't copy record types and let c_common_nodes_and_builtins()
4763        declare the type to be __builtin_va_list.  */
4764     if (TREE_CODE (t) != RECORD_TYPE)
4765       t = build_type_copy (t);
4766
4767     va_list_type_node = t;
4768   }
4769
4770   unsigned_V4SI_type_node
4771     = make_vector (V4SImode, unsigned_intSI_type_node, 1);
4772   unsigned_V2SI_type_node
4773     = make_vector (V2SImode, unsigned_intSI_type_node, 1);
4774   unsigned_V2DI_type_node
4775     = make_vector (V2DImode, unsigned_intDI_type_node, 1);
4776   unsigned_V4HI_type_node
4777     = make_vector (V4HImode, unsigned_intHI_type_node, 1);
4778   unsigned_V8QI_type_node
4779     = make_vector (V8QImode, unsigned_intQI_type_node, 1);
4780   unsigned_V8HI_type_node
4781     = make_vector (V8HImode, unsigned_intHI_type_node, 1);
4782   unsigned_V16QI_type_node
4783     = make_vector (V16QImode, unsigned_intQI_type_node, 1);
4784
4785   V16SF_type_node = make_vector (V16SFmode, float_type_node, 0);
4786   V4SF_type_node = make_vector (V4SFmode, float_type_node, 0);
4787   V4SI_type_node = make_vector (V4SImode, intSI_type_node, 0);
4788   V2SI_type_node = make_vector (V2SImode, intSI_type_node, 0);
4789   V2DI_type_node = make_vector (V2DImode, intDI_type_node, 0);
4790   V4HI_type_node = make_vector (V4HImode, intHI_type_node, 0);
4791   V8QI_type_node = make_vector (V8QImode, intQI_type_node, 0);
4792   V8HI_type_node = make_vector (V8HImode, intHI_type_node, 0);
4793   V2SF_type_node = make_vector (V2SFmode, float_type_node, 0);
4794   V2DF_type_node = make_vector (V2DFmode, double_type_node, 0);
4795   V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0);
4796 }
4797
4798 /* Returns a vector tree node given a vector mode, the inner type, and
4799    the signness.  */
4800
4801 static tree
4802 make_vector (mode, innertype, unsignedp)
4803      enum machine_mode mode;
4804      tree innertype;
4805      int unsignedp;
4806 {
4807   tree t;
4808
4809   t = make_node (VECTOR_TYPE);
4810   TREE_TYPE (t) = innertype;
4811   TYPE_MODE (t) = mode;
4812   TREE_UNSIGNED (TREE_TYPE (t)) = unsignedp;
4813   finish_vector_type (t);
4814
4815   return t;
4816 }
4817
4818 /* Given an initializer INIT, return TRUE if INIT is zero or some
4819    aggregate of zeros.  Otherwise return FALSE.  */
4820
4821 bool
4822 initializer_zerop (init)
4823      tree init;
4824 {
4825   STRIP_NOPS (init);
4826
4827   switch (TREE_CODE (init))
4828     {
4829     case INTEGER_CST:
4830       return integer_zerop (init);
4831     case REAL_CST:
4832       return real_zerop (init)
4833         && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
4834     case COMPLEX_CST:
4835       return integer_zerop (init)
4836         || (real_zerop (init)
4837             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
4838             && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
4839     case CONSTRUCTOR:
4840       {
4841         if (AGGREGATE_TYPE_P (TREE_TYPE (init)))
4842           {
4843             tree aggr_init = TREE_OPERAND (init, 1);
4844
4845             while (aggr_init)
4846               {
4847                 if (! initializer_zerop (TREE_VALUE (aggr_init)))
4848                   return false;
4849                 aggr_init = TREE_CHAIN (aggr_init);
4850               }
4851             return true;
4852           }
4853         return false;
4854       }
4855     default:
4856       return false;
4857     }
4858 }