gcc/c-typeck.c

   1 /* Build expressions with type checking for C compiler.
   2    Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23
  24 /* This file is part of the C front end.
  25    It contains routines to build C expressions given their operands,
  26    including computing the types of the result, C-specific error checks,
  27    and some optimization.  */
  28
  29 #include "config.h"
  30 #include "system.h"
  31 #include "coretypes.h"
  32 #include "tm.h"
  33 #include "rtl.h"
  34 #include "tree.h"
  35 #include "langhooks.h"
  36 #include "c-tree.h"
  37 #include "tm_p.h"
  38 #include "flags.h"
  39 #include "output.h"
  40 #include "expr.h"
  41 #include "toplev.h"
  42 #include "intl.h"
  43 #include "ggc.h"
  44 #include "target.h"
  45 #include "tree-iterator.h"
  46 #include "tree-gimple.h"
  47 #include "tree-flow.h"
  48
  49 /* Possible cases of implicit bad conversions.  Used to select
  50    diagnostic messages in convert_for_assignment.  */
  51 enum impl_conv {
  52   ic_argpass,
  53   ic_argpass_nonproto,
  54   ic_assign,
  55   ic_init,
  56   ic_return
  57 };
  58
  59 /* The level of nesting inside "__alignof__".  */
  60 int in_alignof;
  61
  62 /* The level of nesting inside "sizeof".  */
  63 int in_sizeof;
  64
  65 /* The level of nesting inside "typeof".  */
  66 int in_typeof;
  67
  68 struct c_label_context_se *label_context_stack_se;
  69 struct c_label_context_vm *label_context_stack_vm;
  70
  71 /* Nonzero if we've already printed a "missing braces around initializer"
  72    message within this initializer.  */
  73 static int missing_braces_mentioned;
  74
  75 static int require_constant_value;
  76 static int require_constant_elements;
  77
  78 static bool null_pointer_constant_p (tree);
  79 static tree qualify_type (tree, tree);
  80 static int tagged_types_tu_compatible_p (tree, tree);
  81 static int comp_target_types (tree, tree);
  82 static int function_types_compatible_p (tree, tree);
  83 static int type_lists_compatible_p (tree, tree);
  84 static tree decl_constant_value_for_broken_optimization (tree);
  85 static tree lookup_field (tree, tree);
  86 static tree convert_arguments (tree, tree, tree, tree);
  87 static tree pointer_diff (tree, tree);
  88 static tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree,
  89                                     int);
  90 static tree valid_compound_expr_initializer (tree, tree);
  91 static void push_string (const char *);
  92 static void push_member_name (tree);
  93 static int spelling_length (void);
  94 static char *print_spelling (char *);
  95 static void warning_init (const char *);
  96 static tree digest_init (tree, tree, bool, int);
  97 static void output_init_element (tree, bool, tree, tree, int);
  98 static void output_pending_init_elements (int);
  99 static int set_designator (int);
 100 static void push_range_stack (tree);
 101 static void add_pending_init (tree, tree);
 102 static void set_nonincremental_init (void);
 103 static void set_nonincremental_init_from_string (tree);
 104 static tree find_init_member (tree);
 105 static void readonly_error (tree, enum lvalue_use);
 106 static int lvalue_or_else (tree, enum lvalue_use);
 107 static int lvalue_p (tree);
 108 static void record_maybe_used_decl (tree);
 109 static int comptypes_internal (tree, tree);
 110 \f
 111 /* Return true if EXP is a null pointer constant, false otherwise.  */
 112
 113 static bool
 114 null_pointer_constant_p (tree expr)
 115 {
 116   /* This should really operate on c_expr structures, but they aren't
 117      yet available everywhere required.  */
 118   tree type = TREE_TYPE (expr);
 119   return (TREE_CODE (expr) == INTEGER_CST
 120           && !TREE_CONSTANT_OVERFLOW (expr)
 121           && integer_zerop (expr)
 122           && (INTEGRAL_TYPE_P (type)
 123               || (TREE_CODE (type) == POINTER_TYPE
 124                   && VOID_TYPE_P (TREE_TYPE (type))
 125                   && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED)));
 126 }
 127 \f/* This is a cache to hold if two types are compatible or not.  */
 128
 129 struct tagged_tu_seen_cache {
 130   const struct tagged_tu_seen_cache * next;
 131   tree t1;
 132   tree t2;
 133   /* The return value of tagged_types_tu_compatible_p if we had seen
 134      these two types already.  */
 135   int val;
 136 };
 137
 138 static const struct tagged_tu_seen_cache * tagged_tu_seen_base;
 139 static void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *);
 140
 141 /* Do `exp = require_complete_type (exp);' to make sure exp
 142    does not have an incomplete type.  (That includes void types.)  */
 143
 144 tree
 145 require_complete_type (tree value)
 146 {
 147   tree type = TREE_TYPE (value);
 148
 149   if (value == error_mark_node || type == error_mark_node)
 150     return error_mark_node;
 151
 152   /* First, detect a valid value with a complete type.  */
 153   if (COMPLETE_TYPE_P (type))
 154     return value;
 155
 156   c_incomplete_type_error (value, type);
 157   return error_mark_node;
 158 }
 159
 160 /* Print an error message for invalid use of an incomplete type.
 161    VALUE is the expression that was used (or 0 if that isn't known)
 162    and TYPE is the type that was invalid.  */
 163
 164 void
 165 c_incomplete_type_error (tree value, tree type)
 166 {
 167   const char *type_code_string;
 168
 169   /* Avoid duplicate error message.  */
 170   if (TREE_CODE (type) == ERROR_MARK)
 171     return;
 172
 173   if (value != 0 && (TREE_CODE (value) == VAR_DECL
 174                      || TREE_CODE (value) == PARM_DECL))
 175     error ("%qD has an incomplete type", value);
 176   else
 177     {
 178     retry:
 179       /* We must print an error message.  Be clever about what it says.  */
 180
 181       switch (TREE_CODE (type))
 182         {
 183         case RECORD_TYPE:
 184           type_code_string = "struct";
 185           break;
 186
 187         case UNION_TYPE:
 188           type_code_string = "union";
 189           break;
 190
 191         case ENUMERAL_TYPE:
 192           type_code_string = "enum";
 193           break;
 194
 195         case VOID_TYPE:
 196           error ("invalid use of void expression");
 197           return;
 198
 199         case ARRAY_TYPE:
 200           if (TYPE_DOMAIN (type))
 201             {
 202               if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL)
 203                 {
 204                   error ("invalid use of flexible array member");
 205                   return;
 206                 }
 207               type = TREE_TYPE (type);
 208               goto retry;
 209             }
 210           error ("invalid use of array with unspecified bounds");
 211           return;
 212
 213         default:
 214           gcc_unreachable ();
 215         }
 216
 217       if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
 218         error ("invalid use of undefined type %<%s %E%>",
 219                type_code_string, TYPE_NAME (type));
 220       else
 221         /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL.  */
 222         error ("invalid use of incomplete typedef %qD", TYPE_NAME (type));
 223     }
 224 }
 225
 226 /* Given a type, apply default promotions wrt unnamed function
 227    arguments and return the new type.  */
 228
 229 tree
 230 c_type_promotes_to (tree type)
 231 {
 232   if (TYPE_MAIN_VARIANT (type) == float_type_node)
 233     return double_type_node;
 234
 235   if (c_promoting_integer_type_p (type))
 236     {
 237       /* Preserve unsignedness if not really getting any wider.  */
 238       if (TYPE_UNSIGNED (type)
 239           && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)))
 240         return unsigned_type_node;
 241       return integer_type_node;
 242     }
 243
 244   return type;
 245 }
 246
 247 /* Return a variant of TYPE which has all the type qualifiers of LIKE
 248    as well as those of TYPE.  */
 249
 250 static tree
 251 qualify_type (tree type, tree like)
 252 {
 253   return c_build_qualified_type (type,
 254                                  TYPE_QUALS (type) | TYPE_QUALS (like));
 255 }
 256
 257 /* Return true iff the given tree T is a variable length array.  */
 258
 259 bool
 260 c_vla_type_p (tree t)
 261 {
 262   if (TREE_CODE (t) == ARRAY_TYPE
 263       && C_TYPE_VARIABLE_SIZE (t))
 264     return true;
 265   return false;
 266 }
 267 \f
 268 /* Return the composite type of two compatible types.
 269
 270    We assume that comptypes has already been done and returned
 271    nonzero; if that isn't so, this may crash.  In particular, we
 272    assume that qualifiers match.  */
 273
 274 tree
 275 composite_type (tree t1, tree t2)
 276 {
 277   enum tree_code code1;
 278   enum tree_code code2;
 279   tree attributes;
 280
 281   /* Save time if the two types are the same.  */
 282
 283   if (t1 == t2) return t1;
 284
 285   /* If one type is nonsense, use the other.  */
 286   if (t1 == error_mark_node)
 287     return t2;
 288   if (t2 == error_mark_node)
 289     return t1;
 290
 291   code1 = TREE_CODE (t1);
 292   code2 = TREE_CODE (t2);
 293
 294   /* Merge the attributes.  */
 295   attributes = targetm.merge_type_attributes (t1, t2);
 296
 297   /* If one is an enumerated type and the other is the compatible
 298      integer type, the composite type might be either of the two
 299      (DR#013 question 3).  For consistency, use the enumerated type as
 300      the composite type.  */
 301
 302   if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE)
 303     return t1;
 304   if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE)
 305     return t2;
 306
 307   gcc_assert (code1 == code2);
 308
 309   switch (code1)
 310     {
 311     case POINTER_TYPE:
 312       /* For two pointers, do this recursively on the target type.  */
 313       {
 314         tree pointed_to_1 = TREE_TYPE (t1);
 315         tree pointed_to_2 = TREE_TYPE (t2);
 316         tree target = composite_type (pointed_to_1, pointed_to_2);
 317         t1 = build_pointer_type (target);
 318         t1 = build_type_attribute_variant (t1, attributes);
 319         return qualify_type (t1, t2);
 320       }
 321
 322     case ARRAY_TYPE:
 323       {
 324         tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 325         int quals;
 326         tree unqual_elt;
 327         tree d1 = TYPE_DOMAIN (t1);
 328         tree d2 = TYPE_DOMAIN (t2);
 329         bool d1_variable, d2_variable;
 330         bool d1_zero, d2_zero;
 331
 332         /* We should not have any type quals on arrays at all.  */
 333         gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2));
 334
 335         d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1);
 336         d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2);
 337
 338         d1_variable = (!d1_zero
 339                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 340                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 341         d2_variable = (!d2_zero
 342                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 343                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 344         d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
 345         d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
 346
 347         /* Save space: see if the result is identical to one of the args.  */
 348         if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1)
 349             && (d2_variable || d2_zero || !d1_variable))
 350           return build_type_attribute_variant (t1, attributes);
 351         if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2)
 352             && (d1_variable || d1_zero || !d2_variable))
 353           return build_type_attribute_variant (t2, attributes);
 354
 355         if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 356           return build_type_attribute_variant (t1, attributes);
 357         if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1))
 358           return build_type_attribute_variant (t2, attributes);
 359
 360         /* Merge the element types, and have a size if either arg has
 361            one.  We may have qualifiers on the element types.  To set
 362            up TYPE_MAIN_VARIANT correctly, we need to form the
 363            composite of the unqualified types and add the qualifiers
 364            back at the end.  */
 365         quals = TYPE_QUALS (strip_array_types (elt));
 366         unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
 367         t1 = build_array_type (unqual_elt,
 368                                TYPE_DOMAIN ((TYPE_DOMAIN (t1)
 369                                              && (d2_variable
 370                                                  || d2_zero
 371                                                  || !d1_variable))
 372                                             ? t1
 373                                             : t2));
 374         t1 = c_build_qualified_type (t1, quals);
 375         return build_type_attribute_variant (t1, attributes);
 376       }
 377
 378     case FUNCTION_TYPE:
 379       /* Function types: prefer the one that specified arg types.
 380          If both do, merge the arg types.  Also merge the return types.  */
 381       {
 382         tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2));
 383         tree p1 = TYPE_ARG_TYPES (t1);
 384         tree p2 = TYPE_ARG_TYPES (t2);
 385         int len;
 386         tree newargs, n;
 387         int i;
 388
 389         /* Save space: see if the result is identical to one of the args.  */
 390         if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2))
 391           return build_type_attribute_variant (t1, attributes);
 392         if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1))
 393           return build_type_attribute_variant (t2, attributes);
 394
 395         /* Simple way if one arg fails to specify argument types.  */
 396         if (TYPE_ARG_TYPES (t1) == 0)
 397          {
 398             t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2));
 399             t1 = build_type_attribute_variant (t1, attributes);
 400             return qualify_type (t1, t2);
 401          }
 402         if (TYPE_ARG_TYPES (t2) == 0)
 403          {
 404            t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1));
 405            t1 = build_type_attribute_variant (t1, attributes);
 406            return qualify_type (t1, t2);
 407          }
 408
 409         /* If both args specify argument types, we must merge the two
 410            lists, argument by argument.  */
 411         /* Tell global_bindings_p to return false so that variable_size
 412            doesn't die on VLAs in parameter types.  */
 413         c_override_global_bindings_to_false = true;
 414
 415         len = list_length (p1);
 416         newargs = 0;
 417
 418         for (i = 0; i < len; i++)
 419           newargs = tree_cons (NULL_TREE, NULL_TREE, newargs);
 420
 421         n = newargs;
 422
 423         for (; p1;
 424              p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n))
 425           {
 426             /* A null type means arg type is not specified.
 427                Take whatever the other function type has.  */
 428             if (TREE_VALUE (p1) == 0)
 429               {
 430                 TREE_VALUE (n) = TREE_VALUE (p2);
 431                 goto parm_done;
 432               }
 433             if (TREE_VALUE (p2) == 0)
 434               {
 435                 TREE_VALUE (n) = TREE_VALUE (p1);
 436                 goto parm_done;
 437               }
 438
 439             /* Given  wait (union {union wait *u; int *i} *)
 440                and  wait (union wait *),
 441                prefer  union wait *  as type of parm.  */
 442             if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE
 443                 && TREE_VALUE (p1) != TREE_VALUE (p2))
 444               {
 445                 tree memb;
 446                 tree mv2 = TREE_VALUE (p2);
 447                 if (mv2 && mv2 != error_mark_node
 448                     && TREE_CODE (mv2) != ARRAY_TYPE)
 449                   mv2 = TYPE_MAIN_VARIANT (mv2);
 450                 for (memb = TYPE_FIELDS (TREE_VALUE (p1));
 451                      memb; memb = TREE_CHAIN (memb))
 452                   {
 453                     tree mv3 = TREE_TYPE (memb);
 454                     if (mv3 && mv3 != error_mark_node
 455                         && TREE_CODE (mv3) != ARRAY_TYPE)
 456                       mv3 = TYPE_MAIN_VARIANT (mv3);
 457                     if (comptypes (mv3, mv2))
 458                       {
 459                         TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 460                                                          TREE_VALUE (p2));
 461                         if (pedantic)
 462                           pedwarn ("function types not truly compatible in ISO C");
 463                         goto parm_done;
 464                       }
 465                   }
 466               }
 467             if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE
 468                 && TREE_VALUE (p2) != TREE_VALUE (p1))
 469               {
 470                 tree memb;
 471                 tree mv1 = TREE_VALUE (p1);
 472                 if (mv1 && mv1 != error_mark_node
 473                     && TREE_CODE (mv1) != ARRAY_TYPE)
 474                   mv1 = TYPE_MAIN_VARIANT (mv1);
 475                 for (memb = TYPE_FIELDS (TREE_VALUE (p2));
 476                      memb; memb = TREE_CHAIN (memb))
 477                   {
 478                     tree mv3 = TREE_TYPE (memb);
 479                     if (mv3 && mv3 != error_mark_node
 480                         && TREE_CODE (mv3) != ARRAY_TYPE)
 481                       mv3 = TYPE_MAIN_VARIANT (mv3);
 482                     if (comptypes (mv3, mv1))
 483                       {
 484                         TREE_VALUE (n) = composite_type (TREE_TYPE (memb),
 485                                                          TREE_VALUE (p1));
 486                         if (pedantic)
 487                           pedwarn ("function types not truly compatible in ISO C");
 488                         goto parm_done;
 489                       }
 490                   }
 491               }
 492             TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2));
 493           parm_done: ;
 494           }
 495
 496         c_override_global_bindings_to_false = false;
 497         t1 = build_function_type (valtype, newargs);
 498         t1 = qualify_type (t1, t2);
 499         /* ... falls through ...  */
 500       }
 501
 502     default:
 503       return build_type_attribute_variant (t1, attributes);
 504     }
 505
 506 }
 507
 508 /* Return the type of a conditional expression between pointers to
 509    possibly differently qualified versions of compatible types.
 510
 511    We assume that comp_target_types has already been done and returned
 512    nonzero; if that isn't so, this may crash.  */
 513
 514 static tree
 515 common_pointer_type (tree t1, tree t2)
 516 {
 517   tree attributes;
 518   tree pointed_to_1, mv1;
 519   tree pointed_to_2, mv2;
 520   tree target;
 521
 522   /* Save time if the two types are the same.  */
 523
 524   if (t1 == t2) return t1;
 525
 526   /* If one type is nonsense, use the other.  */
 527   if (t1 == error_mark_node)
 528     return t2;
 529   if (t2 == error_mark_node)
 530     return t1;
 531
 532   gcc_assert (TREE_CODE (t1) == POINTER_TYPE
 533               && TREE_CODE (t2) == POINTER_TYPE);
 534
 535   /* Merge the attributes.  */
 536   attributes = targetm.merge_type_attributes (t1, t2);
 537
 538   /* Find the composite type of the target types, and combine the
 539      qualifiers of the two types' targets.  Do not lose qualifiers on
 540      array element types by taking the TYPE_MAIN_VARIANT.  */
 541   mv1 = pointed_to_1 = TREE_TYPE (t1);
 542   mv2 = pointed_to_2 = TREE_TYPE (t2);
 543   if (TREE_CODE (mv1) != ARRAY_TYPE)
 544     mv1 = TYPE_MAIN_VARIANT (pointed_to_1);
 545   if (TREE_CODE (mv2) != ARRAY_TYPE)
 546     mv2 = TYPE_MAIN_VARIANT (pointed_to_2);
 547   target = composite_type (mv1, mv2);
 548   t1 = build_pointer_type (c_build_qualified_type
 549                            (target,
 550                             TYPE_QUALS (pointed_to_1) |
 551                             TYPE_QUALS (pointed_to_2)));
 552   return build_type_attribute_variant (t1, attributes);
 553 }
 554
 555 /* Return the common type for two arithmetic types under the usual
 556    arithmetic conversions.  The default conversions have already been
 557    applied, and enumerated types converted to their compatible integer
 558    types.  The resulting type is unqualified and has no attributes.
 559
 560    This is the type for the result of most arithmetic operations
 561    if the operands have the given two types.  */
 562
 563 static tree
 564 c_common_type (tree t1, tree t2)
 565 {
 566   enum tree_code code1;
 567   enum tree_code code2;
 568
 569   /* If one type is nonsense, use the other.  */
 570   if (t1 == error_mark_node)
 571     return t2;
 572   if (t2 == error_mark_node)
 573     return t1;
 574
 575   if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED)
 576     t1 = TYPE_MAIN_VARIANT (t1);
 577
 578   if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED)
 579     t2 = TYPE_MAIN_VARIANT (t2);
 580
 581   if (TYPE_ATTRIBUTES (t1) != NULL_TREE)
 582     t1 = build_type_attribute_variant (t1, NULL_TREE);
 583
 584   if (TYPE_ATTRIBUTES (t2) != NULL_TREE)
 585     t2 = build_type_attribute_variant (t2, NULL_TREE);
 586
 587   /* Save time if the two types are the same.  */
 588
 589   if (t1 == t2) return t1;
 590
 591   code1 = TREE_CODE (t1);
 592   code2 = TREE_CODE (t2);
 593
 594   gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE
 595               || code1 == REAL_TYPE || code1 == INTEGER_TYPE);
 596   gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE
 597               || code2 == REAL_TYPE || code2 == INTEGER_TYPE);
 598
 599   /* When one operand is a decimal float type, the other operand cannot be
 600      a generic float type or a complex type.  We also disallow vector types
 601      here.  */
 602   if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2))
 603       && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2)))
 604     {
 605       if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE)
 606         {
 607           error ("can%'t mix operands of decimal float and vector types");
 608           return error_mark_node;
 609         }
 610       if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 611         {
 612           error ("can%'t mix operands of decimal float and complex types");
 613           return error_mark_node;
 614         }
 615       if (code1 == REAL_TYPE && code2 == REAL_TYPE)
 616         {
 617           error ("can%'t mix operands of decimal float and other float types");
 618           return error_mark_node;
 619         }
 620     }
 621
 622   /* If one type is a vector type, return that type.  (How the usual
 623      arithmetic conversions apply to the vector types extension is not
 624      precisely specified.)  */
 625   if (code1 == VECTOR_TYPE)
 626     return t1;
 627
 628   if (code2 == VECTOR_TYPE)
 629     return t2;
 630
 631   /* If one type is complex, form the common type of the non-complex
 632      components, then make that complex.  Use T1 or T2 if it is the
 633      required type.  */
 634   if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE)
 635     {
 636       tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1;
 637       tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2;
 638       tree subtype = c_common_type (subtype1, subtype2);
 639
 640       if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype)
 641         return t1;
 642       else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype)
 643         return t2;
 644       else
 645         return build_complex_type (subtype);
 646     }
 647
 648   /* If only one is real, use it as the result.  */
 649
 650   if (code1 == REAL_TYPE && code2 != REAL_TYPE)
 651     return t1;
 652
 653   if (code2 == REAL_TYPE && code1 != REAL_TYPE)
 654     return t2;
 655
 656   /* If both are real and either are decimal floating point types, use
 657      the decimal floating point type with the greater precision. */
 658
 659   if (code1 == REAL_TYPE && code2 == REAL_TYPE)
 660     {
 661       if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node
 662           || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node)
 663         return dfloat128_type_node;
 664       else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node
 665                || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node)
 666         return dfloat64_type_node;
 667       else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node
 668                || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node)
 669         return dfloat32_type_node;
 670     }
 671
 672   /* Both real or both integers; use the one with greater precision.  */
 673
 674   if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2))
 675     return t1;
 676   else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1))
 677     return t2;
 678
 679   /* Same precision.  Prefer long longs to longs to ints when the
 680      same precision, following the C99 rules on integer type rank
 681      (which are equivalent to the C90 rules for C90 types).  */
 682
 683   if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node
 684       || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node)
 685     return long_long_unsigned_type_node;
 686
 687   if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node
 688       || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node)
 689     {
 690       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 691         return long_long_unsigned_type_node;
 692       else
 693         return long_long_integer_type_node;
 694     }
 695
 696   if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node
 697       || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node)
 698     return long_unsigned_type_node;
 699
 700   if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node
 701       || TYPE_MAIN_VARIANT (t2) == long_integer_type_node)
 702     {
 703       /* But preserve unsignedness from the other type,
 704          since long cannot hold all the values of an unsigned int.  */
 705       if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2))
 706         return long_unsigned_type_node;
 707       else
 708         return long_integer_type_node;
 709     }
 710
 711   /* Likewise, prefer long double to double even if same size.  */
 712   if (TYPE_MAIN_VARIANT (t1) == long_double_type_node
 713       || TYPE_MAIN_VARIANT (t2) == long_double_type_node)
 714     return long_double_type_node;
 715
 716   /* Otherwise prefer the unsigned one.  */
 717
 718   if (TYPE_UNSIGNED (t1))
 719     return t1;
 720   else
 721     return t2;
 722 }
 723 \f
 724 /* Wrapper around c_common_type that is used by c-common.c and other
 725    front end optimizations that remove promotions.  ENUMERAL_TYPEs
 726    are allowed here and are converted to their compatible integer types.
 727    BOOLEAN_TYPEs are allowed here and return either boolean_type_node or
 728    preferably a non-Boolean type as the common type.  */
 729 tree
 730 common_type (tree t1, tree t2)
 731 {
 732   if (TREE_CODE (t1) == ENUMERAL_TYPE)
 733     t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1);
 734   if (TREE_CODE (t2) == ENUMERAL_TYPE)
 735     t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1);
 736
 737   /* If both types are BOOLEAN_TYPE, then return boolean_type_node.  */
 738   if (TREE_CODE (t1) == BOOLEAN_TYPE
 739       && TREE_CODE (t2) == BOOLEAN_TYPE)
 740     return boolean_type_node;
 741
 742   /* If either type is BOOLEAN_TYPE, then return the other.  */
 743   if (TREE_CODE (t1) == BOOLEAN_TYPE)
 744     return t2;
 745   if (TREE_CODE (t2) == BOOLEAN_TYPE)
 746     return t1;
 747
 748   return c_common_type (t1, t2);
 749 }
 750
 751 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 752    or various other operations.  Return 2 if they are compatible
 753    but a warning may be needed if you use them together.  */
 754
 755 int
 756 comptypes (tree type1, tree type2)
 757 {
 758   const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base;
 759   int val;
 760
 761   val = comptypes_internal (type1, type2);
 762   free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1);
 763
 764   return val;
 765 }
 766 \f
 767 /* Return 1 if TYPE1 and TYPE2 are compatible types for assignment
 768    or various other operations.  Return 2 if they are compatible
 769    but a warning may be needed if you use them together.  This
 770    differs from comptypes, in that we don't free the seen types.  */
 771
 772 static int
 773 comptypes_internal (tree type1, tree type2)
 774 {
 775   tree t1 = type1;
 776   tree t2 = type2;
 777   int attrval, val;
 778
 779   /* Suppress errors caused by previously reported errors.  */
 780
 781   if (t1 == t2 || !t1 || !t2
 782       || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK)
 783     return 1;
 784
 785   /* If either type is the internal version of sizetype, return the
 786      language version.  */
 787   if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1)
 788       && TYPE_ORIG_SIZE_TYPE (t1))
 789     t1 = TYPE_ORIG_SIZE_TYPE (t1);
 790
 791   if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2)
 792       && TYPE_ORIG_SIZE_TYPE (t2))
 793     t2 = TYPE_ORIG_SIZE_TYPE (t2);
 794
 795
 796   /* Enumerated types are compatible with integer types, but this is
 797      not transitive: two enumerated types in the same translation unit
 798      are compatible with each other only if they are the same type.  */
 799
 800   if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE)
 801     t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1));
 802   else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE)
 803     t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2));
 804
 805   if (t1 == t2)
 806     return 1;
 807
 808   /* Different classes of types can't be compatible.  */
 809
 810   if (TREE_CODE (t1) != TREE_CODE (t2))
 811     return 0;
 812
 813   /* Qualifiers must match. C99 6.7.3p9 */
 814
 815   if (TYPE_QUALS (t1) != TYPE_QUALS (t2))
 816     return 0;
 817
 818   /* Allow for two different type nodes which have essentially the same
 819      definition.  Note that we already checked for equality of the type
 820      qualifiers (just above).  */
 821
 822   if (TREE_CODE (t1) != ARRAY_TYPE
 823       && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2))
 824     return 1;
 825
 826   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 827   if (!(attrval = targetm.comp_type_attributes (t1, t2)))
 828      return 0;
 829
 830   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
 831   val = 0;
 832
 833   switch (TREE_CODE (t1))
 834     {
 835     case POINTER_TYPE:
 836       /* Do not remove mode or aliasing information.  */
 837       if (TYPE_MODE (t1) != TYPE_MODE (t2)
 838           || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2))
 839         break;
 840       val = (TREE_TYPE (t1) == TREE_TYPE (t2)
 841              ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)));
 842       break;
 843
 844     case FUNCTION_TYPE:
 845       val = function_types_compatible_p (t1, t2);
 846       break;
 847
 848     case ARRAY_TYPE:
 849       {
 850         tree d1 = TYPE_DOMAIN (t1);
 851         tree d2 = TYPE_DOMAIN (t2);
 852         bool d1_variable, d2_variable;
 853         bool d1_zero, d2_zero;
 854         val = 1;
 855
 856         /* Target types must match incl. qualifiers.  */
 857         if (TREE_TYPE (t1) != TREE_TYPE (t2)
 858             && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))))
 859           return 0;
 860
 861         /* Sizes must match unless one is missing or variable.  */
 862         if (d1 == 0 || d2 == 0 || d1 == d2)
 863           break;
 864
 865         d1_zero = !TYPE_MAX_VALUE (d1);
 866         d2_zero = !TYPE_MAX_VALUE (d2);
 867
 868         d1_variable = (!d1_zero
 869                        && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST
 870                            || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST));
 871         d2_variable = (!d2_zero
 872                        && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST
 873                            || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST));
 874         d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1));
 875         d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2));
 876
 877         if (d1_variable || d2_variable)
 878           break;
 879         if (d1_zero && d2_zero)
 880           break;
 881         if (d1_zero || d2_zero
 882             || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2))
 883             || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2)))
 884           val = 0;
 885
 886         break;
 887       }
 888
 889     case ENUMERAL_TYPE:
 890     case RECORD_TYPE:
 891     case UNION_TYPE:
 892       if (val != 1 && !same_translation_unit_p (t1, t2))
 893         {
 894           if (attrval != 2)
 895             return tagged_types_tu_compatible_p (t1, t2);
 896           val = tagged_types_tu_compatible_p (t1, t2);
 897         }
 898       break;
 899
 900     case VECTOR_TYPE:
 901       val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
 902             && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2));
 903       break;
 904
 905     default:
 906       break;
 907     }
 908   return attrval == 2 && val == 1 ? 2 : val;
 909 }
 910
 911 /* Return 1 if TTL and TTR are pointers to types that are equivalent,
 912    ignoring their qualifiers.  */
 913
 914 static int
 915 comp_target_types (tree ttl, tree ttr)
 916 {
 917   int val;
 918   tree mvl, mvr;
 919
 920   /* Do not lose qualifiers on element types of array types that are
 921      pointer targets by taking their TYPE_MAIN_VARIANT.  */
 922   mvl = TREE_TYPE (ttl);
 923   mvr = TREE_TYPE (ttr);
 924   if (TREE_CODE (mvl) != ARRAY_TYPE)
 925     mvl = TYPE_MAIN_VARIANT (mvl);
 926   if (TREE_CODE (mvr) != ARRAY_TYPE)
 927     mvr = TYPE_MAIN_VARIANT (mvr);
 928   val = comptypes (mvl, mvr);
 929
 930   if (val == 2 && pedantic)
 931     pedwarn ("types are not quite compatible");
 932   return val;
 933 }
 934 \f
 935 /* Subroutines of `comptypes'.  */
 936
 937 /* Determine whether two trees derive from the same translation unit.
 938    If the CONTEXT chain ends in a null, that tree's context is still
 939    being parsed, so if two trees have context chains ending in null,
 940    they're in the same translation unit.  */
 941 int
 942 same_translation_unit_p (tree t1, tree t2)
 943 {
 944   while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL)
 945     switch (TREE_CODE_CLASS (TREE_CODE (t1)))
 946       {
 947       case tcc_declaration:
 948         t1 = DECL_CONTEXT (t1); break;
 949       case tcc_type:
 950         t1 = TYPE_CONTEXT (t1); break;
 951       case tcc_exceptional:
 952         t1 = BLOCK_SUPERCONTEXT (t1); break;  /* assume block */
 953       default: gcc_unreachable ();
 954       }
 955
 956   while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL)
 957     switch (TREE_CODE_CLASS (TREE_CODE (t2)))
 958       {
 959       case tcc_declaration:
 960         t2 = DECL_CONTEXT (t2); break;
 961       case tcc_type:
 962         t2 = TYPE_CONTEXT (t2); break;
 963       case tcc_exceptional:
 964         t2 = BLOCK_SUPERCONTEXT (t2); break;  /* assume block */
 965       default: gcc_unreachable ();
 966       }
 967
 968   return t1 == t2;
 969 }
 970
 971 /* Allocate the seen two types, assuming that they are compatible. */
 972
 973 static struct tagged_tu_seen_cache *
 974 alloc_tagged_tu_seen_cache (tree t1, tree t2)
 975 {
 976   struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache);
 977   tu->next = tagged_tu_seen_base;
 978   tu->t1 = t1;
 979   tu->t2 = t2;
 980
 981   tagged_tu_seen_base = tu;
 982
 983   /* The C standard says that two structures in different translation
 984      units are compatible with each other only if the types of their
 985      fields are compatible (among other things).  We assume that they
 986      are compatible until proven otherwise when building the cache.
 987      An example where this can occur is:
 988      struct a
 989      {
 990        struct a *next;
 991      };
 992      If we are comparing this against a similar struct in another TU,
 993      and did not assume they were compatible, we end up with an infinite
 994      loop.  */
 995   tu->val = 1;
 996   return tu;
 997 }
 998
 999 /* Free the seen types until we get to TU_TIL. */
1000
1001 static void
1002 free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til)
1003 {
1004   const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base;
1005   while (tu != tu_til)
1006     {
1007       struct tagged_tu_seen_cache *tu1 = (struct tagged_tu_seen_cache*)tu;
1008       tu = tu1->next;
1009       free (tu1);
1010     }
1011   tagged_tu_seen_base = tu_til;
1012 }
1013
1014 /* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are
1015    compatible.  If the two types are not the same (which has been
1016    checked earlier), this can only happen when multiple translation
1017    units are being compiled.  See C99 6.2.7 paragraph 1 for the exact
1018    rules.  */
1019
1020 static int
1021 tagged_types_tu_compatible_p (tree t1, tree t2)
1022 {
1023   tree s1, s2;
1024   bool needs_warning = false;
1025
1026   /* We have to verify that the tags of the types are the same.  This
1027      is harder than it looks because this may be a typedef, so we have
1028      to go look at the original type.  It may even be a typedef of a
1029      typedef...
1030      In the case of compiler-created builtin structs the TYPE_DECL
1031      may be a dummy, with no DECL_ORIGINAL_TYPE.  Don't fault.  */
1032   while (TYPE_NAME (t1)
1033          && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL
1034          && DECL_ORIGINAL_TYPE (TYPE_NAME (t1)))
1035     t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1));
1036
1037   while (TYPE_NAME (t2)
1038          && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL
1039          && DECL_ORIGINAL_TYPE (TYPE_NAME (t2)))
1040     t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2));
1041
1042   /* C90 didn't have the requirement that the two tags be the same.  */
1043   if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2))
1044     return 0;
1045
1046   /* C90 didn't say what happened if one or both of the types were
1047      incomplete; we choose to follow C99 rules here, which is that they
1048      are compatible.  */
1049   if (TYPE_SIZE (t1) == NULL
1050       || TYPE_SIZE (t2) == NULL)
1051     return 1;
1052
1053   {
1054     const struct tagged_tu_seen_cache * tts_i;
1055     for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next)
1056       if (tts_i->t1 == t1 && tts_i->t2 == t2)
1057         return tts_i->val;
1058   }
1059
1060   switch (TREE_CODE (t1))
1061     {
1062     case ENUMERAL_TYPE:
1063       {
1064         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1065         /* Speed up the case where the type values are in the same order.  */
1066         tree tv1 = TYPE_VALUES (t1);
1067         tree tv2 = TYPE_VALUES (t2);
1068
1069         if (tv1 == tv2)
1070           {
1071             return 1;
1072           }
1073
1074         for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2))
1075           {
1076             if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2))
1077               break;
1078             if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1)
1079               {
1080                 tu->val = 0;
1081                 return 0;
1082               }
1083           }
1084
1085         if (tv1 == NULL_TREE && tv2 == NULL_TREE)
1086           {
1087             return 1;
1088           }
1089         if (tv1 == NULL_TREE || tv2 == NULL_TREE)
1090           {
1091             tu->val = 0;
1092             return 0;
1093           }
1094
1095         if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2)))
1096           {
1097             tu->val = 0;
1098             return 0;
1099           }
1100
1101         for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1))
1102           {
1103             s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2));
1104             if (s2 == NULL
1105                 || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1)
1106               {
1107                 tu->val = 0;
1108                 return 0;
1109               }
1110           }
1111         return 1;
1112       }
1113
1114     case UNION_TYPE:
1115       {
1116         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1117         if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2)))
1118           {
1119             tu->val = 0;
1120             return 0;
1121           }
1122
1123         /*  Speed up the common case where the fields are in the same order. */
1124         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2;
1125              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
1126           {
1127             int result;
1128
1129
1130             if (DECL_NAME (s1) == NULL
1131                 || DECL_NAME (s1) != DECL_NAME (s2))
1132               break;
1133             result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
1134             if (result == 0)
1135               {
1136                 tu->val = 0;
1137                 return 0;
1138               }
1139             if (result == 2)
1140               needs_warning = true;
1141
1142             if (TREE_CODE (s1) == FIELD_DECL
1143                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1144                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
1145               {
1146                 tu->val = 0;
1147                 return 0;
1148               }
1149           }
1150         if (!s1 && !s2)
1151           {
1152             tu->val = needs_warning ? 2 : 1;
1153             return tu->val;
1154           }
1155
1156         for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1))
1157           {
1158             bool ok = false;
1159
1160             if (DECL_NAME (s1) != NULL)
1161               for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2))
1162                 if (DECL_NAME (s1) == DECL_NAME (s2))
1163                   {
1164                     int result;
1165                     result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
1166                     if (result == 0)
1167                       {
1168                         tu->val = 0;
1169                         return 0;
1170                       }
1171                     if (result == 2)
1172                       needs_warning = true;
1173
1174                     if (TREE_CODE (s1) == FIELD_DECL
1175                         && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1176                                              DECL_FIELD_BIT_OFFSET (s2)) != 1)
1177                       break;
1178
1179                     ok = true;
1180                     break;
1181                   }
1182             if (!ok)
1183               {
1184                 tu->val = 0;
1185                 return 0;
1186               }
1187           }
1188         tu->val = needs_warning ? 2 : 10;
1189         return tu->val;
1190       }
1191
1192     case RECORD_TYPE:
1193       {
1194         struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2);
1195
1196         for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2);
1197              s1 && s2;
1198              s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2))
1199           {
1200             int result;
1201             if (TREE_CODE (s1) != TREE_CODE (s2)
1202                 || DECL_NAME (s1) != DECL_NAME (s2))
1203               break;
1204             result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2));
1205             if (result == 0)
1206               break;
1207             if (result == 2)
1208               needs_warning = true;
1209
1210             if (TREE_CODE (s1) == FIELD_DECL
1211                 && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1),
1212                                      DECL_FIELD_BIT_OFFSET (s2)) != 1)
1213               break;
1214           }
1215         if (s1 && s2)
1216           tu->val = 0;
1217         else
1218           tu->val = needs_warning ? 2 : 1;
1219         return tu->val;
1220       }
1221
1222     default:
1223       gcc_unreachable ();
1224     }
1225 }
1226
1227 /* Return 1 if two function types F1 and F2 are compatible.
1228    If either type specifies no argument types,
1229    the other must specify a fixed number of self-promoting arg types.
1230    Otherwise, if one type specifies only the number of arguments,
1231    the other must specify that number of self-promoting arg types.
1232    Otherwise, the argument types must match.  */
1233
1234 static int
1235 function_types_compatible_p (tree f1, tree f2)
1236 {
1237   tree args1, args2;
1238   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1239   int val = 1;
1240   int val1;
1241   tree ret1, ret2;
1242
1243   ret1 = TREE_TYPE (f1);
1244   ret2 = TREE_TYPE (f2);
1245
1246   /* 'volatile' qualifiers on a function's return type used to mean
1247      the function is noreturn.  */
1248   if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2))
1249     pedwarn ("function return types not compatible due to %<volatile%>");
1250   if (TYPE_VOLATILE (ret1))
1251     ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1),
1252                                  TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE);
1253   if (TYPE_VOLATILE (ret2))
1254     ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2),
1255                                  TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE);
1256   val = comptypes_internal (ret1, ret2);
1257   if (val == 0)
1258     return 0;
1259
1260   args1 = TYPE_ARG_TYPES (f1);
1261   args2 = TYPE_ARG_TYPES (f2);
1262
1263   /* An unspecified parmlist matches any specified parmlist
1264      whose argument types don't need default promotions.  */
1265
1266   if (args1 == 0)
1267     {
1268       if (!self_promoting_args_p (args2))
1269         return 0;
1270       /* If one of these types comes from a non-prototype fn definition,
1271          compare that with the other type's arglist.
1272          If they don't match, ask for a warning (but no error).  */
1273       if (TYPE_ACTUAL_ARG_TYPES (f1)
1274           && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1)))
1275         val = 2;
1276       return val;
1277     }
1278   if (args2 == 0)
1279     {
1280       if (!self_promoting_args_p (args1))
1281         return 0;
1282       if (TYPE_ACTUAL_ARG_TYPES (f2)
1283           && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2)))
1284         val = 2;
1285       return val;
1286     }
1287
1288   /* Both types have argument lists: compare them and propagate results.  */
1289   val1 = type_lists_compatible_p (args1, args2);
1290   return val1 != 1 ? val1 : val;
1291 }
1292
1293 /* Check two lists of types for compatibility,
1294    returning 0 for incompatible, 1 for compatible,
1295    or 2 for compatible with warning.  */
1296
1297 static int
1298 type_lists_compatible_p (tree args1, tree args2)
1299 {
1300   /* 1 if no need for warning yet, 2 if warning cause has been seen.  */
1301   int val = 1;
1302   int newval = 0;
1303
1304   while (1)
1305     {
1306       tree a1, mv1, a2, mv2;
1307       if (args1 == 0 && args2 == 0)
1308         return val;
1309       /* If one list is shorter than the other,
1310          they fail to match.  */
1311       if (args1 == 0 || args2 == 0)
1312         return 0;
1313       mv1 = a1 = TREE_VALUE (args1);
1314       mv2 = a2 = TREE_VALUE (args2);
1315       if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE)
1316         mv1 = TYPE_MAIN_VARIANT (mv1);
1317       if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE)
1318         mv2 = TYPE_MAIN_VARIANT (mv2);
1319       /* A null pointer instead of a type
1320          means there is supposed to be an argument
1321          but nothing is specified about what type it has.
1322          So match anything that self-promotes.  */
1323       if (a1 == 0)
1324         {
1325           if (c_type_promotes_to (a2) != a2)
1326             return 0;
1327         }
1328       else if (a2 == 0)
1329         {
1330           if (c_type_promotes_to (a1) != a1)
1331             return 0;
1332         }
1333       /* If one of the lists has an error marker, ignore this arg.  */
1334       else if (TREE_CODE (a1) == ERROR_MARK
1335                || TREE_CODE (a2) == ERROR_MARK)
1336         ;
1337       else if (!(newval = comptypes_internal (mv1, mv2)))
1338         {
1339           /* Allow  wait (union {union wait *u; int *i} *)
1340              and  wait (union wait *)  to be compatible.  */
1341           if (TREE_CODE (a1) == UNION_TYPE
1342               && (TYPE_NAME (a1) == 0
1343                   || TYPE_TRANSPARENT_UNION (a1))
1344               && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST
1345               && tree_int_cst_equal (TYPE_SIZE (a1),
1346                                      TYPE_SIZE (a2)))
1347             {
1348               tree memb;
1349               for (memb = TYPE_FIELDS (a1);
1350                    memb; memb = TREE_CHAIN (memb))
1351                 {
1352                   tree mv3 = TREE_TYPE (memb);
1353                   if (mv3 && mv3 != error_mark_node
1354                       && TREE_CODE (mv3) != ARRAY_TYPE)
1355                     mv3 = TYPE_MAIN_VARIANT (mv3);
1356                   if (comptypes_internal (mv3, mv2))
1357                     break;
1358                 }
1359               if (memb == 0)
1360                 return 0;
1361             }
1362           else if (TREE_CODE (a2) == UNION_TYPE
1363                    && (TYPE_NAME (a2) == 0
1364                        || TYPE_TRANSPARENT_UNION (a2))
1365                    && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST
1366                    && tree_int_cst_equal (TYPE_SIZE (a2),
1367                                           TYPE_SIZE (a1)))
1368             {
1369               tree memb;
1370               for (memb = TYPE_FIELDS (a2);
1371                    memb; memb = TREE_CHAIN (memb))
1372                 {
1373                   tree mv3 = TREE_TYPE (memb);
1374                   if (mv3 && mv3 != error_mark_node
1375                       && TREE_CODE (mv3) != ARRAY_TYPE)
1376                     mv3 = TYPE_MAIN_VARIANT (mv3);
1377                   if (comptypes_internal (mv3, mv1))
1378                     break;
1379                 }
1380               if (memb == 0)
1381                 return 0;
1382             }
1383           else
1384             return 0;
1385         }
1386
1387       /* comptypes said ok, but record if it said to warn.  */
1388       if (newval > val)
1389         val = newval;
1390
1391       args1 = TREE_CHAIN (args1);
1392       args2 = TREE_CHAIN (args2);
1393     }
1394 }
1395 \f
1396 /* Compute the size to increment a pointer by.  */
1397
1398 static tree
1399 c_size_in_bytes (tree type)
1400 {
1401   enum tree_code code = TREE_CODE (type);
1402
1403   if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK)
1404     return size_one_node;
1405
1406   if (!COMPLETE_OR_VOID_TYPE_P (type))
1407     {
1408       error ("arithmetic on pointer to an incomplete type");
1409       return size_one_node;
1410     }
1411
1412   /* Convert in case a char is more than one unit.  */
1413   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
1414                      size_int (TYPE_PRECISION (char_type_node)
1415                                / BITS_PER_UNIT));
1416 }
1417 \f
1418 /* Return either DECL or its known constant value (if it has one).  */
1419
1420 tree
1421 decl_constant_value (tree decl)
1422 {
1423   if (/* Don't change a variable array bound or initial value to a constant
1424          in a place where a variable is invalid.  Note that DECL_INITIAL
1425          isn't valid for a PARM_DECL.  */
1426       current_function_decl != 0
1427       && TREE_CODE (decl) != PARM_DECL
1428       && !TREE_THIS_VOLATILE (decl)
1429       && TREE_READONLY (decl)
1430       && DECL_INITIAL (decl) != 0
1431       && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK
1432       /* This is invalid if initial value is not constant.
1433          If it has either a function call, a memory reference,
1434          or a variable, then re-evaluating it could give different results.  */
1435       && TREE_CONSTANT (DECL_INITIAL (decl))
1436       /* Check for cases where this is sub-optimal, even though valid.  */
1437       && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR)
1438     return DECL_INITIAL (decl);
1439   return decl;
1440 }
1441
1442 /* Return either DECL or its known constant value (if it has one), but
1443    return DECL if pedantic or DECL has mode BLKmode.  This is for
1444    bug-compatibility with the old behavior of decl_constant_value
1445    (before GCC 3.0); every use of this function is a bug and it should
1446    be removed before GCC 3.1.  It is not appropriate to use pedantic
1447    in a way that affects optimization, and BLKmode is probably not the
1448    right test for avoiding misoptimizations either.  */
1449
1450 static tree
1451 decl_constant_value_for_broken_optimization (tree decl)
1452 {
1453   tree ret;
1454
1455   if (pedantic || DECL_MODE (decl) == BLKmode)
1456     return decl;
1457
1458   ret = decl_constant_value (decl);
1459   /* Avoid unwanted tree sharing between the initializer and current
1460      function's body where the tree can be modified e.g. by the
1461      gimplifier.  */
1462   if (ret != decl && TREE_STATIC (decl))
1463     ret = unshare_expr (ret);
1464   return ret;
1465 }
1466
1467 /* Convert the array expression EXP to a pointer.  */
1468 static tree
1469 array_to_pointer_conversion (tree exp)
1470 {
1471   tree orig_exp = exp;
1472   tree type = TREE_TYPE (exp);
1473   tree adr;
1474   tree restype = TREE_TYPE (type);
1475   tree ptrtype;
1476
1477   gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
1478
1479   STRIP_TYPE_NOPS (exp);
1480
1481   if (TREE_NO_WARNING (orig_exp))
1482     TREE_NO_WARNING (exp) = 1;
1483
1484   ptrtype = build_pointer_type (restype);
1485
1486   if (TREE_CODE (exp) == INDIRECT_REF)
1487     return convert (ptrtype, TREE_OPERAND (exp, 0));
1488
1489   if (TREE_CODE (exp) == VAR_DECL)
1490     {
1491       /* We are making an ADDR_EXPR of ptrtype.  This is a valid
1492          ADDR_EXPR because it's the best way of representing what
1493          happens in C when we take the address of an array and place
1494          it in a pointer to the element type.  */
1495       adr = build1 (ADDR_EXPR, ptrtype, exp);
1496       if (!c_mark_addressable (exp))
1497         return error_mark_node;
1498       TREE_SIDE_EFFECTS (adr) = 0;   /* Default would be, same as EXP.  */
1499       return adr;
1500     }
1501
1502   /* This way is better for a COMPONENT_REF since it can
1503      simplify the offset for a component.  */
1504   adr = build_unary_op (ADDR_EXPR, exp, 1);
1505   return convert (ptrtype, adr);
1506 }
1507
1508 /* Convert the function expression EXP to a pointer.  */
1509 static tree
1510 function_to_pointer_conversion (tree exp)
1511 {
1512   tree orig_exp = exp;
1513
1514   gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE);
1515
1516   STRIP_TYPE_NOPS (exp);
1517
1518   if (TREE_NO_WARNING (orig_exp))
1519     TREE_NO_WARNING (exp) = 1;
1520
1521   return build_unary_op (ADDR_EXPR, exp, 0);
1522 }
1523
1524 /* Perform the default conversion of arrays and functions to pointers.
1525    Return the result of converting EXP.  For any other expression, just
1526    return EXP after removing NOPs.  */
1527
1528 struct c_expr
1529 default_function_array_conversion (struct c_expr exp)
1530 {
1531   tree orig_exp = exp.value;
1532   tree type = TREE_TYPE (exp.value);
1533   enum tree_code code = TREE_CODE (type);
1534
1535   switch (code)
1536     {
1537     case ARRAY_TYPE:
1538       {
1539         bool not_lvalue = false;
1540         bool lvalue_array_p;
1541
1542         while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR
1543                 || TREE_CODE (exp.value) == NOP_EXPR
1544                 || TREE_CODE (exp.value) == CONVERT_EXPR)
1545                && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type)
1546           {
1547             if (TREE_CODE (exp.value) == NON_LVALUE_EXPR)
1548               not_lvalue = true;
1549             exp.value = TREE_OPERAND (exp.value, 0);
1550           }
1551
1552         if (TREE_NO_WARNING (orig_exp))
1553           TREE_NO_WARNING (exp.value) = 1;
1554
1555         lvalue_array_p = !not_lvalue && lvalue_p (exp.value);
1556         if (!flag_isoc99 && !lvalue_array_p)
1557           {
1558             /* Before C99, non-lvalue arrays do not decay to pointers.
1559                Normally, using such an array would be invalid; but it can
1560                be used correctly inside sizeof or as a statement expression.
1561                Thus, do not give an error here; an error will result later.  */
1562             return exp;
1563           }
1564
1565         exp.value = array_to_pointer_conversion (exp.value);
1566       }
1567       break;
1568     case FUNCTION_TYPE:
1569       exp.value = function_to_pointer_conversion (exp.value);
1570       break;
1571     default:
1572       STRIP_TYPE_NOPS (exp.value);
1573       if (TREE_NO_WARNING (orig_exp))
1574         TREE_NO_WARNING (exp.value) = 1;
1575       break;
1576     }
1577
1578   return exp;
1579 }
1580
1581
1582 /* EXP is an expression of integer type.  Apply the integer promotions
1583    to it and return the promoted value.  */
1584
1585 tree
1586 perform_integral_promotions (tree exp)
1587 {
1588   tree type = TREE_TYPE (exp);
1589   enum tree_code code = TREE_CODE (type);
1590
1591   gcc_assert (INTEGRAL_TYPE_P (type));
1592
1593   /* Normally convert enums to int,
1594      but convert wide enums to something wider.  */
1595   if (code == ENUMERAL_TYPE)
1596     {
1597       type = c_common_type_for_size (MAX (TYPE_PRECISION (type),
1598                                           TYPE_PRECISION (integer_type_node)),
1599                                      ((TYPE_PRECISION (type)
1600                                        >= TYPE_PRECISION (integer_type_node))
1601                                       && TYPE_UNSIGNED (type)));
1602
1603       return convert (type, exp);
1604     }
1605
1606   /* ??? This should no longer be needed now bit-fields have their
1607      proper types.  */
1608   if (TREE_CODE (exp) == COMPONENT_REF
1609       && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1))
1610       /* If it's thinner than an int, promote it like a
1611          c_promoting_integer_type_p, otherwise leave it alone.  */
1612       && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)),
1613                                TYPE_PRECISION (integer_type_node)))
1614     return convert (integer_type_node, exp);
1615
1616   if (c_promoting_integer_type_p (type))
1617     {
1618       /* Preserve unsignedness if not really getting any wider.  */
1619       if (TYPE_UNSIGNED (type)
1620           && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
1621         return convert (unsigned_type_node, exp);
1622
1623       return convert (integer_type_node, exp);
1624     }
1625
1626   return exp;
1627 }
1628
1629
1630 /* Perform default promotions for C data used in expressions.
1631    Enumeral types or short or char are converted to int.
1632    In addition, manifest constants symbols are replaced by their values.  */
1633
1634 tree
1635 default_conversion (tree exp)
1636 {
1637   tree orig_exp;
1638   tree type = TREE_TYPE (exp);
1639   enum tree_code code = TREE_CODE (type);
1640
1641   /* Functions and arrays have been converted during parsing.  */
1642   gcc_assert (code != FUNCTION_TYPE);
1643   if (code == ARRAY_TYPE)
1644     return exp;
1645
1646   /* Constants can be used directly unless they're not loadable.  */
1647   if (TREE_CODE (exp) == CONST_DECL)
1648     exp = DECL_INITIAL (exp);
1649
1650   /* Replace a nonvolatile const static variable with its value unless
1651      it is an array, in which case we must be sure that taking the
1652      address of the array produces consistent results.  */
1653   else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE)
1654     {
1655       exp = decl_constant_value_for_broken_optimization (exp);
1656       type = TREE_TYPE (exp);
1657     }
1658
1659   /* Strip no-op conversions.  */
1660   orig_exp = exp;
1661   STRIP_TYPE_NOPS (exp);
1662
1663   if (TREE_NO_WARNING (orig_exp))
1664     TREE_NO_WARNING (exp) = 1;
1665
1666   if (INTEGRAL_TYPE_P (type))
1667     return perform_integral_promotions (exp);
1668
1669   if (code == VOID_TYPE)
1670     {
1671       error ("void value not ignored as it ought to be");
1672       return error_mark_node;
1673     }
1674   return exp;
1675 }
1676 \f
1677 /* Look up COMPONENT in a structure or union DECL.
1678
1679    If the component name is not found, returns NULL_TREE.  Otherwise,
1680    the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL
1681    stepping down the chain to the component, which is in the last
1682    TREE_VALUE of the list.  Normally the list is of length one, but if
1683    the component is embedded within (nested) anonymous structures or
1684    unions, the list steps down the chain to the component.  */
1685
1686 static tree
1687 lookup_field (tree decl, tree component)
1688 {
1689   tree type = TREE_TYPE (decl);
1690   tree field;
1691
1692   /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers
1693      to the field elements.  Use a binary search on this array to quickly
1694      find the element.  Otherwise, do a linear search.  TYPE_LANG_SPECIFIC
1695      will always be set for structures which have many elements.  */
1696
1697   if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s)
1698     {
1699       int bot, top, half;
1700       tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0];
1701
1702       field = TYPE_FIELDS (type);
1703       bot = 0;
1704       top = TYPE_LANG_SPECIFIC (type)->s->len;
1705       while (top - bot > 1)
1706         {
1707           half = (top - bot + 1) >> 1;
1708           field = field_array[bot+half];
1709
1710           if (DECL_NAME (field) == NULL_TREE)
1711             {
1712               /* Step through all anon unions in linear fashion.  */
1713               while (DECL_NAME (field_array[bot]) == NULL_TREE)
1714                 {
1715                   field = field_array[bot++];
1716                   if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1717                       || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
1718                     {
1719                       tree anon = lookup_field (field, component);
1720
1721                       if (anon)
1722                         return tree_cons (NULL_TREE, field, anon);
1723                     }
1724                 }
1725
1726               /* Entire record is only anon unions.  */
1727               if (bot > top)
1728                 return NULL_TREE;
1729
1730               /* Restart the binary search, with new lower bound.  */
1731               continue;
1732             }
1733
1734           if (DECL_NAME (field) == component)
1735             break;
1736           if (DECL_NAME (field) < component)
1737             bot += half;
1738           else
1739             top = bot + half;
1740         }
1741
1742       if (DECL_NAME (field_array[bot]) == component)
1743         field = field_array[bot];
1744       else if (DECL_NAME (field) != component)
1745         return NULL_TREE;
1746     }
1747   else
1748     {
1749       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
1750         {
1751           if (DECL_NAME (field) == NULL_TREE
1752               && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
1753                   || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE))
1754             {
1755               tree anon = lookup_field (field, component);
1756
1757               if (anon)
1758                 return tree_cons (NULL_TREE, field, anon);
1759             }
1760
1761           if (DECL_NAME (field) == component)
1762             break;
1763         }
1764
1765       if (field == NULL_TREE)
1766         return NULL_TREE;
1767     }
1768
1769   return tree_cons (NULL_TREE, field, NULL_TREE);
1770 }
1771
1772 /* Make an expression to refer to the COMPONENT field of
1773    structure or union value DATUM.  COMPONENT is an IDENTIFIER_NODE.  */
1774
1775 tree
1776 build_component_ref (tree datum, tree component)
1777 {
1778   tree type = TREE_TYPE (datum);
1779   enum tree_code code = TREE_CODE (type);
1780   tree field = NULL;
1781   tree ref;
1782
1783   if (!objc_is_public (datum, component))
1784     return error_mark_node;
1785
1786   /* See if there is a field or component with name COMPONENT.  */
1787
1788   if (code == RECORD_TYPE || code == UNION_TYPE)
1789     {
1790       if (!COMPLETE_TYPE_P (type))
1791         {
1792           c_incomplete_type_error (NULL_TREE, type);
1793           return error_mark_node;
1794         }
1795
1796       field = lookup_field (datum, component);
1797
1798       if (!field)
1799         {
1800           error ("%qT has no member named %qE", type, component);
1801           return error_mark_node;
1802         }
1803
1804       /* Chain the COMPONENT_REFs if necessary down to the FIELD.
1805          This might be better solved in future the way the C++ front
1806          end does it - by giving the anonymous entities each a
1807          separate name and type, and then have build_component_ref
1808          recursively call itself.  We can't do that here.  */
1809       do
1810         {
1811           tree subdatum = TREE_VALUE (field);
1812           int quals;
1813           tree subtype;
1814
1815           if (TREE_TYPE (subdatum) == error_mark_node)
1816             return error_mark_node;
1817
1818           quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum)));
1819           quals |= TYPE_QUALS (TREE_TYPE (datum));
1820           subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals);
1821
1822           ref = build3 (COMPONENT_REF, subtype, datum, subdatum,
1823                         NULL_TREE);
1824           if (TREE_READONLY (datum) || TREE_READONLY (subdatum))
1825             TREE_READONLY (ref) = 1;
1826           if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
1827             TREE_THIS_VOLATILE (ref) = 1;
1828
1829           if (TREE_DEPRECATED (subdatum))
1830             warn_deprecated_use (subdatum);
1831
1832           datum = ref;
1833
1834           field = TREE_CHAIN (field);
1835         }
1836       while (field);
1837
1838       return ref;
1839     }
1840   else if (code != ERROR_MARK)
1841     error ("request for member %qE in something not a structure or union",
1842            component);
1843
1844   return error_mark_node;
1845 }
1846 \f
1847 /* Given an expression PTR for a pointer, return an expression
1848    for the value pointed to.
1849    ERRORSTRING is the name of the operator to appear in error messages.  */
1850
1851 tree
1852 build_indirect_ref (tree ptr, const char *errorstring)
1853 {
1854   tree pointer = default_conversion (ptr);
1855   tree type = TREE_TYPE (pointer);
1856
1857   if (TREE_CODE (type) == POINTER_TYPE)
1858     {
1859       if (TREE_CODE (pointer) == ADDR_EXPR
1860           && (TREE_TYPE (TREE_OPERAND (pointer, 0))
1861               == TREE_TYPE (type)))
1862         return TREE_OPERAND (pointer, 0);
1863       else
1864         {
1865           tree t = TREE_TYPE (type);
1866           tree ref;
1867
1868           ref = build1 (INDIRECT_REF, t, pointer);
1869
1870           if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE)
1871             {
1872               error ("dereferencing pointer to incomplete type");
1873               return error_mark_node;
1874             }
1875           if (VOID_TYPE_P (t) && skip_evaluation == 0)
1876             warning (0, "dereferencing %<void *%> pointer");
1877
1878           /* We *must* set TREE_READONLY when dereferencing a pointer to const,
1879              so that we get the proper error message if the result is used
1880              to assign to.  Also, &* is supposed to be a no-op.
1881              And ANSI C seems to specify that the type of the result
1882              should be the const type.  */
1883           /* A de-reference of a pointer to const is not a const.  It is valid
1884              to change it via some other pointer.  */
1885           TREE_READONLY (ref) = TYPE_READONLY (t);
1886           TREE_SIDE_EFFECTS (ref)
1887             = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
1888           TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
1889           return ref;
1890         }
1891     }
1892   else if (TREE_CODE (pointer) != ERROR_MARK)
1893     error ("invalid type argument of %qs", errorstring);
1894   return error_mark_node;
1895 }
1896
1897 /* This handles expressions of the form "a[i]", which denotes
1898    an array reference.
1899
1900    This is logically equivalent in C to *(a+i), but we may do it differently.
1901    If A is a variable or a member, we generate a primitive ARRAY_REF.
1902    This avoids forcing the array out of registers, and can work on
1903    arrays that are not lvalues (for example, members of structures returned
1904    by functions).  */
1905
1906 tree
1907 build_array_ref (tree array, tree index)
1908 {
1909   bool swapped = false;
1910   if (TREE_TYPE (array) == error_mark_node
1911       || TREE_TYPE (index) == error_mark_node)
1912     return error_mark_node;
1913
1914   if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE
1915       && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE)
1916     {
1917       tree temp;
1918       if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE
1919           && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE)
1920         {
1921           error ("subscripted value is neither array nor pointer");
1922           return error_mark_node;
1923         }
1924       temp = array;
1925       array = index;
1926       index = temp;
1927       swapped = true;
1928     }
1929
1930   if (!INTEGRAL_TYPE_P (TREE_TYPE (index)))
1931     {
1932       error ("array subscript is not an integer");
1933       return error_mark_node;
1934     }
1935
1936   if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE)
1937     {
1938       error ("subscripted value is pointer to function");
1939       return error_mark_node;
1940     }
1941
1942   /* ??? Existing practice has been to warn only when the char
1943      index is syntactically the index, not for char[array].  */
1944   if (!swapped)
1945      warn_array_subscript_with_type_char (index);
1946
1947   /* Apply default promotions *after* noticing character types.  */
1948   index = default_conversion (index);
1949
1950   gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE);
1951
1952   if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE)
1953     {
1954       tree rval, type;
1955
1956       /* An array that is indexed by a non-constant
1957          cannot be stored in a register; we must be able to do
1958          address arithmetic on its address.
1959          Likewise an array of elements of variable size.  */
1960       if (TREE_CODE (index) != INTEGER_CST
1961           || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array)))
1962               && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
1963         {
1964           if (!c_mark_addressable (array))
1965             return error_mark_node;
1966         }
1967       /* An array that is indexed by a constant value which is not within
1968          the array bounds cannot be stored in a register either; because we
1969          would get a crash in store_bit_field/extract_bit_field when trying
1970          to access a non-existent part of the register.  */
1971       if (TREE_CODE (index) == INTEGER_CST
1972           && TYPE_DOMAIN (TREE_TYPE (array))
1973           && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array))))
1974         {
1975           if (!c_mark_addressable (array))
1976             return error_mark_node;
1977         }
1978
1979       if (pedantic)
1980         {
1981           tree foo = array;
1982           while (TREE_CODE (foo) == COMPONENT_REF)
1983             foo = TREE_OPERAND (foo, 0);
1984           if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo))
1985             pedwarn ("ISO C forbids subscripting %<register%> array");
1986           else if (!flag_isoc99 && !lvalue_p (foo))
1987             pedwarn ("ISO C90 forbids subscripting non-lvalue array");
1988         }
1989
1990       type = TREE_TYPE (TREE_TYPE (array));
1991       if (TREE_CODE (type) != ARRAY_TYPE)
1992         type = TYPE_MAIN_VARIANT (type);
1993       rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE);
1994       /* Array ref is const/volatile if the array elements are
1995          or if the array is.  */
1996       TREE_READONLY (rval)
1997         |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array)))
1998             | TREE_READONLY (array));
1999       TREE_SIDE_EFFECTS (rval)
2000         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2001             | TREE_SIDE_EFFECTS (array));
2002       TREE_THIS_VOLATILE (rval)
2003         |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array)))
2004             /* This was added by rms on 16 Nov 91.
2005                It fixes  vol struct foo *a;  a->elts[1]
2006                in an inline function.
2007                Hope it doesn't break something else.  */
2008             | TREE_THIS_VOLATILE (array));
2009       return require_complete_type (fold (rval));
2010     }
2011   else
2012     {
2013       tree ar = default_conversion (array);
2014
2015       if (ar == error_mark_node)
2016         return ar;
2017
2018       gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE);
2019       gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE);
2020
2021       return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0),
2022                                  "array indexing");
2023     }
2024 }
2025 \f
2026 /* Build an external reference to identifier ID.  FUN indicates
2027    whether this will be used for a function call.  LOC is the source
2028    location of the identifier.  */
2029 tree
2030 build_external_ref (tree id, int fun, location_t loc)
2031 {
2032   tree ref;
2033   tree decl = lookup_name (id);
2034
2035   /* In Objective-C, an instance variable (ivar) may be preferred to
2036      whatever lookup_name() found.  */
2037   decl = objc_lookup_ivar (decl, id);
2038
2039   if (decl && decl != error_mark_node)
2040     ref = decl;
2041   else if (fun)
2042     /* Implicit function declaration.  */
2043     ref = implicitly_declare (id);
2044   else if (decl == error_mark_node)
2045     /* Don't complain about something that's already been
2046        complained about.  */
2047     return error_mark_node;
2048   else
2049     {
2050       undeclared_variable (id, loc);
2051       return error_mark_node;
2052     }
2053
2054   if (TREE_TYPE (ref) == error_mark_node)
2055     return error_mark_node;
2056
2057   if (TREE_DEPRECATED (ref))
2058     warn_deprecated_use (ref);
2059
2060   if (!skip_evaluation)
2061     assemble_external (ref);
2062   TREE_USED (ref) = 1;
2063
2064   if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof)
2065     {
2066       if (!in_sizeof && !in_typeof)
2067         C_DECL_USED (ref) = 1;
2068       else if (DECL_INITIAL (ref) == 0
2069                && DECL_EXTERNAL (ref)
2070                && !TREE_PUBLIC (ref))
2071         record_maybe_used_decl (ref);
2072     }
2073
2074   if (TREE_CODE (ref) == CONST_DECL)
2075     {
2076       used_types_insert (TREE_TYPE (ref));
2077       ref = DECL_INITIAL (ref);
2078       TREE_CONSTANT (ref) = 1;
2079       TREE_INVARIANT (ref) = 1;
2080     }
2081   else if (current_function_decl != 0
2082            && !DECL_FILE_SCOPE_P (current_function_decl)
2083            && (TREE_CODE (ref) == VAR_DECL
2084                || TREE_CODE (ref) == PARM_DECL
2085                || TREE_CODE (ref) == FUNCTION_DECL))
2086     {
2087       tree context = decl_function_context (ref);
2088
2089       if (context != 0 && context != current_function_decl)
2090         DECL_NONLOCAL (ref) = 1;
2091     }
2092
2093   return ref;
2094 }
2095
2096 /* Record details of decls possibly used inside sizeof or typeof.  */
2097 struct maybe_used_decl
2098 {
2099   /* The decl.  */
2100   tree decl;
2101   /* The level seen at (in_sizeof + in_typeof).  */
2102   int level;
2103   /* The next one at this level or above, or NULL.  */
2104   struct maybe_used_decl *next;
2105 };
2106
2107 static struct maybe_used_decl *maybe_used_decls;
2108
2109 /* Record that DECL, an undefined static function reference seen
2110    inside sizeof or typeof, might be used if the operand of sizeof is
2111    a VLA type or the operand of typeof is a variably modified
2112    type.  */
2113
2114 static void
2115 record_maybe_used_decl (tree decl)
2116 {
2117   struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl);
2118   t->decl = decl;
2119   t->level = in_sizeof + in_typeof;
2120   t->next = maybe_used_decls;
2121   maybe_used_decls = t;
2122 }
2123
2124 /* Pop the stack of decls possibly used inside sizeof or typeof.  If
2125    USED is false, just discard them.  If it is true, mark them used
2126    (if no longer inside sizeof or typeof) or move them to the next
2127    level up (if still inside sizeof or typeof).  */
2128
2129 void
2130 pop_maybe_used (bool used)
2131 {
2132   struct maybe_used_decl *p = maybe_used_decls;
2133   int cur_level = in_sizeof + in_typeof;
2134   while (p && p->level > cur_level)
2135     {
2136       if (used)
2137         {
2138           if (cur_level == 0)
2139             C_DECL_USED (p->decl) = 1;
2140           else
2141             p->level = cur_level;
2142         }
2143       p = p->next;
2144     }
2145   if (!used || cur_level == 0)
2146     maybe_used_decls = p;
2147 }
2148
2149 /* Return the result of sizeof applied to EXPR.  */
2150
2151 struct c_expr
2152 c_expr_sizeof_expr (struct c_expr expr)
2153 {
2154   struct c_expr ret;
2155   if (expr.value == error_mark_node)
2156     {
2157       ret.value = error_mark_node;
2158       ret.original_code = ERROR_MARK;
2159       pop_maybe_used (false);
2160     }
2161   else
2162     {
2163       ret.value = c_sizeof (TREE_TYPE (expr.value));
2164       ret.original_code = ERROR_MARK;
2165       if (c_vla_type_p (TREE_TYPE (expr.value)))
2166         {
2167           /* sizeof is evaluated when given a vla (C99 6.5.3.4p2).  */
2168           ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value);
2169         }
2170       pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value)));
2171     }
2172   return ret;
2173 }
2174
2175 /* Return the result of sizeof applied to T, a structure for the type
2176    name passed to sizeof (rather than the type itself).  */
2177
2178 struct c_expr
2179 c_expr_sizeof_type (struct c_type_name *t)
2180 {
2181   tree type;
2182   struct c_expr ret;
2183   type = groktypename (t);
2184   ret.value = c_sizeof (type);
2185   ret.original_code = ERROR_MARK;
2186   pop_maybe_used (type != error_mark_node
2187                   ? C_TYPE_VARIABLE_SIZE (type) : false);
2188   return ret;
2189 }
2190
2191 /* Build a function call to function FUNCTION with parameters PARAMS.
2192    PARAMS is a list--a chain of TREE_LIST nodes--in which the
2193    TREE_VALUE of each node is a parameter-expression.
2194    FUNCTION's data type may be a function type or a pointer-to-function.  */
2195
2196 tree
2197 build_function_call (tree function, tree params)
2198 {
2199   tree fntype, fundecl = 0;
2200   tree coerced_params;
2201   tree name = NULL_TREE, result;
2202   tree tem;
2203
2204   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
2205   STRIP_TYPE_NOPS (function);
2206
2207   /* Convert anything with function type to a pointer-to-function.  */
2208   if (TREE_CODE (function) == FUNCTION_DECL)
2209     {
2210       /* Implement type-directed function overloading for builtins.
2211          resolve_overloaded_builtin and targetm.resolve_overloaded_builtin
2212          handle all the type checking.  The result is a complete expression
2213          that implements this function call.  */
2214       tem = resolve_overloaded_builtin (function, params);
2215       if (tem)
2216         return tem;
2217
2218       name = DECL_NAME (function);
2219       fundecl = function;
2220     }
2221   if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
2222     function = function_to_pointer_conversion (function);
2223
2224   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2225      expressions, like those used for ObjC messenger dispatches.  */
2226   function = objc_rewrite_function_call (function, params);
2227
2228   fntype = TREE_TYPE (function);
2229
2230   if (TREE_CODE (fntype) == ERROR_MARK)
2231     return error_mark_node;
2232
2233   if (!(TREE_CODE (fntype) == POINTER_TYPE
2234         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
2235     {
2236       error ("called object %qE is not a function", function);
2237       return error_mark_node;
2238     }
2239
2240   if (fundecl && TREE_THIS_VOLATILE (fundecl))
2241     current_function_returns_abnormally = 1;
2242
2243   /* fntype now gets the type of function pointed to.  */
2244   fntype = TREE_TYPE (fntype);
2245
2246   /* Check that the function is called through a compatible prototype.
2247      If it is not, replace the call by a trap, wrapped up in a compound
2248      expression if necessary.  This has the nice side-effect to prevent
2249      the tree-inliner from generating invalid assignment trees which may
2250      blow up in the RTL expander later.  */
2251   if ((TREE_CODE (function) == NOP_EXPR
2252        || TREE_CODE (function) == CONVERT_EXPR)
2253       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
2254       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
2255       && !comptypes (fntype, TREE_TYPE (tem)))
2256     {
2257       tree return_type = TREE_TYPE (fntype);
2258       tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP],
2259                                        NULL_TREE);
2260
2261       /* This situation leads to run-time undefined behavior.  We can't,
2262          therefore, simply error unless we can prove that all possible
2263          executions of the program must execute the code.  */
2264       warning (0, "function called through a non-compatible type");
2265
2266       /* We can, however, treat "undefined" any way we please.
2267          Call abort to encourage the user to fix the program.  */
2268       inform ("if this code is reached, the program will abort");
2269
2270       if (VOID_TYPE_P (return_type))
2271         return trap;
2272       else
2273         {
2274           tree rhs;
2275
2276           if (AGGREGATE_TYPE_P (return_type))
2277             rhs = build_compound_literal (return_type,
2278                                           build_constructor (return_type, 0));
2279           else
2280             rhs = fold_convert (return_type, integer_zero_node);
2281
2282           return build2 (COMPOUND_EXPR, return_type, trap, rhs);
2283         }
2284     }
2285
2286   /* Convert the parameters to the types declared in the
2287      function prototype, or apply default promotions.  */
2288
2289   coerced_params
2290     = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl);
2291
2292   if (coerced_params == error_mark_node)
2293     return error_mark_node;
2294
2295   /* Check that the arguments to the function are valid.  */
2296
2297   check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params,
2298                             TYPE_ARG_TYPES (fntype));
2299
2300   if (require_constant_value)
2301     {
2302       result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype),
2303                                         function, coerced_params, NULL_TREE);
2304
2305       if (TREE_CONSTANT (result)
2306           && (name == NULL_TREE
2307               || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0))
2308         pedwarn_init ("initializer element is not constant");
2309     }
2310   else
2311     result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype),
2312                           function, coerced_params, NULL_TREE);
2313
2314   if (VOID_TYPE_P (TREE_TYPE (result)))
2315     return result;
2316   return require_complete_type (result);
2317 }
2318 \f
2319 /* Convert the argument expressions in the list VALUES
2320    to the types in the list TYPELIST.  The result is a list of converted
2321    argument expressions, unless there are too few arguments in which
2322    case it is error_mark_node.
2323
2324    If TYPELIST is exhausted, or when an element has NULL as its type,
2325    perform the default conversions.
2326
2327    PARMLIST is the chain of parm decls for the function being called.
2328    It may be 0, if that info is not available.
2329    It is used only for generating error messages.
2330
2331    FUNCTION is a tree for the called function.  It is used only for
2332    error messages, where it is formatted with %qE.
2333
2334    This is also where warnings about wrong number of args are generated.
2335
2336    Both VALUES and the returned value are chains of TREE_LIST nodes
2337    with the elements of the list in the TREE_VALUE slots of those nodes.  */
2338
2339 static tree
2340 convert_arguments (tree typelist, tree values, tree function, tree fundecl)
2341 {
2342   tree typetail, valtail;
2343   tree result = NULL;
2344   int parmnum;
2345   tree selector;
2346
2347   /* Change pointer to function to the function itself for
2348      diagnostics.  */
2349   if (TREE_CODE (function) == ADDR_EXPR
2350       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2351     function = TREE_OPERAND (function, 0);
2352
2353   /* Handle an ObjC selector specially for diagnostics.  */
2354   selector = objc_message_selector ();
2355
2356   /* Scan the given expressions and types, producing individual
2357      converted arguments and pushing them on RESULT in reverse order.  */
2358
2359   for (valtail = values, typetail = typelist, parmnum = 0;
2360        valtail;
2361        valtail = TREE_CHAIN (valtail), parmnum++)
2362     {
2363       tree type = typetail ? TREE_VALUE (typetail) : 0;
2364       tree val = TREE_VALUE (valtail);
2365       tree rname = function;
2366       int argnum = parmnum + 1;
2367       const char *invalid_func_diag;
2368
2369       if (type == void_type_node)
2370         {
2371           error ("too many arguments to function %qE", function);
2372           break;
2373         }
2374
2375       if (selector && argnum > 2)
2376         {
2377           rname = selector;
2378           argnum -= 2;
2379         }
2380
2381       STRIP_TYPE_NOPS (val);
2382
2383       val = require_complete_type (val);
2384
2385       if (type != 0)
2386         {
2387           /* Formal parm type is specified by a function prototype.  */
2388           tree parmval;
2389
2390           if (type == error_mark_node || !COMPLETE_TYPE_P (type))
2391             {
2392               error ("type of formal parameter %d is incomplete", parmnum + 1);
2393               parmval = val;
2394             }
2395           else
2396             {
2397               /* Optionally warn about conversions that
2398                  differ from the default conversions.  */
2399               if (warn_conversion || warn_traditional)
2400                 {
2401                   unsigned int formal_prec = TYPE_PRECISION (type);
2402
2403                   if (INTEGRAL_TYPE_P (type)
2404                       && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2405                     warning (0, "passing argument %d of %qE as integer "
2406                              "rather than floating due to prototype",
2407                              argnum, rname);
2408                   if (INTEGRAL_TYPE_P (type)
2409                       && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2410                     warning (0, "passing argument %d of %qE as integer "
2411                              "rather than complex due to prototype",
2412                              argnum, rname);
2413                   else if (TREE_CODE (type) == COMPLEX_TYPE
2414                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2415                     warning (0, "passing argument %d of %qE as complex "
2416                              "rather than floating due to prototype",
2417                              argnum, rname);
2418                   else if (TREE_CODE (type) == REAL_TYPE
2419                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2420                     warning (0, "passing argument %d of %qE as floating "
2421                              "rather than integer due to prototype",
2422                              argnum, rname);
2423                   else if (TREE_CODE (type) == COMPLEX_TYPE
2424                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2425                     warning (0, "passing argument %d of %qE as complex "
2426                              "rather than integer due to prototype",
2427                              argnum, rname);
2428                   else if (TREE_CODE (type) == REAL_TYPE
2429                            && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE)
2430                     warning (0, "passing argument %d of %qE as floating "
2431                              "rather than complex due to prototype",
2432                              argnum, rname);
2433                   /* ??? At some point, messages should be written about
2434                      conversions between complex types, but that's too messy
2435                      to do now.  */
2436                   else if (TREE_CODE (type) == REAL_TYPE
2437                            && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE)
2438                     {
2439                       /* Warn if any argument is passed as `float',
2440                          since without a prototype it would be `double'.  */
2441                       if (formal_prec == TYPE_PRECISION (float_type_node)
2442                           && type != dfloat32_type_node)
2443                         warning (0, "passing argument %d of %qE as %<float%> "
2444                                  "rather than %<double%> due to prototype",
2445                                  argnum, rname);
2446
2447                       /* Warn if mismatch between argument and prototype
2448                          for decimal float types.  Warn of conversions with
2449                          binary float types and of precision narrowing due to
2450                          prototype. */
2451                       else if (type != TREE_TYPE (val)
2452                                && (type == dfloat32_type_node
2453                                    || type == dfloat64_type_node
2454                                    || type == dfloat128_type_node
2455                                    || TREE_TYPE (val) == dfloat32_type_node
2456                                    || TREE_TYPE (val) == dfloat64_type_node
2457                                    || TREE_TYPE (val) == dfloat128_type_node)
2458                                && (formal_prec
2459                                    <= TYPE_PRECISION (TREE_TYPE (val))
2460                                    || (type == dfloat128_type_node
2461                                        && (TREE_TYPE (val)
2462                                            != dfloat64_type_node
2463                                            && (TREE_TYPE (val)
2464                                                != dfloat32_type_node)))
2465                                    || (type == dfloat64_type_node
2466                                        && (TREE_TYPE (val)
2467                                            != dfloat32_type_node))))
2468                         warning (0, "passing argument %d of %qE as %qT "
2469                                  "rather than %qT due to prototype",
2470                                  argnum, rname, type, TREE_TYPE (val));
2471
2472                     }
2473                   /* Detect integer changing in width or signedness.
2474                      These warnings are only activated with
2475                      -Wconversion, not with -Wtraditional.  */
2476                   else if (warn_conversion && INTEGRAL_TYPE_P (type)
2477                            && INTEGRAL_TYPE_P (TREE_TYPE (val)))
2478                     {
2479                       tree would_have_been = default_conversion (val);
2480                       tree type1 = TREE_TYPE (would_have_been);
2481
2482                       if (TREE_CODE (type) == ENUMERAL_TYPE
2483                           && (TYPE_MAIN_VARIANT (type)
2484                               == TYPE_MAIN_VARIANT (TREE_TYPE (val))))
2485                         /* No warning if function asks for enum
2486                            and the actual arg is that enum type.  */
2487                         ;
2488                       else if (formal_prec != TYPE_PRECISION (type1))
2489                         warning (OPT_Wconversion, "passing argument %d of %qE "
2490                                  "with different width due to prototype",
2491                                  argnum, rname);
2492                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2493                         ;
2494                       /* Don't complain if the formal parameter type
2495                          is an enum, because we can't tell now whether
2496                          the value was an enum--even the same enum.  */
2497                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
2498                         ;
2499                       else if (TREE_CODE (val) == INTEGER_CST
2500                                && int_fits_type_p (val, type))
2501                         /* Change in signedness doesn't matter
2502                            if a constant value is unaffected.  */
2503                         ;
2504                       /* If the value is extended from a narrower
2505                          unsigned type, it doesn't matter whether we
2506                          pass it as signed or unsigned; the value
2507                          certainly is the same either way.  */
2508                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
2509                                && TYPE_UNSIGNED (TREE_TYPE (val)))
2510                         ;
2511                       else if (TYPE_UNSIGNED (type))
2512                         warning (OPT_Wconversion, "passing argument %d of %qE "
2513                                  "as unsigned due to prototype",
2514                                  argnum, rname);
2515                       else
2516                         warning (OPT_Wconversion, "passing argument %d of %qE "
2517                                  "as signed due to prototype", argnum, rname);
2518                     }
2519                 }
2520
2521               parmval = convert_for_assignment (type, val, ic_argpass,
2522                                                 fundecl, function,
2523                                                 parmnum + 1);
2524
2525               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
2526                   && INTEGRAL_TYPE_P (type)
2527                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2528                 parmval = default_conversion (parmval);
2529             }
2530           result = tree_cons (NULL_TREE, parmval, result);
2531         }
2532       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2533                && (TYPE_PRECISION (TREE_TYPE (val))
2534                    < TYPE_PRECISION (double_type_node))
2535                && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val))))
2536         /* Convert `float' to `double'.  */
2537         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2538       else if ((invalid_func_diag =
2539                 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
2540         {
2541           error (invalid_func_diag);
2542           return error_mark_node;
2543         }
2544       else
2545         /* Convert `short' and `char' to full-size `int'.  */
2546         result = tree_cons (NULL_TREE, default_conversion (val), result);
2547
2548       if (typetail)
2549         typetail = TREE_CHAIN (typetail);
2550     }
2551
2552   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
2553     {
2554       error ("too few arguments to function %qE", function);
2555       return error_mark_node;
2556     }
2557
2558   return nreverse (result);
2559 }
2560 \f
2561 /* This is the entry point used by the parser to build unary operators
2562    in the input.  CODE, a tree_code, specifies the unary operator, and
2563    ARG is the operand.  For unary plus, the C parser currently uses
2564    CONVERT_EXPR for code.  */
2565
2566 struct c_expr
2567 parser_build_unary_op (enum tree_code code, struct c_expr arg)
2568 {
2569   struct c_expr result;
2570
2571   result.original_code = ERROR_MARK;
2572   result.value = build_unary_op (code, arg.value, 0);
2573   overflow_warning (result.value);
2574   return result;
2575 }
2576
2577 /* This is the entry point used by the parser to build binary operators
2578    in the input.  CODE, a tree_code, specifies the binary operator, and
2579    ARG1 and ARG2 are the operands.  In addition to constructing the
2580    expression, we check for operands that were written with other binary
2581    operators in a way that is likely to confuse the user.  */
2582
2583 struct c_expr
2584 parser_build_binary_op (enum tree_code code, struct c_expr arg1,
2585                         struct c_expr arg2)
2586 {
2587   struct c_expr result;
2588
2589   enum tree_code code1 = arg1.original_code;
2590   enum tree_code code2 = arg2.original_code;
2591
2592   result.value = build_binary_op (code, arg1.value, arg2.value, 1);
2593   result.original_code = code;
2594
2595   if (TREE_CODE (result.value) == ERROR_MARK)
2596     return result;
2597
2598   /* Check for cases such as x+y<<z which users are likely
2599      to misinterpret.  */
2600   if (warn_parentheses)
2601     {
2602       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
2603         {
2604           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2605               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2606             warning (OPT_Wparentheses,
2607                      "suggest parentheses around + or - inside shift");
2608         }
2609
2610       if (code == TRUTH_ORIF_EXPR)
2611         {
2612           if (code1 == TRUTH_ANDIF_EXPR
2613               || code2 == TRUTH_ANDIF_EXPR)
2614             warning (OPT_Wparentheses,
2615                      "suggest parentheses around && within ||");
2616         }
2617
2618       if (code == BIT_IOR_EXPR)
2619         {
2620           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2621               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2622               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2623               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2624             warning (OPT_Wparentheses,
2625                      "suggest parentheses around arithmetic in operand of |");
2626           /* Check cases like x|y==z */
2627           if (TREE_CODE_CLASS (code1) == tcc_comparison
2628               || TREE_CODE_CLASS (code2) == tcc_comparison)
2629             warning (OPT_Wparentheses,
2630                      "suggest parentheses around comparison in operand of |");
2631         }
2632
2633       if (code == BIT_XOR_EXPR)
2634         {
2635           if (code1 == BIT_AND_EXPR
2636               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2637               || code2 == BIT_AND_EXPR
2638               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2639             warning (OPT_Wparentheses,
2640                      "suggest parentheses around arithmetic in operand of ^");
2641           /* Check cases like x^y==z */
2642           if (TREE_CODE_CLASS (code1) == tcc_comparison
2643               || TREE_CODE_CLASS (code2) == tcc_comparison)
2644             warning (OPT_Wparentheses,
2645                      "suggest parentheses around comparison in operand of ^");
2646         }
2647
2648       if (code == BIT_AND_EXPR)
2649         {
2650           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2651               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2652             warning (OPT_Wparentheses,
2653                      "suggest parentheses around + or - in operand of &");
2654           /* Check cases like x&y==z */
2655           if (TREE_CODE_CLASS (code1) == tcc_comparison
2656               || TREE_CODE_CLASS (code2) == tcc_comparison)
2657             warning (OPT_Wparentheses,
2658                      "suggest parentheses around comparison in operand of &");
2659         }
2660       /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
2661       if (TREE_CODE_CLASS (code) == tcc_comparison
2662           && (TREE_CODE_CLASS (code1) == tcc_comparison
2663               || TREE_CODE_CLASS (code2) == tcc_comparison))
2664         warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not "
2665                  "have their mathematical meaning");
2666
2667     }
2668
2669   /* Warn about comparisons against string literals, with the exception
2670      of testing for equality or inequality of a string literal with NULL.  */
2671   if (code == EQ_EXPR || code == NE_EXPR)
2672     {
2673       if ((code1 == STRING_CST && !integer_zerop (arg2.value))
2674           || (code2 == STRING_CST && !integer_zerop (arg1.value)))
2675         warning (OPT_Wstring_literal_comparison,
2676                  "comparison with string literal");
2677     }
2678   else if (TREE_CODE_CLASS (code) == tcc_comparison
2679            && (code1 == STRING_CST || code2 == STRING_CST))
2680     warning (OPT_Wstring_literal_comparison,
2681              "comparison with string literal");
2682
2683   overflow_warning (result.value);
2684
2685   return result;
2686 }
2687 \f
2688 /* Return a tree for the difference of pointers OP0 and OP1.
2689    The resulting tree has type int.  */
2690
2691 static tree
2692 pointer_diff (tree op0, tree op1)
2693 {
2694   tree restype = ptrdiff_type_node;
2695
2696   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2697   tree con0, con1, lit0, lit1;
2698   tree orig_op1 = op1;
2699
2700   if (pedantic || warn_pointer_arith)
2701     {
2702       if (TREE_CODE (target_type) == VOID_TYPE)
2703         pedwarn ("pointer of type %<void *%> used in subtraction");
2704       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2705         pedwarn ("pointer to a function used in subtraction");
2706     }
2707
2708   /* If the conversion to ptrdiff_type does anything like widening or
2709      converting a partial to an integral mode, we get a convert_expression
2710      that is in the way to do any simplifications.
2711      (fold-const.c doesn't know that the extra bits won't be needed.
2712      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2713      different mode in place.)
2714      So first try to find a common term here 'by hand'; we want to cover
2715      at least the cases that occur in legal static initializers.  */
2716   if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR)
2717       && (TYPE_PRECISION (TREE_TYPE (op0))
2718           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
2719     con0 = TREE_OPERAND (op0, 0);
2720   else
2721     con0 = op0;
2722   if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR)
2723       && (TYPE_PRECISION (TREE_TYPE (op1))
2724           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))))
2725     con1 = TREE_OPERAND (op1, 0);
2726   else
2727     con1 = op1;
2728
2729   if (TREE_CODE (con0) == PLUS_EXPR)
2730     {
2731       lit0 = TREE_OPERAND (con0, 1);
2732       con0 = TREE_OPERAND (con0, 0);
2733     }
2734   else
2735     lit0 = integer_zero_node;
2736
2737   if (TREE_CODE (con1) == PLUS_EXPR)
2738     {
2739       lit1 = TREE_OPERAND (con1, 1);
2740       con1 = TREE_OPERAND (con1, 0);
2741     }
2742   else
2743     lit1 = integer_zero_node;
2744
2745   if (operand_equal_p (con0, con1, 0))
2746     {
2747       op0 = lit0;
2748       op1 = lit1;
2749     }
2750
2751
2752   /* First do the subtraction as integers;
2753      then drop through to build the divide operator.
2754      Do not do default conversions on the minus operator
2755      in case restype is a short type.  */
2756
2757   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2758                          convert (restype, op1), 0);
2759   /* This generates an error if op1 is pointer to incomplete type.  */
2760   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2761     error ("arithmetic on pointer to an incomplete type");
2762
2763   /* This generates an error if op0 is pointer to incomplete type.  */
2764   op1 = c_size_in_bytes (target_type);
2765
2766   /* Divide by the size, in easiest possible way.  */
2767   return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2768 }
2769 \f
2770 /* Construct and perhaps optimize a tree representation
2771    for a unary operation.  CODE, a tree_code, specifies the operation
2772    and XARG is the operand.
2773    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2774    the default promotions (such as from short to int).
2775    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2776    allows non-lvalues; this is only used to handle conversion of non-lvalue
2777    arrays to pointers in C99.  */
2778
2779 tree
2780 build_unary_op (enum tree_code code, tree xarg, int flag)
2781 {
2782   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2783   tree arg = xarg;
2784   tree argtype = 0;
2785   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2786   tree val;
2787   int noconvert = flag;
2788   const char *invalid_op_diag;
2789
2790   if (typecode == ERROR_MARK)
2791     return error_mark_node;
2792   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2793     typecode = INTEGER_TYPE;
2794
2795   if ((invalid_op_diag
2796        = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
2797     {
2798       error (invalid_op_diag);
2799       return error_mark_node;
2800     }
2801
2802   switch (code)
2803     {
2804     case CONVERT_EXPR:
2805       /* This is used for unary plus, because a CONVERT_EXPR
2806          is enough to prevent anybody from looking inside for
2807          associativity, but won't generate any code.  */
2808       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2809             || typecode == COMPLEX_TYPE
2810             || typecode == VECTOR_TYPE))
2811         {
2812           error ("wrong type argument to unary plus");
2813           return error_mark_node;
2814         }
2815       else if (!noconvert)
2816         arg = default_conversion (arg);
2817       arg = non_lvalue (arg);
2818       break;
2819
2820     case NEGATE_EXPR:
2821       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2822             || typecode == COMPLEX_TYPE
2823             || typecode == VECTOR_TYPE))
2824         {
2825           error ("wrong type argument to unary minus");
2826           return error_mark_node;
2827         }
2828       else if (!noconvert)
2829         arg = default_conversion (arg);
2830       break;
2831
2832     case BIT_NOT_EXPR:
2833       if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2834         {
2835           if (!noconvert)
2836             arg = default_conversion (arg);
2837         }
2838       else if (typecode == COMPLEX_TYPE)
2839         {
2840           code = CONJ_EXPR;
2841           if (pedantic)
2842             pedwarn ("ISO C does not support %<~%> for complex conjugation");
2843           if (!noconvert)
2844             arg = default_conversion (arg);
2845         }
2846       else
2847         {
2848           error ("wrong type argument to bit-complement");
2849           return error_mark_node;
2850         }
2851       break;
2852
2853     case ABS_EXPR:
2854       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2855         {
2856           error ("wrong type argument to abs");
2857           return error_mark_node;
2858         }
2859       else if (!noconvert)
2860         arg = default_conversion (arg);
2861       break;
2862
2863     case CONJ_EXPR:
2864       /* Conjugating a real value is a no-op, but allow it anyway.  */
2865       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2866             || typecode == COMPLEX_TYPE))
2867         {
2868           error ("wrong type argument to conjugation");
2869           return error_mark_node;
2870         }
2871       else if (!noconvert)
2872         arg = default_conversion (arg);
2873       break;
2874
2875     case TRUTH_NOT_EXPR:
2876       if (typecode != INTEGER_TYPE
2877           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2878           && typecode != COMPLEX_TYPE)
2879         {
2880           error ("wrong type argument to unary exclamation mark");
2881           return error_mark_node;
2882         }
2883       arg = c_objc_common_truthvalue_conversion (arg);
2884       return invert_truthvalue (arg);
2885
2886     case REALPART_EXPR:
2887       if (TREE_CODE (arg) == COMPLEX_CST)
2888         return TREE_REALPART (arg);
2889       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2890         return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
2891       else
2892         return arg;
2893
2894     case IMAGPART_EXPR:
2895       if (TREE_CODE (arg) == COMPLEX_CST)
2896         return TREE_IMAGPART (arg);
2897       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2898         return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
2899       else
2900         return convert (TREE_TYPE (arg), integer_zero_node);
2901
2902     case PREINCREMENT_EXPR:
2903     case POSTINCREMENT_EXPR:
2904     case PREDECREMENT_EXPR:
2905     case POSTDECREMENT_EXPR:
2906
2907       /* Increment or decrement the real part of the value,
2908          and don't change the imaginary part.  */
2909       if (typecode == COMPLEX_TYPE)
2910         {
2911           tree real, imag;
2912
2913           if (pedantic)
2914             pedwarn ("ISO C does not support %<++%> and %<--%>"
2915                      " on complex types");
2916
2917           arg = stabilize_reference (arg);
2918           real = build_unary_op (REALPART_EXPR, arg, 1);
2919           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2920           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
2921                          build_unary_op (code, real, 1), imag);
2922         }
2923
2924       /* Report invalid types.  */
2925
2926       if (typecode != POINTER_TYPE
2927           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2928         {
2929           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2930             error ("wrong type argument to increment");
2931           else
2932             error ("wrong type argument to decrement");
2933
2934           return error_mark_node;
2935         }
2936
2937       {
2938         tree inc;
2939         tree result_type = TREE_TYPE (arg);
2940
2941         arg = get_unwidened (arg, 0);
2942         argtype = TREE_TYPE (arg);
2943
2944         /* Compute the increment.  */
2945
2946         if (typecode == POINTER_TYPE)
2947           {
2948             /* If pointer target is an undefined struct,
2949                we just cannot know how to do the arithmetic.  */
2950             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2951               {
2952                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2953                   error ("increment of pointer to unknown structure");
2954                 else
2955                   error ("decrement of pointer to unknown structure");
2956               }
2957             else if ((pedantic || warn_pointer_arith)
2958                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2959                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2960               {
2961                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2962                   pedwarn ("wrong type argument to increment");
2963                 else
2964                   pedwarn ("wrong type argument to decrement");
2965               }
2966
2967             inc = c_size_in_bytes (TREE_TYPE (result_type));
2968           }
2969         else
2970           inc = integer_one_node;
2971
2972         inc = convert (argtype, inc);
2973
2974         /* Complain about anything else that is not a true lvalue.  */
2975         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2976                                     || code == POSTINCREMENT_EXPR)
2977                                    ? lv_increment
2978                                    : lv_decrement)))
2979           return error_mark_node;
2980
2981         /* Report a read-only lvalue.  */
2982         if (TREE_READONLY (arg))
2983           {
2984             readonly_error (arg,
2985                             ((code == PREINCREMENT_EXPR
2986                               || code == POSTINCREMENT_EXPR)
2987                              ? lv_increment : lv_decrement));
2988             return error_mark_node;
2989           }
2990
2991         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2992           val = boolean_increment (code, arg);
2993         else
2994           val = build2 (code, TREE_TYPE (arg), arg, inc);
2995         TREE_SIDE_EFFECTS (val) = 1;
2996         val = convert (result_type, val);
2997         if (TREE_CODE (val) != code)
2998           TREE_NO_WARNING (val) = 1;
2999         return val;
3000       }
3001
3002     case ADDR_EXPR:
3003       /* Note that this operation never does default_conversion.  */
3004
3005       /* Let &* cancel out to simplify resulting code.  */
3006       if (TREE_CODE (arg) == INDIRECT_REF)
3007         {
3008           /* Don't let this be an lvalue.  */
3009           if (lvalue_p (TREE_OPERAND (arg, 0)))
3010             return non_lvalue (TREE_OPERAND (arg, 0));
3011           return TREE_OPERAND (arg, 0);
3012         }
3013
3014       /* For &x[y], return x+y */
3015       if (TREE_CODE (arg) == ARRAY_REF)
3016         {
3017           tree op0 = TREE_OPERAND (arg, 0);
3018           if (!c_mark_addressable (op0))
3019             return error_mark_node;
3020           return build_binary_op (PLUS_EXPR,
3021                                   (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE
3022                                    ? array_to_pointer_conversion (op0)
3023                                    : op0),
3024                                   TREE_OPERAND (arg, 1), 1);
3025         }
3026
3027       /* Anything not already handled and not a true memory reference
3028          or a non-lvalue array is an error.  */
3029       else if (typecode != FUNCTION_TYPE && !flag
3030                && !lvalue_or_else (arg, lv_addressof))
3031         return error_mark_node;
3032
3033       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
3034       argtype = TREE_TYPE (arg);
3035
3036       /* If the lvalue is const or volatile, merge that into the type
3037          to which the address will point.  Note that you can't get a
3038          restricted pointer by taking the address of something, so we
3039          only have to deal with `const' and `volatile' here.  */
3040       if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
3041           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
3042           argtype = c_build_type_variant (argtype,
3043                                           TREE_READONLY (arg),
3044                                           TREE_THIS_VOLATILE (arg));
3045
3046       if (!c_mark_addressable (arg))
3047         return error_mark_node;
3048
3049       gcc_assert (TREE_CODE (arg) != COMPONENT_REF
3050                   || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
3051
3052       argtype = build_pointer_type (argtype);
3053
3054       /* ??? Cope with user tricks that amount to offsetof.  Delete this
3055          when we have proper support for integer constant expressions.  */
3056       val = get_base_address (arg);
3057       if (val && TREE_CODE (val) == INDIRECT_REF
3058           && TREE_CONSTANT (TREE_OPERAND (val, 0)))
3059         {
3060           tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1;
3061
3062           op1 = fold_convert (argtype, TREE_OPERAND (val, 0));
3063           return fold_build2 (PLUS_EXPR, argtype, op0, op1);
3064         }
3065
3066       val = build1 (ADDR_EXPR, argtype, arg);
3067
3068       return val;
3069
3070     default:
3071       gcc_unreachable ();
3072     }
3073
3074   if (argtype == 0)
3075     argtype = TREE_TYPE (arg);
3076   return require_constant_value ? fold_build1_initializer (code, argtype, arg)
3077                                 : fold_build1 (code, argtype, arg);
3078 }
3079
3080 /* Return nonzero if REF is an lvalue valid for this language.
3081    Lvalues can be assigned, unless their type has TYPE_READONLY.
3082    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
3083
3084 static int
3085 lvalue_p (tree ref)
3086 {
3087   enum tree_code code = TREE_CODE (ref);
3088
3089   switch (code)
3090     {
3091     case REALPART_EXPR:
3092     case IMAGPART_EXPR:
3093     case COMPONENT_REF:
3094       return lvalue_p (TREE_OPERAND (ref, 0));
3095
3096     case COMPOUND_LITERAL_EXPR:
3097     case STRING_CST:
3098       return 1;
3099
3100     case INDIRECT_REF:
3101     case ARRAY_REF:
3102     case VAR_DECL:
3103     case PARM_DECL:
3104     case RESULT_DECL:
3105     case ERROR_MARK:
3106       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3107               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3108
3109     case BIND_EXPR:
3110       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3111
3112     default:
3113       return 0;
3114     }
3115 }
3116 \f
3117 /* Give an error for storing in something that is 'const'.  */
3118
3119 static void
3120 readonly_error (tree arg, enum lvalue_use use)
3121 {
3122   gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement
3123               || use == lv_asm);
3124   /* Using this macro rather than (for example) arrays of messages
3125      ensures that all the format strings are checked at compile
3126      time.  */
3127 #define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A)               \
3128                                    : (use == lv_increment ? (I)         \
3129                                    : (use == lv_decrement ? (D) : (AS))))
3130   if (TREE_CODE (arg) == COMPONENT_REF)
3131     {
3132       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
3133         readonly_error (TREE_OPERAND (arg, 0), use);
3134       else
3135         error (READONLY_MSG (G_("assignment of read-only member %qD"),
3136                              G_("increment of read-only member %qD"),
3137                              G_("decrement of read-only member %qD"),
3138                              G_("read-only member %qD used as %<asm%> output")),
3139                TREE_OPERAND (arg, 1));
3140     }
3141   else if (TREE_CODE (arg) == VAR_DECL)
3142     error (READONLY_MSG (G_("assignment of read-only variable %qD"),
3143                          G_("increment of read-only variable %qD"),
3144                          G_("decrement of read-only variable %qD"),
3145                          G_("read-only variable %qD used as %<asm%> output")),
3146            arg);
3147   else
3148     error (READONLY_MSG (G_("assignment of read-only location"),
3149                          G_("increment of read-only location"),
3150                          G_("decrement of read-only location"),
3151                          G_("read-only location used as %<asm%> output")));
3152 }
3153
3154
3155 /* Return nonzero if REF is an lvalue valid for this language;
3156    otherwise, print an error message and return zero.  USE says
3157    how the lvalue is being used and so selects the error message.  */
3158
3159 static int
3160 lvalue_or_else (tree ref, enum lvalue_use use)
3161 {
3162   int win = lvalue_p (ref);
3163
3164   if (!win)
3165     lvalue_error (use);
3166
3167   return win;
3168 }
3169 \f
3170 /* Mark EXP saying that we need to be able to take the
3171    address of it; it should not be allocated in a register.
3172    Returns true if successful.  */
3173
3174 bool
3175 c_mark_addressable (tree exp)
3176 {
3177   tree x = exp;
3178
3179   while (1)
3180     switch (TREE_CODE (x))
3181       {
3182       case COMPONENT_REF:
3183         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
3184           {
3185             error
3186               ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
3187             return false;
3188           }
3189
3190         /* ... fall through ...  */
3191
3192       case ADDR_EXPR:
3193       case ARRAY_REF:
3194       case REALPART_EXPR:
3195       case IMAGPART_EXPR:
3196         x = TREE_OPERAND (x, 0);
3197         break;
3198
3199       case COMPOUND_LITERAL_EXPR:
3200       case CONSTRUCTOR:
3201         TREE_ADDRESSABLE (x) = 1;
3202         return true;
3203
3204       case VAR_DECL:
3205       case CONST_DECL:
3206       case PARM_DECL:
3207       case RESULT_DECL:
3208         if (C_DECL_REGISTER (x)
3209             && DECL_NONLOCAL (x))
3210           {
3211             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
3212               {
3213                 error
3214                   ("global register variable %qD used in nested function", x);
3215                 return false;
3216               }
3217             pedwarn ("register variable %qD used in nested function", x);
3218           }
3219         else if (C_DECL_REGISTER (x))
3220           {
3221             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
3222               error ("address of global register variable %qD requested", x);
3223             else
3224               error ("address of register variable %qD requested", x);
3225             return false;
3226           }
3227
3228         /* drops in */
3229       case FUNCTION_DECL:
3230         TREE_ADDRESSABLE (x) = 1;
3231         /* drops out */
3232       default:
3233         return true;
3234     }
3235 }
3236 \f
3237 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
3238
3239 tree
3240 build_conditional_expr (tree ifexp, tree op1, tree op2)
3241 {
3242   tree type1;
3243   tree type2;
3244   enum tree_code code1;
3245   enum tree_code code2;
3246   tree result_type = NULL;
3247   tree orig_op1 = op1, orig_op2 = op2;
3248
3249   /* Promote both alternatives.  */
3250
3251   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
3252     op1 = default_conversion (op1);
3253   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
3254     op2 = default_conversion (op2);
3255
3256   if (TREE_CODE (ifexp) == ERROR_MARK
3257       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
3258       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
3259     return error_mark_node;
3260
3261   type1 = TREE_TYPE (op1);
3262   code1 = TREE_CODE (type1);
3263   type2 = TREE_TYPE (op2);
3264   code2 = TREE_CODE (type2);
3265
3266   /* C90 does not permit non-lvalue arrays in conditional expressions.
3267      In C99 they will be pointers by now.  */
3268   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
3269     {
3270       error ("non-lvalue array in conditional expression");
3271       return error_mark_node;
3272     }
3273
3274   /* Quickly detect the usual case where op1 and op2 have the same type
3275      after promotion.  */
3276   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
3277     {
3278       if (type1 == type2)
3279         result_type = type1;
3280       else
3281         result_type = TYPE_MAIN_VARIANT (type1);
3282     }
3283   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
3284             || code1 == COMPLEX_TYPE)
3285            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
3286                || code2 == COMPLEX_TYPE))
3287     {
3288       result_type = c_common_type (type1, type2);
3289
3290       /* If -Wsign-compare, warn here if type1 and type2 have
3291          different signedness.  We'll promote the signed to unsigned
3292          and later code won't know it used to be different.
3293          Do this check on the original types, so that explicit casts
3294          will be considered, but default promotions won't.  */
3295       if (warn_sign_compare && !skip_evaluation)
3296         {
3297           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
3298           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
3299
3300           if (unsigned_op1 ^ unsigned_op2)
3301             {
3302               /* Do not warn if the result type is signed, since the
3303                  signed type will only be chosen if it can represent
3304                  all the values of the unsigned type.  */
3305               if (!TYPE_UNSIGNED (result_type))
3306                 /* OK */;
3307               /* Do not warn if the signed quantity is an unsuffixed
3308                  integer literal (or some static constant expression
3309                  involving such literals) and it is non-negative.  */
3310               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3311                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3312                 /* OK */;
3313               else
3314                 warning (0, "signed and unsigned type in conditional expression");
3315             }
3316         }
3317     }
3318   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3319     {
3320       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3321         pedwarn ("ISO C forbids conditional expr with only one void side");
3322       result_type = void_type_node;
3323     }
3324   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3325     {
3326       if (comp_target_types (type1, type2))
3327         result_type = common_pointer_type (type1, type2);
3328       else if (null_pointer_constant_p (orig_op1))
3329         result_type = qualify_type (type2, type1);
3330       else if (null_pointer_constant_p (orig_op2))
3331         result_type = qualify_type (type1, type2);
3332       else if (VOID_TYPE_P (TREE_TYPE (type1)))
3333         {
3334           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3335             pedwarn ("ISO C forbids conditional expr between "
3336                      "%<void *%> and function pointer");
3337           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3338                                                           TREE_TYPE (type2)));
3339         }
3340       else if (VOID_TYPE_P (TREE_TYPE (type2)))
3341         {
3342           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3343             pedwarn ("ISO C forbids conditional expr between "
3344                      "%<void *%> and function pointer");
3345           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3346                                                           TREE_TYPE (type1)));
3347         }
3348       else
3349         {
3350           pedwarn ("pointer type mismatch in conditional expression");
3351           result_type = build_pointer_type (void_type_node);
3352         }
3353     }
3354   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3355     {
3356       if (!null_pointer_constant_p (orig_op2))
3357         pedwarn ("pointer/integer type mismatch in conditional expression");
3358       else
3359         {
3360           op2 = null_pointer_node;
3361         }
3362       result_type = type1;
3363     }
3364   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3365     {
3366       if (!null_pointer_constant_p (orig_op1))
3367         pedwarn ("pointer/integer type mismatch in conditional expression");
3368       else
3369         {
3370           op1 = null_pointer_node;
3371         }
3372       result_type = type2;
3373     }
3374
3375   if (!result_type)
3376     {
3377       if (flag_cond_mismatch)
3378         result_type = void_type_node;
3379       else
3380         {
3381           error ("type mismatch in conditional expression");
3382           return error_mark_node;
3383         }
3384     }
3385
3386   /* Merge const and volatile flags of the incoming types.  */
3387   result_type
3388     = build_type_variant (result_type,
3389                           TREE_READONLY (op1) || TREE_READONLY (op2),
3390                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3391
3392   if (result_type != TREE_TYPE (op1))
3393     op1 = convert_and_check (result_type, op1);
3394   if (result_type != TREE_TYPE (op2))
3395     op2 = convert_and_check (result_type, op2);
3396
3397   return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2);
3398 }
3399 \f
3400 /* Return a compound expression that performs two expressions and
3401    returns the value of the second of them.  */
3402
3403 tree
3404 build_compound_expr (tree expr1, tree expr2)
3405 {
3406   if (!TREE_SIDE_EFFECTS (expr1))
3407     {
3408       /* The left-hand operand of a comma expression is like an expression
3409          statement: with -Wextra or -Wunused, we should warn if it doesn't have
3410          any side-effects, unless it was explicitly cast to (void).  */
3411       if (warn_unused_value)
3412         {
3413           if (VOID_TYPE_P (TREE_TYPE (expr1))
3414               && (TREE_CODE (expr1) == NOP_EXPR
3415                   || TREE_CODE (expr1) == CONVERT_EXPR))
3416             ; /* (void) a, b */
3417           else if (VOID_TYPE_P (TREE_TYPE (expr1))
3418                    && TREE_CODE (expr1) == COMPOUND_EXPR
3419                    && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR
3420                        || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR))
3421             ; /* (void) a, (void) b, c */
3422           else
3423             warning (0, "left-hand operand of comma expression has no effect");
3424         }
3425     }
3426
3427   /* With -Wunused, we should also warn if the left-hand operand does have
3428      side-effects, but computes a value which is not used.  For example, in
3429      `foo() + bar(), baz()' the result of the `+' operator is not used,
3430      so we should issue a warning.  */
3431   else if (warn_unused_value)
3432     warn_if_unused_value (expr1, input_location);
3433
3434   if (expr2 == error_mark_node)
3435     return error_mark_node;
3436
3437   return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
3438 }
3439
3440 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3441
3442 tree
3443 build_c_cast (tree type, tree expr)
3444 {
3445   tree value = expr;
3446
3447   if (type == error_mark_node || expr == error_mark_node)
3448     return error_mark_node;
3449
3450   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3451      only in <protocol> qualifications.  But when constructing cast expressions,
3452      the protocols do matter and must be kept around.  */
3453   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
3454     return build1 (NOP_EXPR, type, expr);
3455
3456   type = TYPE_MAIN_VARIANT (type);
3457
3458   if (TREE_CODE (type) == ARRAY_TYPE)
3459     {
3460       error ("cast specifies array type");
3461       return error_mark_node;
3462     }
3463
3464   if (TREE_CODE (type) == FUNCTION_TYPE)
3465     {
3466       error ("cast specifies function type");
3467       return error_mark_node;
3468     }
3469
3470   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3471     {
3472       if (pedantic)
3473         {
3474           if (TREE_CODE (type) == RECORD_TYPE
3475               || TREE_CODE (type) == UNION_TYPE)
3476             pedwarn ("ISO C forbids casting nonscalar to the same type");
3477         }
3478     }
3479   else if (TREE_CODE (type) == UNION_TYPE)
3480     {
3481       tree field;
3482
3483       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3484         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3485                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3486           break;
3487
3488       if (field)
3489         {
3490           tree t;
3491
3492           if (pedantic)
3493             pedwarn ("ISO C forbids casts to union type");
3494           t = digest_init (type,
3495                            build_constructor_single (type, field, value),
3496                            true, 0);
3497           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3498           TREE_INVARIANT (t) = TREE_INVARIANT (value);
3499           return t;
3500         }
3501       error ("cast to union type from type not present in union");
3502       return error_mark_node;
3503     }
3504   else
3505     {
3506       tree otype, ovalue;
3507
3508       if (type == void_type_node)
3509         return build1 (CONVERT_EXPR, type, value);
3510
3511       otype = TREE_TYPE (value);
3512
3513       /* Optionally warn about potentially worrisome casts.  */
3514
3515       if (warn_cast_qual
3516           && TREE_CODE (type) == POINTER_TYPE
3517           && TREE_CODE (otype) == POINTER_TYPE)
3518         {
3519           tree in_type = type;
3520           tree in_otype = otype;
3521           int added = 0;
3522           int discarded = 0;
3523
3524           /* Check that the qualifiers on IN_TYPE are a superset of
3525              the qualifiers of IN_OTYPE.  The outermost level of
3526              POINTER_TYPE nodes is uninteresting and we stop as soon
3527              as we hit a non-POINTER_TYPE node on either type.  */
3528           do
3529             {
3530               in_otype = TREE_TYPE (in_otype);
3531               in_type = TREE_TYPE (in_type);
3532
3533               /* GNU C allows cv-qualified function types.  'const'
3534                  means the function is very pure, 'volatile' means it
3535                  can't return.  We need to warn when such qualifiers
3536                  are added, not when they're taken away.  */
3537               if (TREE_CODE (in_otype) == FUNCTION_TYPE
3538                   && TREE_CODE (in_type) == FUNCTION_TYPE)
3539                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3540               else
3541                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3542             }
3543           while (TREE_CODE (in_type) == POINTER_TYPE
3544                  && TREE_CODE (in_otype) == POINTER_TYPE);
3545
3546           if (added)
3547             warning (0, "cast adds new qualifiers to function type");
3548
3549           if (discarded)
3550             /* There are qualifiers present in IN_OTYPE that are not
3551                present in IN_TYPE.  */
3552             warning (0, "cast discards qualifiers from pointer target type");
3553         }
3554
3555       /* Warn about possible alignment problems.  */
3556       if (STRICT_ALIGNMENT
3557           && TREE_CODE (type) == POINTER_TYPE
3558           && TREE_CODE (otype) == POINTER_TYPE
3559           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3560           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3561           /* Don't warn about opaque types, where the actual alignment
3562              restriction is unknown.  */
3563           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3564                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3565                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3566           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3567         warning (OPT_Wcast_align,
3568                  "cast increases required alignment of target type");
3569
3570       if (TREE_CODE (type) == INTEGER_TYPE
3571           && TREE_CODE (otype) == POINTER_TYPE
3572           && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
3573       /* Unlike conversion of integers to pointers, where the
3574          warning is disabled for converting constants because
3575          of cases such as SIG_*, warn about converting constant
3576          pointers to integers. In some cases it may cause unwanted
3577          sign extension, and a warning is appropriate.  */
3578         warning (OPT_Wpointer_to_int_cast,
3579                  "cast from pointer to integer of different size");
3580
3581       if (TREE_CODE (value) == CALL_EXPR
3582           && TREE_CODE (type) != TREE_CODE (otype))
3583         warning (OPT_Wbad_function_cast, "cast from function call of type %qT "
3584                  "to non-matching type %qT", otype, type);
3585
3586       if (TREE_CODE (type) == POINTER_TYPE
3587           && TREE_CODE (otype) == INTEGER_TYPE
3588           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3589           /* Don't warn about converting any constant.  */
3590           && !TREE_CONSTANT (value))
3591         warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer "
3592                  "of different size");
3593
3594       strict_aliasing_warning (otype, type, expr);
3595
3596       /* If pedantic, warn for conversions between function and object
3597          pointer types, except for converting a null pointer constant
3598          to function pointer type.  */
3599       if (pedantic
3600           && TREE_CODE (type) == POINTER_TYPE
3601           && TREE_CODE (otype) == POINTER_TYPE
3602           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3603           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3604         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3605
3606       if (pedantic
3607           && TREE_CODE (type) == POINTER_TYPE
3608           && TREE_CODE (otype) == POINTER_TYPE
3609           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3610           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3611           && !null_pointer_constant_p (value))
3612         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3613
3614       ovalue = value;
3615       value = convert (type, value);
3616
3617       /* Ignore any integer overflow caused by the cast.  */
3618       if (TREE_CODE (value) == INTEGER_CST)
3619         {
3620           if (CONSTANT_CLASS_P (ovalue)
3621               && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue)))
3622             {
3623               /* Avoid clobbering a shared constant.  */
3624               value = copy_node (value);
3625               TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3626               TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3627             }
3628           else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value))
3629             /* Reset VALUE's overflow flags, ensuring constant sharing.  */
3630             value = build_int_cst_wide (TREE_TYPE (value),
3631                                         TREE_INT_CST_LOW (value),
3632                                         TREE_INT_CST_HIGH (value));
3633         }
3634     }
3635
3636   /* Don't let a cast be an lvalue.  */
3637   if (value == expr)
3638     value = non_lvalue (value);
3639
3640   return value;
3641 }
3642
3643 /* Interpret a cast of expression EXPR to type TYPE.  */
3644 tree
3645 c_cast_expr (struct c_type_name *type_name, tree expr)
3646 {
3647   tree type;
3648   int saved_wsp = warn_strict_prototypes;
3649
3650   /* This avoids warnings about unprototyped casts on
3651      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3652   if (TREE_CODE (expr) == INTEGER_CST)
3653     warn_strict_prototypes = 0;
3654   type = groktypename (type_name);
3655   warn_strict_prototypes = saved_wsp;
3656
3657   return build_c_cast (type, expr);
3658 }
3659 \f
3660 /* Build an assignment expression of lvalue LHS from value RHS.
3661    MODIFYCODE is the code for a binary operator that we use
3662    to combine the old value of LHS with RHS to get the new value.
3663    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3664
3665 tree
3666 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3667 {
3668   tree result;
3669   tree newrhs;
3670   tree lhstype = TREE_TYPE (lhs);
3671   tree olhstype = lhstype;
3672
3673   /* Types that aren't fully specified cannot be used in assignments.  */
3674   lhs = require_complete_type (lhs);
3675
3676   /* Avoid duplicate error messages from operands that had errors.  */
3677   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3678     return error_mark_node;
3679
3680   if (!lvalue_or_else (lhs, lv_assign))
3681     return error_mark_node;
3682
3683   STRIP_TYPE_NOPS (rhs);
3684
3685   newrhs = rhs;
3686
3687   /* If a binary op has been requested, combine the old LHS value with the RHS
3688      producing the value we should actually store into the LHS.  */
3689
3690   if (modifycode != NOP_EXPR)
3691     {
3692       lhs = stabilize_reference (lhs);
3693       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3694     }
3695
3696   /* Give an error for storing in something that is 'const'.  */
3697
3698   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3699       || ((TREE_CODE (lhstype) == RECORD_TYPE
3700            || TREE_CODE (lhstype) == UNION_TYPE)
3701           && C_TYPE_FIELDS_READONLY (lhstype)))
3702     {
3703       readonly_error (lhs, lv_assign);
3704       return error_mark_node;
3705     }
3706
3707   /* If storing into a structure or union member,
3708      it has probably been given type `int'.
3709      Compute the type that would go with
3710      the actual amount of storage the member occupies.  */
3711
3712   if (TREE_CODE (lhs) == COMPONENT_REF
3713       && (TREE_CODE (lhstype) == INTEGER_TYPE
3714           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3715           || TREE_CODE (lhstype) == REAL_TYPE
3716           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3717     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3718
3719   /* If storing in a field that is in actuality a short or narrower than one,
3720      we must store in the field in its actual type.  */
3721
3722   if (lhstype != TREE_TYPE (lhs))
3723     {
3724       lhs = copy_node (lhs);
3725       TREE_TYPE (lhs) = lhstype;
3726     }
3727
3728   /* Convert new value to destination type.  */
3729
3730   newrhs = convert_for_assignment (lhstype, newrhs, ic_assign,
3731                                    NULL_TREE, NULL_TREE, 0);
3732   if (TREE_CODE (newrhs) == ERROR_MARK)
3733     return error_mark_node;
3734
3735   /* Emit ObjC write barrier, if necessary.  */
3736   if (c_dialect_objc () && flag_objc_gc)
3737     {
3738       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
3739       if (result)
3740         return result;
3741     }
3742
3743   /* Scan operands.  */
3744
3745   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3746   TREE_SIDE_EFFECTS (result) = 1;
3747
3748   /* If we got the LHS in a different type for storing in,
3749      convert the result back to the nominal type of LHS
3750      so that the value we return always has the same type
3751      as the LHS argument.  */
3752
3753   if (olhstype == TREE_TYPE (result))
3754     return result;
3755   return convert_for_assignment (olhstype, result, ic_assign,
3756                                  NULL_TREE, NULL_TREE, 0);
3757 }
3758 \f
3759 /* Convert value RHS to type TYPE as preparation for an assignment
3760    to an lvalue of type TYPE.
3761    The real work of conversion is done by `convert'.
3762    The purpose of this function is to generate error messages
3763    for assignments that are not allowed in C.
3764    ERRTYPE says whether it is argument passing, assignment,
3765    initialization or return.
3766
3767    FUNCTION is a tree for the function being called.
3768    PARMNUM is the number of the argument, for printing in error messages.  */
3769
3770 static tree
3771 convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
3772                         tree fundecl, tree function, int parmnum)
3773 {
3774   enum tree_code codel = TREE_CODE (type);
3775   tree rhstype;
3776   enum tree_code coder;
3777   tree rname = NULL_TREE;
3778   bool objc_ok = false;
3779
3780   if (errtype == ic_argpass || errtype == ic_argpass_nonproto)
3781     {
3782       tree selector;
3783       /* Change pointer to function to the function itself for
3784          diagnostics.  */
3785       if (TREE_CODE (function) == ADDR_EXPR
3786           && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
3787         function = TREE_OPERAND (function, 0);
3788
3789       /* Handle an ObjC selector specially for diagnostics.  */
3790       selector = objc_message_selector ();
3791       rname = function;
3792       if (selector && parmnum > 2)
3793         {
3794           rname = selector;
3795           parmnum -= 2;
3796         }
3797     }
3798
3799   /* This macro is used to emit diagnostics to ensure that all format
3800      strings are complete sentences, visible to gettext and checked at
3801      compile time.  */
3802 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE)     \
3803   do {                                          \
3804     switch (errtype)                            \
3805       {                                         \
3806       case ic_argpass:                          \
3807         pedwarn (AR, parmnum, rname);           \
3808         break;                                  \
3809       case ic_argpass_nonproto:                 \
3810         warning (0, AR, parmnum, rname);                \
3811         break;                                  \
3812       case ic_assign:                           \
3813         pedwarn (AS);                           \
3814         break;                                  \
3815       case ic_init:                             \
3816         pedwarn (IN);                           \
3817         break;                                  \
3818       case ic_return:                           \
3819         pedwarn (RE);                           \
3820         break;                                  \
3821       default:                                  \
3822         gcc_unreachable ();                     \
3823       }                                         \
3824   } while (0)
3825
3826   STRIP_TYPE_NOPS (rhs);
3827
3828   if (optimize && TREE_CODE (rhs) == VAR_DECL
3829            && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE)
3830     rhs = decl_constant_value_for_broken_optimization (rhs);
3831
3832   rhstype = TREE_TYPE (rhs);
3833   coder = TREE_CODE (rhstype);
3834
3835   if (coder == ERROR_MARK)
3836     return error_mark_node;
3837
3838   if (c_dialect_objc ())
3839     {
3840       int parmno;
3841
3842       switch (errtype)
3843         {
3844         case ic_return:
3845           parmno = 0;
3846           break;
3847
3848         case ic_assign:
3849           parmno = -1;
3850           break;
3851
3852         case ic_init:
3853           parmno = -2;
3854           break;
3855
3856         default:
3857           parmno = parmnum;
3858           break;
3859         }
3860
3861       objc_ok = objc_compare_types (type, rhstype, parmno, rname);
3862     }
3863
3864   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3865     {
3866       overflow_warning (rhs);
3867       return rhs;
3868     }
3869
3870   if (coder == VOID_TYPE)
3871     {
3872       /* Except for passing an argument to an unprototyped function,
3873          this is a constraint violation.  When passing an argument to
3874          an unprototyped function, it is compile-time undefined;
3875          making it a constraint in that case was rejected in
3876          DR#252.  */
3877       error ("void value not ignored as it ought to be");
3878       return error_mark_node;
3879     }
3880   /* A type converts to a reference to it.
3881      This code doesn't fully support references, it's just for the
3882      special case of va_start and va_copy.  */
3883   if (codel == REFERENCE_TYPE
3884       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3885     {
3886       if (!lvalue_p (rhs))
3887         {
3888           error ("cannot pass rvalue to reference parameter");
3889           return error_mark_node;
3890         }
3891       if (!c_mark_addressable (rhs))
3892         return error_mark_node;
3893       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3894
3895       /* We already know that these two types are compatible, but they
3896          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3897          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3898          likely to be va_list, a typedef to __builtin_va_list, which
3899          is different enough that it will cause problems later.  */
3900       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3901         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3902
3903       rhs = build1 (NOP_EXPR, type, rhs);
3904       return rhs;
3905     }
3906   /* Some types can interconvert without explicit casts.  */
3907   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3908            && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3909     return convert (type, rhs);
3910   /* Arithmetic types all interconvert, and enum is treated like int.  */
3911   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3912             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3913             || codel == BOOLEAN_TYPE)
3914            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3915                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3916                || coder == BOOLEAN_TYPE))
3917     return convert_and_check (type, rhs);
3918
3919   /* Conversion to a transparent union from its member types.
3920      This applies only to function arguments.  */
3921   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
3922            && (errtype == ic_argpass || errtype == ic_argpass_nonproto))
3923     {
3924       tree memb, marginal_memb = NULL_TREE;
3925
3926       for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb))
3927         {
3928           tree memb_type = TREE_TYPE (memb);
3929
3930           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3931                          TYPE_MAIN_VARIANT (rhstype)))
3932             break;
3933
3934           if (TREE_CODE (memb_type) != POINTER_TYPE)
3935             continue;
3936
3937           if (coder == POINTER_TYPE)
3938             {
3939               tree ttl = TREE_TYPE (memb_type);
3940               tree ttr = TREE_TYPE (rhstype);
3941
3942               /* Any non-function converts to a [const][volatile] void *
3943                  and vice versa; otherwise, targets must be the same.
3944                  Meanwhile, the lhs target must have all the qualifiers of
3945                  the rhs.  */
3946               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3947                   || comp_target_types (memb_type, rhstype))
3948                 {
3949                   /* If this type won't generate any warnings, use it.  */
3950                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3951                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3952                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3953                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3954                              == TYPE_QUALS (ttr))
3955                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3956                              == TYPE_QUALS (ttl))))
3957                     break;
3958
3959                   /* Keep looking for a better type, but remember this one.  */
3960                   if (!marginal_memb)
3961                     marginal_memb = memb;
3962                 }
3963             }
3964
3965           /* Can convert integer zero to any pointer type.  */
3966           if (null_pointer_constant_p (rhs))
3967             {
3968               rhs = null_pointer_node;
3969               break;
3970             }
3971         }
3972
3973       if (memb || marginal_memb)
3974         {
3975           if (!memb)
3976             {
3977               /* We have only a marginally acceptable member type;
3978                  it needs a warning.  */
3979               tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
3980               tree ttr = TREE_TYPE (rhstype);
3981
3982               /* Const and volatile mean something different for function
3983                  types, so the usual warnings are not appropriate.  */
3984               if (TREE_CODE (ttr) == FUNCTION_TYPE
3985                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3986                 {
3987                   /* Because const and volatile on functions are
3988                      restrictions that say the function will not do
3989                      certain things, it is okay to use a const or volatile
3990                      function where an ordinary one is wanted, but not
3991                      vice-versa.  */
3992                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3993                     WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE "
3994                                             "makes qualified function "
3995                                             "pointer from unqualified"),
3996                                          G_("assignment makes qualified "
3997                                             "function pointer from "
3998                                             "unqualified"),
3999                                          G_("initialization makes qualified "
4000                                             "function pointer from "
4001                                             "unqualified"),
4002                                          G_("return makes qualified function "
4003                                             "pointer from unqualified"));
4004                 }
4005               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4006                 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
4007                                         "qualifiers from pointer target type"),
4008                                      G_("assignment discards qualifiers "
4009                                         "from pointer target type"),
4010                                      G_("initialization discards qualifiers "
4011                                         "from pointer target type"),
4012                                      G_("return discards qualifiers from "
4013                                         "pointer target type"));
4014
4015               memb = marginal_memb;
4016             }
4017
4018           if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl)))
4019             pedwarn ("ISO C prohibits argument conversion to union type");
4020
4021           return build_constructor_single (type, memb, rhs);
4022         }
4023     }
4024
4025   /* Conversions among pointers */
4026   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4027            && (coder == codel))
4028     {
4029       tree ttl = TREE_TYPE (type);
4030       tree ttr = TREE_TYPE (rhstype);
4031       tree mvl = ttl;
4032       tree mvr = ttr;
4033       bool is_opaque_pointer;
4034       int target_cmp = 0;   /* Cache comp_target_types () result.  */
4035
4036       if (TREE_CODE (mvl) != ARRAY_TYPE)
4037         mvl = TYPE_MAIN_VARIANT (mvl);
4038       if (TREE_CODE (mvr) != ARRAY_TYPE)
4039         mvr = TYPE_MAIN_VARIANT (mvr);
4040       /* Opaque pointers are treated like void pointers.  */
4041       is_opaque_pointer = (targetm.vector_opaque_p (type)
4042                            || targetm.vector_opaque_p (rhstype))
4043         && TREE_CODE (ttl) == VECTOR_TYPE
4044         && TREE_CODE (ttr) == VECTOR_TYPE;
4045
4046       /* C++ does not allow the implicit conversion void* -> T*.  However,
4047          for the purpose of reducing the number of false positives, we
4048          tolerate the special case of
4049
4050                 int *p = NULL;
4051
4052          where NULL is typically defined in C to be '(void *) 0'.  */
4053       if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
4054         warning (OPT_Wc___compat, "request for implicit conversion from "
4055                  "%qT to %qT not permitted in C++", rhstype, type);
4056
4057       /* Check if the right-hand side has a format attribute but the
4058          left-hand side doesn't.  */
4059       if (warn_missing_format_attribute
4060           && check_missing_format_attribute (type, rhstype))
4061         {
4062           switch (errtype)
4063           {
4064           case ic_argpass:
4065           case ic_argpass_nonproto:
4066             warning (OPT_Wmissing_format_attribute,
4067                      "argument %d of %qE might be "
4068                      "a candidate for a format attribute",
4069                      parmnum, rname);
4070             break;
4071           case ic_assign:
4072             warning (OPT_Wmissing_format_attribute,
4073                      "assignment left-hand side might be "
4074                      "a candidate for a format attribute");
4075             break;
4076           case ic_init:
4077             warning (OPT_Wmissing_format_attribute,
4078                      "initialization left-hand side might be "
4079                      "a candidate for a format attribute");
4080             break;
4081           case ic_return:
4082             warning (OPT_Wmissing_format_attribute,
4083                      "return type might be "
4084                      "a candidate for a format attribute");
4085             break;
4086           default:
4087             gcc_unreachable ();
4088           }
4089         }
4090
4091       /* Any non-function converts to a [const][volatile] void *
4092          and vice versa; otherwise, targets must be the same.
4093          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4094       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4095           || (target_cmp = comp_target_types (type, rhstype))
4096           || is_opaque_pointer
4097           || (c_common_unsigned_type (mvl)
4098               == c_common_unsigned_type (mvr)))
4099         {
4100           if (pedantic
4101               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4102                   ||
4103                   (VOID_TYPE_P (ttr)
4104                    && !null_pointer_constant_p (rhs)
4105                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4106             WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of "
4107                                     "%qE between function pointer "
4108                                     "and %<void *%>"),
4109                                  G_("ISO C forbids assignment between "
4110                                     "function pointer and %<void *%>"),
4111                                  G_("ISO C forbids initialization between "
4112                                     "function pointer and %<void *%>"),
4113                                  G_("ISO C forbids return between function "
4114                                     "pointer and %<void *%>"));
4115           /* Const and volatile mean something different for function types,
4116              so the usual warnings are not appropriate.  */
4117           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4118                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4119             {
4120               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4121                 {
4122                   /* Types differing only by the presence of the 'volatile'
4123                      qualifier are acceptable if the 'volatile' has been added
4124                      in by the Objective-C EH machinery.  */
4125                   if (!objc_type_quals_match (ttl, ttr))
4126                     WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
4127                                             "qualifiers from pointer target type"),
4128                                          G_("assignment discards qualifiers "
4129                                             "from pointer target type"),
4130                                          G_("initialization discards qualifiers "
4131                                             "from pointer target type"),
4132                                          G_("return discards qualifiers from "
4133                                             "pointer target type"));
4134                 }
4135               /* If this is not a case of ignoring a mismatch in signedness,
4136                  no warning.  */
4137               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4138                        || target_cmp)
4139                 ;
4140               /* If there is a mismatch, do warn.  */
4141               else if (warn_pointer_sign)
4142                 WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument "
4143                                         "%d of %qE differ in signedness"),
4144                                      G_("pointer targets in assignment "
4145                                         "differ in signedness"),
4146                                      G_("pointer targets in initialization "
4147                                         "differ in signedness"),
4148                                      G_("pointer targets in return differ "
4149                                         "in signedness"));
4150             }
4151           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4152                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4153             {
4154               /* Because const and volatile on functions are restrictions
4155                  that say the function will not do certain things,
4156                  it is okay to use a const or volatile function
4157                  where an ordinary one is wanted, but not vice-versa.  */
4158               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4159                 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
4160                                         "qualified function pointer "
4161                                         "from unqualified"),
4162                                      G_("assignment makes qualified function "
4163                                         "pointer from unqualified"),
4164                                      G_("initialization makes qualified "
4165                                         "function pointer from unqualified"),
4166                                      G_("return makes qualified function "
4167                                         "pointer from unqualified"));
4168             }
4169         }
4170       else
4171         /* Avoid warning about the volatile ObjC EH puts on decls.  */
4172         if (!objc_ok)
4173           WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from "
4174                                   "incompatible pointer type"),
4175                                G_("assignment from incompatible pointer type"),
4176                                G_("initialization from incompatible "
4177                                   "pointer type"),
4178                                G_("return from incompatible pointer type"));
4179
4180       return convert (type, rhs);
4181     }
4182   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
4183     {
4184       /* ??? This should not be an error when inlining calls to
4185          unprototyped functions.  */
4186       error ("invalid use of non-lvalue array");
4187       return error_mark_node;
4188     }
4189   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4190     {
4191       /* An explicit constant 0 can convert to a pointer,
4192          or one that results from arithmetic, even including
4193          a cast to integer type.  */
4194       if (!null_pointer_constant_p (rhs))
4195         WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
4196                                 "pointer from integer without a cast"),
4197                              G_("assignment makes pointer from integer "
4198                                 "without a cast"),
4199                              G_("initialization makes pointer from "
4200                                 "integer without a cast"),
4201                              G_("return makes pointer from integer "
4202                                 "without a cast"));
4203
4204       return convert (type, rhs);
4205     }
4206   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4207     {
4208       WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer "
4209                               "from pointer without a cast"),
4210                            G_("assignment makes integer from pointer "
4211                               "without a cast"),
4212                            G_("initialization makes integer from pointer "
4213                               "without a cast"),
4214                            G_("return makes integer from pointer "
4215                               "without a cast"));
4216       return convert (type, rhs);
4217     }
4218   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4219     return convert (type, rhs);
4220
4221   switch (errtype)
4222     {
4223     case ic_argpass:
4224     case ic_argpass_nonproto:
4225       /* ??? This should not be an error when inlining calls to
4226          unprototyped functions.  */
4227       error ("incompatible type for argument %d of %qE", parmnum, rname);
4228       break;
4229     case ic_assign:
4230       error ("incompatible types in assignment");
4231       break;
4232     case ic_init:
4233       error ("incompatible types in initialization");
4234       break;
4235     case ic_return:
4236       error ("incompatible types in return");
4237       break;
4238     default:
4239       gcc_unreachable ();
4240     }
4241
4242   return error_mark_node;
4243 }
4244
4245 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
4246    is used for error and warning reporting and indicates which argument
4247    is being processed.  */
4248
4249 tree
4250 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
4251 {
4252   tree ret, type;
4253
4254   /* If FN was prototyped at the call site, the value has been converted
4255      already in convert_arguments.
4256      However, we might see a prototype now that was not in place when
4257      the function call was seen, so check that the VALUE actually matches
4258      PARM before taking an early exit.  */
4259   if (!value
4260       || (TYPE_ARG_TYPES (TREE_TYPE (fn))
4261           && (TYPE_MAIN_VARIANT (TREE_TYPE (parm))
4262               == TYPE_MAIN_VARIANT (TREE_TYPE (value)))))
4263     return value;
4264
4265   type = TREE_TYPE (parm);
4266   ret = convert_for_assignment (type, value,
4267                                 ic_argpass_nonproto, fn,
4268                                 fn, argnum);
4269   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
4270       && INTEGRAL_TYPE_P (type)
4271       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
4272     ret = default_conversion (ret);
4273   return ret;
4274 }
4275 \f
4276 /* If VALUE is a compound expr all of whose expressions are constant, then
4277    return its value.  Otherwise, return error_mark_node.
4278
4279    This is for handling COMPOUND_EXPRs as initializer elements
4280    which is allowed with a warning when -pedantic is specified.  */
4281
4282 static tree
4283 valid_compound_expr_initializer (tree value, tree endtype)
4284 {
4285   if (TREE_CODE (value) == COMPOUND_EXPR)
4286     {
4287       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
4288           == error_mark_node)
4289         return error_mark_node;
4290       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
4291                                               endtype);
4292     }
4293   else if (!initializer_constant_valid_p (value, endtype))
4294     return error_mark_node;
4295   else
4296     return value;
4297 }
4298 \f
4299 /* Perform appropriate conversions on the initial value of a variable,
4300    store it in the declaration DECL,
4301    and print any error messages that are appropriate.
4302    If the init is invalid, store an ERROR_MARK.  */
4303
4304 void
4305 store_init_value (tree decl, tree init)
4306 {
4307   tree value, type;
4308
4309   /* If variable's type was invalidly declared, just ignore it.  */
4310
4311   type = TREE_TYPE (decl);
4312   if (TREE_CODE (type) == ERROR_MARK)
4313     return;
4314
4315   /* Digest the specified initializer into an expression.  */
4316
4317   value = digest_init (type, init, true, TREE_STATIC (decl));
4318
4319   /* Store the expression if valid; else report error.  */
4320
4321   if (!in_system_header
4322       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
4323     warning (OPT_Wtraditional, "traditional C rejects automatic "
4324              "aggregate initialization");
4325
4326   DECL_INITIAL (decl) = value;
4327
4328   /* ANSI wants warnings about out-of-range constant initializers.  */
4329   STRIP_TYPE_NOPS (value);
4330   constant_expression_warning (value);
4331
4332   /* Check if we need to set array size from compound literal size.  */
4333   if (TREE_CODE (type) == ARRAY_TYPE
4334       && TYPE_DOMAIN (type) == 0
4335       && value != error_mark_node)
4336     {
4337       tree inside_init = init;
4338
4339       STRIP_TYPE_NOPS (inside_init);
4340       inside_init = fold (inside_init);
4341
4342       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4343         {
4344           tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4345
4346           if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
4347             {
4348               /* For int foo[] = (int [3]){1}; we need to set array size
4349                  now since later on array initializer will be just the
4350                  brace enclosed list of the compound literal.  */
4351               type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
4352               TREE_TYPE (decl) = type;
4353               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
4354               layout_type (type);
4355               layout_decl (cldecl, 0);
4356             }
4357         }
4358     }
4359 }
4360 \f
4361 /* Methods for storing and printing names for error messages.  */
4362
4363 /* Implement a spelling stack that allows components of a name to be pushed
4364    and popped.  Each element on the stack is this structure.  */
4365
4366 struct spelling
4367 {
4368   int kind;
4369   union
4370     {
4371       unsigned HOST_WIDE_INT i;
4372       const char *s;
4373     } u;
4374 };
4375
4376 #define SPELLING_STRING 1
4377 #define SPELLING_MEMBER 2
4378 #define SPELLING_BOUNDS 3
4379
4380 static struct spelling *spelling;       /* Next stack element (unused).  */
4381 static struct spelling *spelling_base;  /* Spelling stack base.  */
4382 static int spelling_size;               /* Size of the spelling stack.  */
4383
4384 /* Macros to save and restore the spelling stack around push_... functions.
4385    Alternative to SAVE_SPELLING_STACK.  */
4386
4387 #define SPELLING_DEPTH() (spelling - spelling_base)
4388 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4389
4390 /* Push an element on the spelling stack with type KIND and assign VALUE
4391    to MEMBER.  */
4392
4393 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4394 {                                                                       \
4395   int depth = SPELLING_DEPTH ();                                        \
4396                                                                         \
4397   if (depth >= spelling_size)                                           \
4398     {                                                                   \
4399       spelling_size += 10;                                              \
4400       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
4401                                   spelling_size);                       \
4402       RESTORE_SPELLING_DEPTH (depth);                                   \
4403     }                                                                   \
4404                                                                         \
4405   spelling->kind = (KIND);                                              \
4406   spelling->MEMBER = (VALUE);                                           \
4407   spelling++;                                                           \
4408 }
4409
4410 /* Push STRING on the stack.  Printed literally.  */
4411
4412 static void
4413 push_string (const char *string)
4414 {
4415   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4416 }
4417
4418 /* Push a member name on the stack.  Printed as '.' STRING.  */
4419
4420 static void
4421 push_member_name (tree decl)
4422 {
4423   const char *const string
4424     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4425   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4426 }
4427
4428 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4429
4430 static void
4431 push_array_bounds (unsigned HOST_WIDE_INT bounds)
4432 {
4433   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4434 }
4435
4436 /* Compute the maximum size in bytes of the printed spelling.  */
4437
4438 static int
4439 spelling_length (void)
4440 {
4441   int size = 0;
4442   struct spelling *p;
4443
4444   for (p = spelling_base; p < spelling; p++)
4445     {
4446       if (p->kind == SPELLING_BOUNDS)
4447         size += 25;
4448       else
4449         size += strlen (p->u.s) + 1;
4450     }
4451
4452   return size;
4453 }
4454
4455 /* Print the spelling to BUFFER and return it.  */
4456
4457 static char *
4458 print_spelling (char *buffer)
4459 {
4460   char *d = buffer;
4461   struct spelling *p;
4462
4463   for (p = spelling_base; p < spelling; p++)
4464     if (p->kind == SPELLING_BOUNDS)
4465       {
4466         sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
4467         d += strlen (d);
4468       }
4469     else
4470       {
4471         const char *s;
4472         if (p->kind == SPELLING_MEMBER)
4473           *d++ = '.';
4474         for (s = p->u.s; (*d = *s++); d++)
4475           ;
4476       }
4477   *d++ = '\0';
4478   return buffer;
4479 }
4480
4481 /* Issue an error message for a bad initializer component.
4482    MSGID identifies the message.
4483    The component name is taken from the spelling stack.  */
4484
4485 void
4486 error_init (const char *msgid)
4487 {
4488   char *ofwhat;
4489
4490   error ("%s", _(msgid));
4491   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4492   if (*ofwhat)
4493     error ("(near initialization for %qs)", ofwhat);
4494 }
4495
4496 /* Issue a pedantic warning for a bad initializer component.
4497    MSGID identifies the message.
4498    The component name is taken from the spelling stack.  */
4499
4500 void
4501 pedwarn_init (const char *msgid)
4502 {
4503   char *ofwhat;
4504
4505   pedwarn ("%s", _(msgid));
4506   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4507   if (*ofwhat)
4508     pedwarn ("(near initialization for %qs)", ofwhat);
4509 }
4510
4511 /* Issue a warning for a bad initializer component.
4512    MSGID identifies the message.
4513    The component name is taken from the spelling stack.  */
4514
4515 static void
4516 warning_init (const char *msgid)
4517 {
4518   char *ofwhat;
4519
4520   warning (0, "%s", _(msgid));
4521   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4522   if (*ofwhat)
4523     warning (0, "(near initialization for %qs)", ofwhat);
4524 }
4525 \f
4526 /* If TYPE is an array type and EXPR is a parenthesized string
4527    constant, warn if pedantic that EXPR is being used to initialize an
4528    object of type TYPE.  */
4529
4530 void
4531 maybe_warn_string_init (tree type, struct c_expr expr)
4532 {
4533   if (pedantic
4534       && TREE_CODE (type) == ARRAY_TYPE
4535       && TREE_CODE (expr.value) == STRING_CST
4536       && expr.original_code != STRING_CST)
4537     pedwarn_init ("array initialized from parenthesized string constant");
4538 }
4539
4540 /* Digest the parser output INIT as an initializer for type TYPE.
4541    Return a C expression of type TYPE to represent the initial value.
4542
4543    If INIT is a string constant, STRICT_STRING is true if it is
4544    unparenthesized or we should not warn here for it being parenthesized.
4545    For other types of INIT, STRICT_STRING is not used.
4546
4547    REQUIRE_CONSTANT requests an error if non-constant initializers or
4548    elements are seen.  */
4549
4550 static tree
4551 digest_init (tree type, tree init, bool strict_string, int require_constant)
4552 {
4553   enum tree_code code = TREE_CODE (type);
4554   tree inside_init = init;
4555
4556   if (type == error_mark_node
4557       || !init
4558       || init == error_mark_node
4559       || TREE_TYPE (init) == error_mark_node)
4560     return error_mark_node;
4561
4562   STRIP_TYPE_NOPS (inside_init);
4563
4564   inside_init = fold (inside_init);
4565
4566   /* Initialization of an array of chars from a string constant
4567      optionally enclosed in braces.  */
4568
4569   if (code == ARRAY_TYPE && inside_init
4570       && TREE_CODE (inside_init) == STRING_CST)
4571     {
4572       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4573       /* Note that an array could be both an array of character type
4574          and an array of wchar_t if wchar_t is signed char or unsigned
4575          char.  */
4576       bool char_array = (typ1 == char_type_node
4577                          || typ1 == signed_char_type_node
4578                          || typ1 == unsigned_char_type_node);
4579       bool wchar_array = !!comptypes (typ1, wchar_type_node);
4580       if (char_array || wchar_array)
4581         {
4582           struct c_expr expr;
4583           bool char_string;
4584           expr.value = inside_init;
4585           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
4586           maybe_warn_string_init (type, expr);
4587
4588           char_string
4589             = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4590                == char_type_node);
4591
4592           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4593                          TYPE_MAIN_VARIANT (type)))
4594             return inside_init;
4595
4596           if (!wchar_array && !char_string)
4597             {
4598               error_init ("char-array initialized from wide string");
4599               return error_mark_node;
4600             }
4601           if (char_string && !char_array)
4602             {
4603               error_init ("wchar_t-array initialized from non-wide string");
4604               return error_mark_node;
4605             }
4606
4607           TREE_TYPE (inside_init) = type;
4608           if (TYPE_DOMAIN (type) != 0
4609               && TYPE_SIZE (type) != 0
4610               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4611               /* Subtract 1 (or sizeof (wchar_t))
4612                  because it's ok to ignore the terminating null char
4613                  that is counted in the length of the constant.  */
4614               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4615                                        TREE_STRING_LENGTH (inside_init)
4616                                        - ((TYPE_PRECISION (typ1)
4617                                            != TYPE_PRECISION (char_type_node))
4618                                           ? (TYPE_PRECISION (wchar_type_node)
4619                                              / BITS_PER_UNIT)
4620                                           : 1)))
4621             pedwarn_init ("initializer-string for array of chars is too long");
4622
4623           return inside_init;
4624         }
4625       else if (INTEGRAL_TYPE_P (typ1))
4626         {
4627           error_init ("array of inappropriate type initialized "
4628                       "from string constant");
4629           return error_mark_node;
4630         }
4631     }
4632
4633   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
4634      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4635      below and handle as a constructor.  */
4636   if (code == VECTOR_TYPE
4637       && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
4638       && vector_types_convertible_p (TREE_TYPE (inside_init), type)
4639       && TREE_CONSTANT (inside_init))
4640     {
4641       if (TREE_CODE (inside_init) == VECTOR_CST
4642           && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4643                         TYPE_MAIN_VARIANT (type)))
4644         return inside_init;
4645
4646       if (TREE_CODE (inside_init) == CONSTRUCTOR)
4647         {
4648           unsigned HOST_WIDE_INT ix;
4649           tree value;
4650           bool constant_p = true;
4651
4652           /* Iterate through elements and check if all constructor
4653              elements are *_CSTs.  */
4654           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
4655             if (!CONSTANT_CLASS_P (value))
4656               {
4657                 constant_p = false;
4658                 break;
4659               }
4660
4661           if (constant_p)
4662             return build_vector_from_ctor (type,
4663                                            CONSTRUCTOR_ELTS (inside_init));
4664         }
4665     }
4666
4667   /* Any type can be initialized
4668      from an expression of the same type, optionally with braces.  */
4669
4670   if (inside_init && TREE_TYPE (inside_init) != 0
4671       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4672                      TYPE_MAIN_VARIANT (type))
4673           || (code == ARRAY_TYPE
4674               && comptypes (TREE_TYPE (inside_init), type))
4675           || (code == VECTOR_TYPE
4676               && comptypes (TREE_TYPE (inside_init), type))
4677           || (code == POINTER_TYPE
4678               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4679               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4680                             TREE_TYPE (type)))))
4681     {
4682       if (code == POINTER_TYPE)
4683         {
4684           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4685             {
4686               if (TREE_CODE (inside_init) == STRING_CST
4687                   || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4688                 inside_init = array_to_pointer_conversion (inside_init);
4689               else
4690                 {
4691                   error_init ("invalid use of non-lvalue array");
4692                   return error_mark_node;
4693                 }
4694             }
4695         }
4696
4697       if (code == VECTOR_TYPE)
4698         /* Although the types are compatible, we may require a
4699            conversion.  */
4700         inside_init = convert (type, inside_init);
4701
4702       if (require_constant && !flag_isoc99
4703           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4704         {
4705           /* As an extension, allow initializing objects with static storage
4706              duration with compound literals (which are then treated just as
4707              the brace enclosed list they contain).  */
4708           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4709           inside_init = DECL_INITIAL (decl);
4710         }
4711
4712       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4713           && TREE_CODE (inside_init) != CONSTRUCTOR)
4714         {
4715           error_init ("array initialized from non-constant array expression");
4716           return error_mark_node;
4717         }
4718
4719       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4720         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4721
4722       /* Compound expressions can only occur here if -pedantic or
4723          -pedantic-errors is specified.  In the later case, we always want
4724          an error.  In the former case, we simply want a warning.  */
4725       if (require_constant && pedantic
4726           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4727         {
4728           inside_init
4729             = valid_compound_expr_initializer (inside_init,
4730                                                TREE_TYPE (inside_init));
4731           if (inside_init == error_mark_node)
4732             error_init ("initializer element is not constant");
4733           else
4734             pedwarn_init ("initializer element is not constant");
4735           if (flag_pedantic_errors)
4736             inside_init = error_mark_node;
4737         }
4738       else if (require_constant
4739                && !initializer_constant_valid_p (inside_init,
4740                                                  TREE_TYPE (inside_init)))
4741         {
4742           error_init ("initializer element is not constant");
4743           inside_init = error_mark_node;
4744         }
4745
4746       /* Added to enable additional -Wmissing-format-attribute warnings.  */
4747       if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
4748         inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE,
4749                                               NULL_TREE, 0);
4750       return inside_init;
4751     }
4752
4753   /* Handle scalar types, including conversions.  */
4754
4755   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4756       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4757       || code == VECTOR_TYPE)
4758     {
4759       if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
4760           && (TREE_CODE (init) == STRING_CST
4761               || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
4762         init = array_to_pointer_conversion (init);
4763       inside_init
4764         = convert_for_assignment (type, init, ic_init,
4765                                   NULL_TREE, NULL_TREE, 0);
4766
4767       /* Check to see if we have already given an error message.  */
4768       if (inside_init == error_mark_node)
4769         ;
4770       else if (require_constant && !TREE_CONSTANT (inside_init))
4771         {
4772           error_init ("initializer element is not constant");
4773           inside_init = error_mark_node;
4774         }
4775       else if (require_constant
4776                && !initializer_constant_valid_p (inside_init,
4777                                                  TREE_TYPE (inside_init)))
4778         {
4779           error_init ("initializer element is not computable at load time");
4780           inside_init = error_mark_node;
4781         }
4782
4783       return inside_init;
4784     }
4785
4786   /* Come here only for records and arrays.  */
4787
4788   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4789     {
4790       error_init ("variable-sized object may not be initialized");
4791       return error_mark_node;
4792     }
4793
4794   error_init ("invalid initializer");
4795   return error_mark_node;
4796 }
4797 \f
4798 /* Handle initializers that use braces.  */
4799
4800 /* Type of object we are accumulating a constructor for.
4801    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4802 static tree constructor_type;
4803
4804 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4805    left to fill.  */
4806 static tree constructor_fields;
4807
4808 /* For an ARRAY_TYPE, this is the specified index
4809    at which to store the next element we get.  */
4810 static tree constructor_index;
4811
4812 /* For an ARRAY_TYPE, this is the maximum index.  */
4813 static tree constructor_max_index;
4814
4815 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4816 static tree constructor_unfilled_fields;
4817
4818 /* For an ARRAY_TYPE, this is the index of the first element
4819    not yet written out.  */
4820 static tree constructor_unfilled_index;
4821
4822 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4823    This is so we can generate gaps between fields, when appropriate.  */
4824 static tree constructor_bit_index;
4825
4826 /* If we are saving up the elements rather than allocating them,
4827    this is the list of elements so far (in reverse order,
4828    most recent first).  */
4829 static VEC(constructor_elt,gc) *constructor_elements;
4830
4831 /* 1 if constructor should be incrementally stored into a constructor chain,
4832    0 if all the elements should be kept in AVL tree.  */
4833 static int constructor_incremental;
4834
4835 /* 1 if so far this constructor's elements are all compile-time constants.  */
4836 static int constructor_constant;
4837
4838 /* 1 if so far this constructor's elements are all valid address constants.  */
4839 static int constructor_simple;
4840
4841 /* 1 if this constructor is erroneous so far.  */
4842 static int constructor_erroneous;
4843
4844 /* Structure for managing pending initializer elements, organized as an
4845    AVL tree.  */
4846
4847 struct init_node
4848 {
4849   struct init_node *left, *right;
4850   struct init_node *parent;
4851   int balance;
4852   tree purpose;
4853   tree value;
4854 };
4855
4856 /* Tree of pending elements at this constructor level.
4857    These are elements encountered out of order
4858    which belong at places we haven't reached yet in actually
4859    writing the output.
4860    Will never hold tree nodes across GC runs.  */
4861 static struct init_node *constructor_pending_elts;
4862
4863 /* The SPELLING_DEPTH of this constructor.  */
4864 static int constructor_depth;
4865
4866 /* DECL node for which an initializer is being read.
4867    0 means we are reading a constructor expression
4868    such as (struct foo) {...}.  */
4869 static tree constructor_decl;
4870
4871 /* Nonzero if this is an initializer for a top-level decl.  */
4872 static int constructor_top_level;
4873
4874 /* Nonzero if there were any member designators in this initializer.  */
4875 static int constructor_designated;
4876
4877 /* Nesting depth of designator list.  */
4878 static int designator_depth;
4879
4880 /* Nonzero if there were diagnosed errors in this designator list.  */
4881 static int designator_erroneous;
4882
4883 \f
4884 /* This stack has a level for each implicit or explicit level of
4885    structuring in the initializer, including the outermost one.  It
4886    saves the values of most of the variables above.  */
4887
4888 struct constructor_range_stack;
4889
4890 struct constructor_stack
4891 {
4892   struct constructor_stack *next;
4893   tree type;
4894   tree fields;
4895   tree index;
4896   tree max_index;
4897   tree unfilled_index;
4898   tree unfilled_fields;
4899   tree bit_index;
4900   VEC(constructor_elt,gc) *elements;
4901   struct init_node *pending_elts;
4902   int offset;
4903   int depth;
4904   /* If value nonzero, this value should replace the entire
4905      constructor at this level.  */
4906   struct c_expr replacement_value;
4907   struct constructor_range_stack *range_stack;
4908   char constant;
4909   char simple;
4910   char implicit;
4911   char erroneous;
4912   char outer;
4913   char incremental;
4914   char designated;
4915 };
4916
4917 static struct constructor_stack *constructor_stack;
4918
4919 /* This stack represents designators from some range designator up to
4920    the last designator in the list.  */
4921
4922 struct constructor_range_stack
4923 {
4924   struct constructor_range_stack *next, *prev;
4925   struct constructor_stack *stack;
4926   tree range_start;
4927   tree index;
4928   tree range_end;
4929   tree fields;
4930 };
4931
4932 static struct constructor_range_stack *constructor_range_stack;
4933
4934 /* This stack records separate initializers that are nested.
4935    Nested initializers can't happen in ANSI C, but GNU C allows them
4936    in cases like { ... (struct foo) { ... } ... }.  */
4937
4938 struct initializer_stack
4939 {
4940   struct initializer_stack *next;
4941   tree decl;
4942   struct constructor_stack *constructor_stack;
4943   struct constructor_range_stack *constructor_range_stack;
4944   VEC(constructor_elt,gc) *elements;
4945   struct spelling *spelling;
4946   struct spelling *spelling_base;
4947   int spelling_size;
4948   char top_level;
4949   char require_constant_value;
4950   char require_constant_elements;
4951 };
4952
4953 static struct initializer_stack *initializer_stack;
4954 \f
4955 /* Prepare to parse and output the initializer for variable DECL.  */
4956
4957 void
4958 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
4959 {
4960   const char *locus;
4961   struct initializer_stack *p = XNEW (struct initializer_stack);
4962
4963   p->decl = constructor_decl;
4964   p->require_constant_value = require_constant_value;
4965   p->require_constant_elements = require_constant_elements;
4966   p->constructor_stack = constructor_stack;
4967   p->constructor_range_stack = constructor_range_stack;
4968   p->elements = constructor_elements;
4969   p->spelling = spelling;
4970   p->spelling_base = spelling_base;
4971   p->spelling_size = spelling_size;
4972   p->top_level = constructor_top_level;
4973   p->next = initializer_stack;
4974   initializer_stack = p;
4975
4976   constructor_decl = decl;
4977   constructor_designated = 0;
4978   constructor_top_level = top_level;
4979
4980   if (decl != 0 && decl != error_mark_node)
4981     {
4982       require_constant_value = TREE_STATIC (decl);
4983       require_constant_elements
4984         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4985            /* For a scalar, you can always use any value to initialize,
4986               even within braces.  */
4987            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4988                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4989                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4990                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4991       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4992     }
4993   else
4994     {
4995       require_constant_value = 0;
4996       require_constant_elements = 0;
4997       locus = "(anonymous)";
4998     }
4999
5000   constructor_stack = 0;
5001   constructor_range_stack = 0;
5002
5003   missing_braces_mentioned = 0;
5004
5005   spelling_base = 0;
5006   spelling_size = 0;
5007   RESTORE_SPELLING_DEPTH (0);
5008
5009   if (locus)
5010     push_string (locus);
5011 }
5012
5013 void
5014 finish_init (void)
5015 {
5016   struct initializer_stack *p = initializer_stack;
5017
5018   /* Free the whole constructor stack of this initializer.  */
5019   while (constructor_stack)
5020     {
5021       struct constructor_stack *q = constructor_stack;
5022       constructor_stack = q->next;
5023       free (q);
5024     }
5025
5026   gcc_assert (!constructor_range_stack);
5027
5028   /* Pop back to the data of the outer initializer (if any).  */
5029   free (spelling_base);
5030
5031   constructor_decl = p->decl;
5032   require_constant_value = p->require_constant_value;
5033   require_constant_elements = p->require_constant_elements;
5034   constructor_stack = p->constructor_stack;
5035   constructor_range_stack = p->constructor_range_stack;
5036   constructor_elements = p->elements;
5037   spelling = p->spelling;
5038   spelling_base = p->spelling_base;
5039   spelling_size = p->spelling_size;
5040   constructor_top_level = p->top_level;
5041   initializer_stack = p->next;
5042   free (p);
5043 }
5044 \f
5045 /* Call here when we see the initializer is surrounded by braces.
5046    This is instead of a call to push_init_level;
5047    it is matched by a call to pop_init_level.
5048
5049    TYPE is the type to initialize, for a constructor expression.
5050    For an initializer for a decl, TYPE is zero.  */
5051
5052 void
5053 really_start_incremental_init (tree type)
5054 {
5055   struct constructor_stack *p = XNEW (struct constructor_stack);
5056
5057   if (type == 0)
5058     type = TREE_TYPE (constructor_decl);
5059
5060   if (targetm.vector_opaque_p (type))
5061     error ("opaque vector types cannot be initialized");
5062
5063   p->type = constructor_type;
5064   p->fields = constructor_fields;
5065   p->index = constructor_index;
5066   p->max_index = constructor_max_index;
5067   p->unfilled_index = constructor_unfilled_index;
5068   p->unfilled_fields = constructor_unfilled_fields;
5069   p->bit_index = constructor_bit_index;
5070   p->elements = constructor_elements;
5071   p->constant = constructor_constant;
5072   p->simple = constructor_simple;
5073   p->erroneous = constructor_erroneous;
5074   p->pending_elts = constructor_pending_elts;
5075   p->depth = constructor_depth;
5076   p->replacement_value.value = 0;
5077   p->replacement_value.original_code = ERROR_MARK;
5078   p->implicit = 0;
5079   p->range_stack = 0;
5080   p->outer = 0;
5081   p->incremental = constructor_incremental;
5082   p->designated = constructor_designated;
5083   p->next = 0;
5084   constructor_stack = p;
5085
5086   constructor_constant = 1;
5087   constructor_simple = 1;
5088   constructor_depth = SPELLING_DEPTH ();
5089   constructor_elements = 0;
5090   constructor_pending_elts = 0;
5091   constructor_type = type;
5092   constructor_incremental = 1;
5093   constructor_designated = 0;
5094   designator_depth = 0;
5095   designator_erroneous = 0;
5096
5097   if (TREE_CODE (constructor_type) == RECORD_TYPE
5098       || TREE_CODE (constructor_type) == UNION_TYPE)
5099     {
5100       constructor_fields = TYPE_FIELDS (constructor_type);
5101       /* Skip any nameless bit fields at the beginning.  */
5102       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5103              && DECL_NAME (constructor_fields) == 0)
5104         constructor_fields = TREE_CHAIN (constructor_fields);
5105
5106       constructor_unfilled_fields = constructor_fields;
5107       constructor_bit_index = bitsize_zero_node;
5108     }
5109   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5110     {
5111       if (TYPE_DOMAIN (constructor_type))
5112         {
5113           constructor_max_index
5114             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5115
5116           /* Detect non-empty initializations of zero-length arrays.  */
5117           if (constructor_max_index == NULL_TREE
5118               && TYPE_SIZE (constructor_type))
5119             constructor_max_index = build_int_cst (NULL_TREE, -1);
5120
5121           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5122              to initialize VLAs will cause a proper error; avoid tree
5123              checking errors as well by setting a safe value.  */
5124           if (constructor_max_index
5125               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5126             constructor_max_index = build_int_cst (NULL_TREE, -1);
5127
5128           constructor_index
5129             = convert (bitsizetype,
5130                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5131         }
5132       else
5133         {
5134           constructor_index = bitsize_zero_node;
5135           constructor_max_index = NULL_TREE;
5136         }
5137
5138       constructor_unfilled_index = constructor_index;
5139     }
5140   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5141     {
5142       /* Vectors are like simple fixed-size arrays.  */
5143       constructor_max_index =
5144         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
5145       constructor_index = bitsize_zero_node;
5146       constructor_unfilled_index = constructor_index;
5147     }
5148   else
5149     {
5150       /* Handle the case of int x = {5}; */
5151       constructor_fields = constructor_type;
5152       constructor_unfilled_fields = constructor_type;
5153     }
5154 }
5155 \f
5156 /* Push down into a subobject, for initialization.
5157    If this is for an explicit set of braces, IMPLICIT is 0.
5158    If it is because the next element belongs at a lower level,
5159    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
5160
5161 void
5162 push_init_level (int implicit)
5163 {
5164   struct constructor_stack *p;
5165   tree value = NULL_TREE;
5166
5167   /* If we've exhausted any levels that didn't have braces,
5168      pop them now.  If implicit == 1, this will have been done in
5169      process_init_element; do not repeat it here because in the case
5170      of excess initializers for an empty aggregate this leads to an
5171      infinite cycle of popping a level and immediately recreating
5172      it.  */
5173   if (implicit != 1)
5174     {
5175       while (constructor_stack->implicit)
5176         {
5177           if ((TREE_CODE (constructor_type) == RECORD_TYPE
5178                || TREE_CODE (constructor_type) == UNION_TYPE)
5179               && constructor_fields == 0)
5180             process_init_element (pop_init_level (1));
5181           else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5182                    && constructor_max_index
5183                    && tree_int_cst_lt (constructor_max_index,
5184                                        constructor_index))
5185             process_init_element (pop_init_level (1));
5186           else
5187             break;
5188         }
5189     }
5190
5191   /* Unless this is an explicit brace, we need to preserve previous
5192      content if any.  */
5193   if (implicit)
5194     {
5195       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5196            || TREE_CODE (constructor_type) == UNION_TYPE)
5197           && constructor_fields)
5198         value = find_init_member (constructor_fields);
5199       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5200         value = find_init_member (constructor_index);
5201     }
5202
5203   p = XNEW (struct constructor_stack);
5204   p->type = constructor_type;
5205   p->fields = constructor_fields;
5206   p->index = constructor_index;
5207   p->max_index = constructor_max_index;
5208   p->unfilled_index = constructor_unfilled_index;
5209   p->unfilled_fields = constructor_unfilled_fields;
5210   p->bit_index = constructor_bit_index;
5211   p->elements = constructor_elements;
5212   p->constant = constructor_constant;
5213   p->simple = constructor_simple;
5214   p->erroneous = constructor_erroneous;
5215   p->pending_elts = constructor_pending_elts;
5216   p->depth = constructor_depth;
5217   p->replacement_value.value = 0;
5218   p->replacement_value.original_code = ERROR_MARK;
5219   p->implicit = implicit;
5220   p->outer = 0;
5221   p->incremental = constructor_incremental;
5222   p->designated = constructor_designated;
5223   p->next = constructor_stack;
5224   p->range_stack = 0;
5225   constructor_stack = p;
5226
5227   constructor_constant = 1;
5228   constructor_simple = 1;
5229   constructor_depth = SPELLING_DEPTH ();
5230   constructor_elements = 0;
5231   constructor_incremental = 1;
5232   constructor_designated = 0;
5233   constructor_pending_elts = 0;
5234   if (!implicit)
5235     {
5236       p->range_stack = constructor_range_stack;
5237       constructor_range_stack = 0;
5238       designator_depth = 0;
5239       designator_erroneous = 0;
5240     }
5241
5242   /* Don't die if an entire brace-pair level is superfluous
5243      in the containing level.  */
5244   if (constructor_type == 0)
5245     ;
5246   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5247            || TREE_CODE (constructor_type) == UNION_TYPE)
5248     {
5249       /* Don't die if there are extra init elts at the end.  */
5250       if (constructor_fields == 0)
5251         constructor_type = 0;
5252       else
5253         {
5254           constructor_type = TREE_TYPE (constructor_fields);
5255           push_member_name (constructor_fields);
5256           constructor_depth++;
5257         }
5258     }
5259   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5260     {
5261       constructor_type = TREE_TYPE (constructor_type);
5262       push_array_bounds (tree_low_cst (constructor_index, 1));
5263       constructor_depth++;
5264     }
5265
5266   if (constructor_type == 0)
5267     {
5268       error_init ("extra brace group at end of initializer");
5269       constructor_fields = 0;
5270       constructor_unfilled_fields = 0;
5271       return;
5272     }
5273
5274   if (value && TREE_CODE (value) == CONSTRUCTOR)
5275     {
5276       constructor_constant = TREE_CONSTANT (value);
5277       constructor_simple = TREE_STATIC (value);
5278       constructor_elements = CONSTRUCTOR_ELTS (value);
5279       if (!VEC_empty (constructor_elt, constructor_elements)
5280           && (TREE_CODE (constructor_type) == RECORD_TYPE
5281               || TREE_CODE (constructor_type) == ARRAY_TYPE))
5282         set_nonincremental_init ();
5283     }
5284
5285   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
5286     {
5287       missing_braces_mentioned = 1;
5288       warning_init ("missing braces around initializer");
5289     }
5290
5291   if (TREE_CODE (constructor_type) == RECORD_TYPE
5292            || TREE_CODE (constructor_type) == UNION_TYPE)
5293     {
5294       constructor_fields = TYPE_FIELDS (constructor_type);
5295       /* Skip any nameless bit fields at the beginning.  */
5296       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5297              && DECL_NAME (constructor_fields) == 0)
5298         constructor_fields = TREE_CHAIN (constructor_fields);
5299
5300       constructor_unfilled_fields = constructor_fields;
5301       constructor_bit_index = bitsize_zero_node;
5302     }
5303   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5304     {
5305       /* Vectors are like simple fixed-size arrays.  */
5306       constructor_max_index =
5307         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
5308       constructor_index = convert (bitsizetype, integer_zero_node);
5309       constructor_unfilled_index = constructor_index;
5310     }
5311   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5312     {
5313       if (TYPE_DOMAIN (constructor_type))
5314         {
5315           constructor_max_index
5316             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5317
5318           /* Detect non-empty initializations of zero-length arrays.  */
5319           if (constructor_max_index == NULL_TREE
5320               && TYPE_SIZE (constructor_type))
5321             constructor_max_index = build_int_cst (NULL_TREE, -1);
5322
5323           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5324              to initialize VLAs will cause a proper error; avoid tree
5325              checking errors as well by setting a safe value.  */
5326           if (constructor_max_index
5327               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5328             constructor_max_index = build_int_cst (NULL_TREE, -1);
5329
5330           constructor_index
5331             = convert (bitsizetype,
5332                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5333         }
5334       else
5335         constructor_index = bitsize_zero_node;
5336
5337       constructor_unfilled_index = constructor_index;
5338       if (value && TREE_CODE (value) == STRING_CST)
5339         {
5340           /* We need to split the char/wchar array into individual
5341              characters, so that we don't have to special case it
5342              everywhere.  */
5343           set_nonincremental_init_from_string (value);
5344         }
5345     }
5346   else
5347     {
5348       if (constructor_type != error_mark_node)
5349         warning_init ("braces around scalar initializer");
5350       constructor_fields = constructor_type;
5351       constructor_unfilled_fields = constructor_type;
5352     }
5353 }
5354
5355 /* At the end of an implicit or explicit brace level,
5356    finish up that level of constructor.  If a single expression
5357    with redundant braces initialized that level, return the
5358    c_expr structure for that expression.  Otherwise, the original_code
5359    element is set to ERROR_MARK.
5360    If we were outputting the elements as they are read, return 0 as the value
5361    from inner levels (process_init_element ignores that),
5362    but return error_mark_node as the value from the outermost level
5363    (that's what we want to put in DECL_INITIAL).
5364    Otherwise, return a CONSTRUCTOR expression as the value.  */
5365
5366 struct c_expr
5367 pop_init_level (int implicit)
5368 {
5369   struct constructor_stack *p;
5370   struct c_expr ret;
5371   ret.value = 0;
5372   ret.original_code = ERROR_MARK;
5373
5374   if (implicit == 0)
5375     {
5376       /* When we come to an explicit close brace,
5377          pop any inner levels that didn't have explicit braces.  */
5378       while (constructor_stack->implicit)
5379         process_init_element (pop_init_level (1));
5380
5381       gcc_assert (!constructor_range_stack);
5382     }
5383
5384   /* Now output all pending elements.  */
5385   constructor_incremental = 1;
5386   output_pending_init_elements (1);
5387
5388   p = constructor_stack;
5389
5390   /* Error for initializing a flexible array member, or a zero-length
5391      array member in an inappropriate context.  */
5392   if (constructor_type && constructor_fields
5393       && TREE_CODE (constructor_type) == ARRAY_TYPE
5394       && TYPE_DOMAIN (constructor_type)
5395       && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5396     {
5397       /* Silently discard empty initializations.  The parser will
5398          already have pedwarned for empty brackets.  */
5399       if (integer_zerop (constructor_unfilled_index))
5400         constructor_type = NULL_TREE;
5401       else
5402         {
5403           gcc_assert (!TYPE_SIZE (constructor_type));
5404
5405           if (constructor_depth > 2)
5406             error_init ("initialization of flexible array member in a nested context");
5407           else if (pedantic)
5408             pedwarn_init ("initialization of a flexible array member");
5409
5410           /* We have already issued an error message for the existence
5411              of a flexible array member not at the end of the structure.
5412              Discard the initializer so that we do not die later.  */
5413           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5414             constructor_type = NULL_TREE;
5415         }
5416     }
5417
5418   /* Warn when some struct elements are implicitly initialized to zero.  */
5419   if (warn_missing_field_initializers
5420       && constructor_type
5421       && TREE_CODE (constructor_type) == RECORD_TYPE
5422       && constructor_unfilled_fields)
5423     {
5424         /* Do not warn for flexible array members or zero-length arrays.  */
5425         while (constructor_unfilled_fields
5426                && (!DECL_SIZE (constructor_unfilled_fields)
5427                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5428           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5429
5430         /* Do not warn if this level of the initializer uses member
5431            designators; it is likely to be deliberate.  */
5432         if (constructor_unfilled_fields && !constructor_designated)
5433           {
5434             push_member_name (constructor_unfilled_fields);
5435             warning_init ("missing initializer");
5436             RESTORE_SPELLING_DEPTH (constructor_depth);
5437           }
5438     }
5439
5440   /* Pad out the end of the structure.  */
5441   if (p->replacement_value.value)
5442     /* If this closes a superfluous brace pair,
5443        just pass out the element between them.  */
5444     ret = p->replacement_value;
5445   else if (constructor_type == 0)
5446     ;
5447   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5448            && TREE_CODE (constructor_type) != UNION_TYPE
5449            && TREE_CODE (constructor_type) != ARRAY_TYPE
5450            && TREE_CODE (constructor_type) != VECTOR_TYPE)
5451     {
5452       /* A nonincremental scalar initializer--just return
5453          the element, after verifying there is just one.  */
5454       if (VEC_empty (constructor_elt,constructor_elements))
5455         {
5456           if (!constructor_erroneous)
5457             error_init ("empty scalar initializer");
5458           ret.value = error_mark_node;
5459         }
5460       else if (VEC_length (constructor_elt,constructor_elements) != 1)
5461         {
5462           error_init ("extra elements in scalar initializer");
5463           ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
5464         }
5465       else
5466         ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
5467     }
5468   else
5469     {
5470       if (constructor_erroneous)
5471         ret.value = error_mark_node;
5472       else
5473         {
5474           ret.value = build_constructor (constructor_type,
5475                                          constructor_elements);
5476           if (constructor_constant)
5477             TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
5478           if (constructor_constant && constructor_simple)
5479             TREE_STATIC (ret.value) = 1;
5480         }
5481     }
5482
5483   constructor_type = p->type;
5484   constructor_fields = p->fields;
5485   constructor_index = p->index;
5486   constructor_max_index = p->max_index;
5487   constructor_unfilled_index = p->unfilled_index;
5488   constructor_unfilled_fields = p->unfilled_fields;
5489   constructor_bit_index = p->bit_index;
5490   constructor_elements = p->elements;
5491   constructor_constant = p->constant;
5492   constructor_simple = p->simple;
5493   constructor_erroneous = p->erroneous;
5494   constructor_incremental = p->incremental;
5495   constructor_designated = p->designated;
5496   constructor_pending_elts = p->pending_elts;
5497   constructor_depth = p->depth;
5498   if (!p->implicit)
5499     constructor_range_stack = p->range_stack;
5500   RESTORE_SPELLING_DEPTH (constructor_depth);
5501
5502   constructor_stack = p->next;
5503   free (p);
5504
5505   if (ret.value == 0 && constructor_stack == 0)
5506     ret.value = error_mark_node;
5507   return ret;
5508 }
5509
5510 /* Common handling for both array range and field name designators.
5511    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
5512
5513 static int
5514 set_designator (int array)
5515 {
5516   tree subtype;
5517   enum tree_code subcode;
5518
5519   /* Don't die if an entire brace-pair level is superfluous
5520      in the containing level.  */
5521   if (constructor_type == 0)
5522     return 1;
5523
5524   /* If there were errors in this designator list already, bail out
5525      silently.  */
5526   if (designator_erroneous)
5527     return 1;
5528
5529   if (!designator_depth)
5530     {
5531       gcc_assert (!constructor_range_stack);
5532
5533       /* Designator list starts at the level of closest explicit
5534          braces.  */
5535       while (constructor_stack->implicit)
5536         process_init_element (pop_init_level (1));
5537       constructor_designated = 1;
5538       return 0;
5539     }
5540
5541   switch (TREE_CODE (constructor_type))
5542     {
5543     case  RECORD_TYPE:
5544     case  UNION_TYPE:
5545       subtype = TREE_TYPE (constructor_fields);
5546       if (subtype != error_mark_node)
5547         subtype = TYPE_MAIN_VARIANT (subtype);
5548       break;
5549     case ARRAY_TYPE:
5550       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5551       break;
5552     default:
5553       gcc_unreachable ();
5554     }
5555
5556   subcode = TREE_CODE (subtype);
5557   if (array && subcode != ARRAY_TYPE)
5558     {
5559       error_init ("array index in non-array initializer");
5560       return 1;
5561     }
5562   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5563     {
5564       error_init ("field name not in record or union initializer");
5565       return 1;
5566     }
5567
5568   constructor_designated = 1;
5569   push_init_level (2);
5570   return 0;
5571 }
5572
5573 /* If there are range designators in designator list, push a new designator
5574    to constructor_range_stack.  RANGE_END is end of such stack range or
5575    NULL_TREE if there is no range designator at this level.  */
5576
5577 static void
5578 push_range_stack (tree range_end)
5579 {
5580   struct constructor_range_stack *p;
5581
5582   p = GGC_NEW (struct constructor_range_stack);
5583   p->prev = constructor_range_stack;
5584   p->next = 0;
5585   p->fields = constructor_fields;
5586   p->range_start = constructor_index;
5587   p->index = constructor_index;
5588   p->stack = constructor_stack;
5589   p->range_end = range_end;
5590   if (constructor_range_stack)
5591     constructor_range_stack->next = p;
5592   constructor_range_stack = p;
5593 }
5594
5595 /* Within an array initializer, specify the next index to be initialized.
5596    FIRST is that index.  If LAST is nonzero, then initialize a range
5597    of indices, running from FIRST through LAST.  */
5598
5599 void
5600 set_init_index (tree first, tree last)
5601 {
5602   if (set_designator (1))
5603     return;
5604
5605   designator_erroneous = 1;
5606
5607   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
5608       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
5609     {
5610       error_init ("array index in initializer not of integer type");
5611       return;
5612     }
5613
5614   if (TREE_CODE (first) != INTEGER_CST)
5615     error_init ("nonconstant array index in initializer");
5616   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5617     error_init ("nonconstant array index in initializer");
5618   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5619     error_init ("array index in non-array initializer");
5620   else if (tree_int_cst_sgn (first) == -1)
5621     error_init ("array index in initializer exceeds array bounds");
5622   else if (constructor_max_index
5623            && tree_int_cst_lt (constructor_max_index, first))
5624     error_init ("array index in initializer exceeds array bounds");
5625   else
5626     {
5627       constructor_index = convert (bitsizetype, first);
5628
5629       if (last)
5630         {
5631           if (tree_int_cst_equal (first, last))
5632             last = 0;
5633           else if (tree_int_cst_lt (last, first))
5634             {
5635               error_init ("empty index range in initializer");
5636               last = 0;
5637             }
5638           else
5639             {
5640               last = convert (bitsizetype, last);
5641               if (constructor_max_index != 0
5642                   && tree_int_cst_lt (constructor_max_index, last))
5643                 {
5644                   error_init ("array index range in initializer exceeds array bounds");
5645                   last = 0;
5646                 }
5647             }
5648         }
5649
5650       designator_depth++;
5651       designator_erroneous = 0;
5652       if (constructor_range_stack || last)
5653         push_range_stack (last);
5654     }
5655 }
5656
5657 /* Within a struct initializer, specify the next field to be initialized.  */
5658
5659 void
5660 set_init_label (tree fieldname)
5661 {
5662   tree tail;
5663
5664   if (set_designator (0))
5665     return;
5666
5667   designator_erroneous = 1;
5668
5669   if (TREE_CODE (constructor_type) != RECORD_TYPE
5670       && TREE_CODE (constructor_type) != UNION_TYPE)
5671     {
5672       error_init ("field name not in record or union initializer");
5673       return;
5674     }
5675
5676   for (tail = TYPE_FIELDS (constructor_type); tail;
5677        tail = TREE_CHAIN (tail))
5678     {
5679       if (DECL_NAME (tail) == fieldname)
5680         break;
5681     }
5682
5683   if (tail == 0)
5684     error ("unknown field %qE specified in initializer", fieldname);
5685   else
5686     {
5687       constructor_fields = tail;
5688       designator_depth++;
5689       designator_erroneous = 0;
5690       if (constructor_range_stack)
5691         push_range_stack (NULL_TREE);
5692     }
5693 }
5694 \f
5695 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5696    identifies the initializer, either array index or field in a structure.
5697    VALUE is the value of that index or field.  */
5698
5699 static void
5700 add_pending_init (tree purpose, tree value)
5701 {
5702   struct init_node *p, **q, *r;
5703
5704   q = &constructor_pending_elts;
5705   p = 0;
5706
5707   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5708     {
5709       while (*q != 0)
5710         {
5711           p = *q;
5712           if (tree_int_cst_lt (purpose, p->purpose))
5713             q = &p->left;
5714           else if (tree_int_cst_lt (p->purpose, purpose))
5715             q = &p->right;
5716           else
5717             {
5718               if (TREE_SIDE_EFFECTS (p->value))
5719                 warning_init ("initialized field with side-effects overwritten");
5720               p->value = value;
5721               return;
5722             }
5723         }
5724     }
5725   else
5726     {
5727       tree bitpos;
5728
5729       bitpos = bit_position (purpose);
5730       while (*q != NULL)
5731         {
5732           p = *q;
5733           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5734             q = &p->left;
5735           else if (p->purpose != purpose)
5736             q = &p->right;
5737           else
5738             {
5739               if (TREE_SIDE_EFFECTS (p->value))
5740                 warning_init ("initialized field with side-effects overwritten");
5741               p->value = value;
5742               return;
5743             }
5744         }
5745     }
5746
5747   r = GGC_NEW (struct init_node);
5748   r->purpose = purpose;
5749   r->value = value;
5750
5751   *q = r;
5752   r->parent = p;
5753   r->left = 0;
5754   r->right = 0;
5755   r->balance = 0;
5756
5757   while (p)
5758     {
5759       struct init_node *s;
5760
5761       if (r == p->left)
5762         {
5763           if (p->balance == 0)
5764             p->balance = -1;
5765           else if (p->balance < 0)
5766             {
5767               if (r->balance < 0)
5768                 {
5769                   /* L rotation.  */
5770                   p->left = r->right;
5771                   if (p->left)
5772                     p->left->parent = p;
5773                   r->right = p;
5774
5775                   p->balance = 0;
5776                   r->balance = 0;
5777
5778                   s = p->parent;
5779                   p->parent = r;
5780                   r->parent = s;
5781                   if (s)
5782                     {
5783                       if (s->left == p)
5784                         s->left = r;
5785                       else
5786                         s->right = r;
5787                     }
5788                   else
5789                     constructor_pending_elts = r;
5790                 }
5791               else
5792                 {
5793                   /* LR rotation.  */
5794                   struct init_node *t = r->right;
5795
5796                   r->right = t->left;
5797                   if (r->right)
5798                     r->right->parent = r;
5799                   t->left = r;
5800
5801                   p->left = t->right;
5802                   if (p->left)
5803                     p->left->parent = p;
5804                   t->right = p;
5805
5806                   p->balance = t->balance < 0;
5807                   r->balance = -(t->balance > 0);
5808                   t->balance = 0;
5809
5810                   s = p->parent;
5811                   p->parent = t;
5812                   r->parent = t;
5813                   t->parent = s;
5814                   if (s)
5815                     {
5816                       if (s->left == p)
5817                         s->left = t;
5818                       else
5819                         s->right = t;
5820                     }
5821                   else
5822                     constructor_pending_elts = t;
5823                 }
5824               break;
5825             }
5826           else
5827             {
5828               /* p->balance == +1; growth of left side balances the node.  */
5829               p->balance = 0;
5830               break;
5831             }
5832         }
5833       else /* r == p->right */
5834         {
5835           if (p->balance == 0)
5836             /* Growth propagation from right side.  */
5837             p->balance++;
5838           else if (p->balance > 0)
5839             {
5840               if (r->balance > 0)
5841                 {
5842                   /* R rotation.  */
5843                   p->right = r->left;
5844                   if (p->right)
5845                     p->right->parent = p;
5846                   r->left = p;
5847
5848                   p->balance = 0;
5849                   r->balance = 0;
5850
5851                   s = p->parent;
5852                   p->parent = r;
5853                   r->parent = s;
5854                   if (s)
5855                     {
5856                       if (s->left == p)
5857                         s->left = r;
5858                       else
5859                         s->right = r;
5860                     }
5861                   else
5862                     constructor_pending_elts = r;
5863                 }
5864               else /* r->balance == -1 */
5865                 {
5866                   /* RL rotation */
5867                   struct init_node *t = r->left;
5868
5869                   r->left = t->right;
5870                   if (r->left)
5871                     r->left->parent = r;
5872                   t->right = r;
5873
5874                   p->right = t->left;
5875                   if (p->right)
5876                     p->right->parent = p;
5877                   t->left = p;
5878
5879                   r->balance = (t->balance < 0);
5880                   p->balance = -(t->balance > 0);
5881                   t->balance = 0;
5882
5883                   s = p->parent;
5884                   p->parent = t;
5885                   r->parent = t;
5886                   t->parent = s;
5887                   if (s)
5888                     {
5889                       if (s->left == p)
5890                         s->left = t;
5891                       else
5892                         s->right = t;
5893                     }
5894                   else
5895                     constructor_pending_elts = t;
5896                 }
5897               break;
5898             }
5899           else
5900             {
5901               /* p->balance == -1; growth of right side balances the node.  */
5902               p->balance = 0;
5903               break;
5904             }
5905         }
5906
5907       r = p;
5908       p = p->parent;
5909     }
5910 }
5911
5912 /* Build AVL tree from a sorted chain.  */
5913
5914 static void
5915 set_nonincremental_init (void)
5916 {
5917   unsigned HOST_WIDE_INT ix;
5918   tree index, value;
5919
5920   if (TREE_CODE (constructor_type) != RECORD_TYPE
5921       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5922     return;
5923
5924   FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
5925     add_pending_init (index, value);
5926   constructor_elements = 0;
5927   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5928     {
5929       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5930       /* Skip any nameless bit fields at the beginning.  */
5931       while (constructor_unfilled_fields != 0
5932              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5933              && DECL_NAME (constructor_unfilled_fields) == 0)
5934         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5935
5936     }
5937   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5938     {
5939       if (TYPE_DOMAIN (constructor_type))
5940         constructor_unfilled_index
5941             = convert (bitsizetype,
5942                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5943       else
5944         constructor_unfilled_index = bitsize_zero_node;
5945     }
5946   constructor_incremental = 0;
5947 }
5948
5949 /* Build AVL tree from a string constant.  */
5950
5951 static void
5952 set_nonincremental_init_from_string (tree str)
5953 {
5954   tree value, purpose, type;
5955   HOST_WIDE_INT val[2];
5956   const char *p, *end;
5957   int byte, wchar_bytes, charwidth, bitpos;
5958
5959   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
5960
5961   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5962       == TYPE_PRECISION (char_type_node))
5963     wchar_bytes = 1;
5964   else
5965     {
5966       gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5967                   == TYPE_PRECISION (wchar_type_node));
5968       wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5969     }
5970   charwidth = TYPE_PRECISION (char_type_node);
5971   type = TREE_TYPE (constructor_type);
5972   p = TREE_STRING_POINTER (str);
5973   end = p + TREE_STRING_LENGTH (str);
5974
5975   for (purpose = bitsize_zero_node;
5976        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5977        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5978     {
5979       if (wchar_bytes == 1)
5980         {
5981           val[1] = (unsigned char) *p++;
5982           val[0] = 0;
5983         }
5984       else
5985         {
5986           val[0] = 0;
5987           val[1] = 0;
5988           for (byte = 0; byte < wchar_bytes; byte++)
5989             {
5990               if (BYTES_BIG_ENDIAN)
5991                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5992               else
5993                 bitpos = byte * charwidth;
5994               val[bitpos < HOST_BITS_PER_WIDE_INT]
5995                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5996                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5997             }
5998         }
5999
6000       if (!TYPE_UNSIGNED (type))
6001         {
6002           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6003           if (bitpos < HOST_BITS_PER_WIDE_INT)
6004             {
6005               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6006                 {
6007                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6008                   val[0] = -1;
6009                 }
6010             }
6011           else if (bitpos == HOST_BITS_PER_WIDE_INT)
6012             {
6013               if (val[1] < 0)
6014                 val[0] = -1;
6015             }
6016           else if (val[0] & (((HOST_WIDE_INT) 1)
6017                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6018             val[0] |= ((HOST_WIDE_INT) -1)
6019                       << (bitpos - HOST_BITS_PER_WIDE_INT);
6020         }
6021
6022       value = build_int_cst_wide (type, val[1], val[0]);
6023       add_pending_init (purpose, value);
6024     }
6025
6026   constructor_incremental = 0;
6027 }
6028
6029 /* Return value of FIELD in pending initializer or zero if the field was
6030    not initialized yet.  */
6031
6032 static tree
6033 find_init_member (tree field)
6034 {
6035   struct init_node *p;
6036
6037   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6038     {
6039       if (constructor_incremental
6040           && tree_int_cst_lt (field, constructor_unfilled_index))
6041         set_nonincremental_init ();
6042
6043       p = constructor_pending_elts;
6044       while (p)
6045         {
6046           if (tree_int_cst_lt (field, p->purpose))
6047             p = p->left;
6048           else if (tree_int_cst_lt (p->purpose, field))
6049             p = p->right;
6050           else
6051             return p->value;
6052         }
6053     }
6054   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6055     {
6056       tree bitpos = bit_position (field);
6057
6058       if (constructor_incremental
6059           && (!constructor_unfilled_fields
6060               || tree_int_cst_lt (bitpos,
6061                                   bit_position (constructor_unfilled_fields))))
6062         set_nonincremental_init ();
6063
6064       p = constructor_pending_elts;
6065       while (p)
6066         {
6067           if (field == p->purpose)
6068             return p->value;
6069           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6070             p = p->left;
6071           else
6072             p = p->right;
6073         }
6074     }
6075   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6076     {
6077       if (!VEC_empty (constructor_elt, constructor_elements)
6078           && (VEC_last (constructor_elt, constructor_elements)->index
6079               == field))
6080         return VEC_last (constructor_elt, constructor_elements)->value;
6081     }
6082   return 0;
6083 }
6084
6085 /* "Output" the next constructor element.
6086    At top level, really output it to assembler code now.
6087    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6088    TYPE is the data type that the containing data type wants here.
6089    FIELD is the field (a FIELD_DECL) or the index that this element fills.
6090    If VALUE is a string constant, STRICT_STRING is true if it is
6091    unparenthesized or we should not warn here for it being parenthesized.
6092    For other types of VALUE, STRICT_STRING is not used.
6093
6094    PENDING if non-nil means output pending elements that belong
6095    right after this element.  (PENDING is normally 1;
6096    it is 0 while outputting pending elements, to avoid recursion.)  */
6097
6098 static void
6099 output_init_element (tree value, bool strict_string, tree type, tree field,
6100                      int pending)
6101 {
6102   constructor_elt *celt;
6103
6104   if (type == error_mark_node || value == error_mark_node)
6105     {
6106       constructor_erroneous = 1;
6107       return;
6108     }
6109   if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6110       && (TREE_CODE (value) == STRING_CST
6111           || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
6112       && !(TREE_CODE (value) == STRING_CST
6113            && TREE_CODE (type) == ARRAY_TYPE
6114            && INTEGRAL_TYPE_P (TREE_TYPE (type)))
6115       && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6116                      TYPE_MAIN_VARIANT (type)))
6117     value = array_to_pointer_conversion (value);
6118
6119   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
6120       && require_constant_value && !flag_isoc99 && pending)
6121     {
6122       /* As an extension, allow initializing objects with static storage
6123          duration with compound literals (which are then treated just as
6124          the brace enclosed list they contain).  */
6125       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
6126       value = DECL_INITIAL (decl);
6127     }
6128
6129   if (value == error_mark_node)
6130     constructor_erroneous = 1;
6131   else if (!TREE_CONSTANT (value))
6132     constructor_constant = 0;
6133   else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
6134            || ((TREE_CODE (constructor_type) == RECORD_TYPE
6135                 || TREE_CODE (constructor_type) == UNION_TYPE)
6136                && DECL_C_BIT_FIELD (field)
6137                && TREE_CODE (value) != INTEGER_CST))
6138     constructor_simple = 0;
6139
6140   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
6141     {
6142       if (require_constant_value)
6143         {
6144           error_init ("initializer element is not constant");
6145           value = error_mark_node;
6146         }
6147       else if (require_constant_elements)
6148         pedwarn ("initializer element is not computable at load time");
6149     }
6150
6151   /* If this field is empty (and not at the end of structure),
6152      don't do anything other than checking the initializer.  */
6153   if (field
6154       && (TREE_TYPE (field) == error_mark_node
6155           || (COMPLETE_TYPE_P (TREE_TYPE (field))
6156               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
6157               && (TREE_CODE (constructor_type) == ARRAY_TYPE
6158                   || TREE_CHAIN (field)))))
6159     return;
6160
6161   value = digest_init (type, value, strict_string, require_constant_value);
6162   if (value == error_mark_node)
6163     {
6164       constructor_erroneous = 1;
6165       return;
6166     }
6167
6168   /* If this element doesn't come next in sequence,
6169      put it on constructor_pending_elts.  */
6170   if (TREE_CODE (constructor_type) == ARRAY_TYPE
6171       && (!constructor_incremental
6172           || !tree_int_cst_equal (field, constructor_unfilled_index)))
6173     {
6174       if (constructor_incremental
6175           && tree_int_cst_lt (field, constructor_unfilled_index))
6176         set_nonincremental_init ();
6177
6178       add_pending_init (field, value);
6179       return;
6180     }
6181   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6182            && (!constructor_incremental
6183                || field != constructor_unfilled_fields))
6184     {
6185       /* We do this for records but not for unions.  In a union,
6186          no matter which field is specified, it can be initialized
6187          right away since it starts at the beginning of the union.  */
6188       if (constructor_incremental)
6189         {
6190           if (!constructor_unfilled_fields)
6191             set_nonincremental_init ();
6192           else
6193             {
6194               tree bitpos, unfillpos;
6195
6196               bitpos = bit_position (field);
6197               unfillpos = bit_position (constructor_unfilled_fields);
6198
6199               if (tree_int_cst_lt (bitpos, unfillpos))
6200                 set_nonincremental_init ();
6201             }
6202         }
6203
6204       add_pending_init (field, value);
6205       return;
6206     }
6207   else if (TREE_CODE (constructor_type) == UNION_TYPE
6208            && !VEC_empty (constructor_elt, constructor_elements))
6209     {
6210       if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
6211                                        constructor_elements)->value))
6212         warning_init ("initialized field with side-effects overwritten");
6213
6214       /* We can have just one union field set.  */
6215       constructor_elements = 0;
6216     }
6217
6218   /* Otherwise, output this element either to
6219      constructor_elements or to the assembler file.  */
6220
6221   celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
6222   celt->index = field;
6223   celt->value = value;
6224
6225   /* Advance the variable that indicates sequential elements output.  */
6226   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6227     constructor_unfilled_index
6228       = size_binop (PLUS_EXPR, constructor_unfilled_index,
6229                     bitsize_one_node);
6230   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6231     {
6232       constructor_unfilled_fields
6233         = TREE_CHAIN (constructor_unfilled_fields);
6234
6235       /* Skip any nameless bit fields.  */
6236       while (constructor_unfilled_fields != 0
6237              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6238              && DECL_NAME (constructor_unfilled_fields) == 0)
6239         constructor_unfilled_fields =
6240           TREE_CHAIN (constructor_unfilled_fields);
6241     }
6242   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6243     constructor_unfilled_fields = 0;
6244
6245   /* Now output any pending elements which have become next.  */
6246   if (pending)
6247     output_pending_init_elements (0);
6248 }
6249
6250 /* Output any pending elements which have become next.
6251    As we output elements, constructor_unfilled_{fields,index}
6252    advances, which may cause other elements to become next;
6253    if so, they too are output.
6254
6255    If ALL is 0, we return when there are
6256    no more pending elements to output now.
6257
6258    If ALL is 1, we output space as necessary so that
6259    we can output all the pending elements.  */
6260
6261 static void
6262 output_pending_init_elements (int all)
6263 {
6264   struct init_node *elt = constructor_pending_elts;
6265   tree next;
6266
6267  retry:
6268
6269   /* Look through the whole pending tree.
6270      If we find an element that should be output now,
6271      output it.  Otherwise, set NEXT to the element
6272      that comes first among those still pending.  */
6273
6274   next = 0;
6275   while (elt)
6276     {
6277       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6278         {
6279           if (tree_int_cst_equal (elt->purpose,
6280                                   constructor_unfilled_index))
6281             output_init_element (elt->value, true,
6282                                  TREE_TYPE (constructor_type),
6283                                  constructor_unfilled_index, 0);
6284           else if (tree_int_cst_lt (constructor_unfilled_index,
6285                                     elt->purpose))
6286             {
6287               /* Advance to the next smaller node.  */
6288               if (elt->left)
6289                 elt = elt->left;
6290               else
6291                 {
6292                   /* We have reached the smallest node bigger than the
6293                      current unfilled index.  Fill the space first.  */
6294                   next = elt->purpose;
6295                   break;
6296                 }
6297             }
6298           else
6299             {
6300               /* Advance to the next bigger node.  */
6301               if (elt->right)
6302                 elt = elt->right;
6303               else
6304                 {
6305                   /* We have reached the biggest node in a subtree.  Find
6306                      the parent of it, which is the next bigger node.  */
6307                   while (elt->parent && elt->parent->right == elt)
6308                     elt = elt->parent;
6309                   elt = elt->parent;
6310                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
6311                                               elt->purpose))
6312                     {
6313                       next = elt->purpose;
6314                       break;
6315                     }
6316                 }
6317             }
6318         }
6319       else if (TREE_CODE (constructor_type) == RECORD_TYPE
6320                || TREE_CODE (constructor_type) == UNION_TYPE)
6321         {
6322           tree ctor_unfilled_bitpos, elt_bitpos;
6323
6324           /* If the current record is complete we are done.  */
6325           if (constructor_unfilled_fields == 0)
6326             break;
6327
6328           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
6329           elt_bitpos = bit_position (elt->purpose);
6330           /* We can't compare fields here because there might be empty
6331              fields in between.  */
6332           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6333             {
6334               constructor_unfilled_fields = elt->purpose;
6335               output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
6336                                    elt->purpose, 0);
6337             }
6338           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6339             {
6340               /* Advance to the next smaller node.  */
6341               if (elt->left)
6342                 elt = elt->left;
6343               else
6344                 {
6345                   /* We have reached the smallest node bigger than the
6346                      current unfilled field.  Fill the space first.  */
6347                   next = elt->purpose;
6348                   break;
6349                 }
6350             }
6351           else
6352             {
6353               /* Advance to the next bigger node.  */
6354               if (elt->right)
6355                 elt = elt->right;
6356               else
6357                 {
6358                   /* We have reached the biggest node in a subtree.  Find
6359                      the parent of it, which is the next bigger node.  */
6360                   while (elt->parent && elt->parent->right == elt)
6361                     elt = elt->parent;
6362                   elt = elt->parent;
6363                   if (elt
6364                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
6365                                            bit_position (elt->purpose))))
6366                     {
6367                       next = elt->purpose;
6368                       break;
6369                     }
6370                 }
6371             }
6372         }
6373     }
6374
6375   /* Ordinarily return, but not if we want to output all
6376      and there are elements left.  */
6377   if (!(all && next != 0))
6378     return;
6379
6380   /* If it's not incremental, just skip over the gap, so that after
6381      jumping to retry we will output the next successive element.  */
6382   if (TREE_CODE (constructor_type) == RECORD_TYPE
6383       || TREE_CODE (constructor_type) == UNION_TYPE)
6384     constructor_unfilled_fields = next;
6385   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6386     constructor_unfilled_index = next;
6387
6388   /* ELT now points to the node in the pending tree with the next
6389      initializer to output.  */
6390   goto retry;
6391 }
6392 \f
6393 /* Add one non-braced element to the current constructor level.
6394    This adjusts the current position within the constructor's type.
6395    This may also start or terminate implicit levels
6396    to handle a partly-braced initializer.
6397
6398    Once this has found the correct level for the new element,
6399    it calls output_init_element.  */
6400
6401 void
6402 process_init_element (struct c_expr value)
6403 {
6404   tree orig_value = value.value;
6405   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
6406   bool strict_string = value.original_code == STRING_CST;
6407
6408   designator_depth = 0;
6409   designator_erroneous = 0;
6410
6411   /* Handle superfluous braces around string cst as in
6412      char x[] = {"foo"}; */
6413   if (string_flag
6414       && constructor_type
6415       && TREE_CODE (constructor_type) == ARRAY_TYPE
6416       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
6417       && integer_zerop (constructor_unfilled_index))
6418     {
6419       if (constructor_stack->replacement_value.value)
6420         error_init ("excess elements in char array initializer");
6421       constructor_stack->replacement_value = value;
6422       return;
6423     }
6424
6425   if (constructor_stack->replacement_value.value != 0)
6426     {
6427       error_init ("excess elements in struct initializer");
6428       return;
6429     }
6430
6431   /* Ignore elements of a brace group if it is entirely superfluous
6432      and has already been diagnosed.  */
6433   if (constructor_type == 0)
6434     return;
6435
6436   /* If we've exhausted any levels that didn't have braces,
6437      pop them now.  */
6438   while (constructor_stack->implicit)
6439     {
6440       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6441            || TREE_CODE (constructor_type) == UNION_TYPE)
6442           && constructor_fields == 0)
6443         process_init_element (pop_init_level (1));
6444       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6445                && (constructor_max_index == 0
6446                    || tree_int_cst_lt (constructor_max_index,
6447                                        constructor_index)))
6448         process_init_element (pop_init_level (1));
6449       else
6450         break;
6451     }
6452
6453   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6454   if (constructor_range_stack)
6455     {
6456       /* If value is a compound literal and we'll be just using its
6457          content, don't put it into a SAVE_EXPR.  */
6458       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
6459           || !require_constant_value
6460           || flag_isoc99)
6461         value.value = save_expr (value.value);
6462     }
6463
6464   while (1)
6465     {
6466       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6467         {
6468           tree fieldtype;
6469           enum tree_code fieldcode;
6470
6471           if (constructor_fields == 0)
6472             {
6473               pedwarn_init ("excess elements in struct initializer");
6474               break;
6475             }
6476
6477           fieldtype = TREE_TYPE (constructor_fields);
6478           if (fieldtype != error_mark_node)
6479             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6480           fieldcode = TREE_CODE (fieldtype);
6481
6482           /* Error for non-static initialization of a flexible array member.  */
6483           if (fieldcode == ARRAY_TYPE
6484               && !require_constant_value
6485               && TYPE_SIZE (fieldtype) == NULL_TREE
6486               && TREE_CHAIN (constructor_fields) == NULL_TREE)
6487             {
6488               error_init ("non-static initialization of a flexible array member");
6489               break;
6490             }
6491
6492           /* Accept a string constant to initialize a subarray.  */
6493           if (value.value != 0
6494               && fieldcode == ARRAY_TYPE
6495               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6496               && string_flag)
6497             value.value = orig_value;
6498           /* Otherwise, if we have come to a subaggregate,
6499              and we don't have an element of its type, push into it.  */
6500           else if (value.value != 0
6501                    && value.value != error_mark_node
6502                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6503                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6504                        || fieldcode == UNION_TYPE))
6505             {
6506               push_init_level (1);
6507               continue;
6508             }
6509
6510           if (value.value)
6511             {
6512               push_member_name (constructor_fields);
6513               output_init_element (value.value, strict_string,
6514                                    fieldtype, constructor_fields, 1);
6515               RESTORE_SPELLING_DEPTH (constructor_depth);
6516             }
6517           else
6518             /* Do the bookkeeping for an element that was
6519                directly output as a constructor.  */
6520             {
6521               /* For a record, keep track of end position of last field.  */
6522               if (DECL_SIZE (constructor_fields))
6523                 constructor_bit_index
6524                   = size_binop (PLUS_EXPR,
6525                                 bit_position (constructor_fields),
6526                                 DECL_SIZE (constructor_fields));
6527
6528               /* If the current field was the first one not yet written out,
6529                  it isn't now, so update.  */
6530               if (constructor_unfilled_fields == constructor_fields)
6531                 {
6532                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6533                   /* Skip any nameless bit fields.  */
6534                   while (constructor_unfilled_fields != 0
6535                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6536                          && DECL_NAME (constructor_unfilled_fields) == 0)
6537                     constructor_unfilled_fields =
6538                       TREE_CHAIN (constructor_unfilled_fields);
6539                 }
6540             }
6541
6542           constructor_fields = TREE_CHAIN (constructor_fields);
6543           /* Skip any nameless bit fields at the beginning.  */
6544           while (constructor_fields != 0
6545                  && DECL_C_BIT_FIELD (constructor_fields)
6546                  && DECL_NAME (constructor_fields) == 0)
6547             constructor_fields = TREE_CHAIN (constructor_fields);
6548         }
6549       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6550         {
6551           tree fieldtype;
6552           enum tree_code fieldcode;
6553
6554           if (constructor_fields == 0)
6555             {
6556               pedwarn_init ("excess elements in union initializer");
6557               break;
6558             }
6559
6560           fieldtype = TREE_TYPE (constructor_fields);
6561           if (fieldtype != error_mark_node)
6562             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6563           fieldcode = TREE_CODE (fieldtype);
6564
6565           /* Warn that traditional C rejects initialization of unions.
6566              We skip the warning if the value is zero.  This is done
6567              under the assumption that the zero initializer in user
6568              code appears conditioned on e.g. __STDC__ to avoid
6569              "missing initializer" warnings and relies on default
6570              initialization to zero in the traditional C case.
6571              We also skip the warning if the initializer is designated,
6572              again on the assumption that this must be conditional on
6573              __STDC__ anyway (and we've already complained about the
6574              member-designator already).  */
6575           if (!in_system_header && !constructor_designated
6576               && !(value.value && (integer_zerop (value.value)
6577                                    || real_zerop (value.value))))
6578             warning (OPT_Wtraditional, "traditional C rejects initialization "
6579                      "of unions");
6580
6581           /* Accept a string constant to initialize a subarray.  */
6582           if (value.value != 0
6583               && fieldcode == ARRAY_TYPE
6584               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6585               && string_flag)
6586             value.value = orig_value;
6587           /* Otherwise, if we have come to a subaggregate,
6588              and we don't have an element of its type, push into it.  */
6589           else if (value.value != 0
6590                    && value.value != error_mark_node
6591                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6592                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6593                        || fieldcode == UNION_TYPE))
6594             {
6595               push_init_level (1);
6596               continue;
6597             }
6598
6599           if (value.value)
6600             {
6601               push_member_name (constructor_fields);
6602               output_init_element (value.value, strict_string,
6603                                    fieldtype, constructor_fields, 1);
6604               RESTORE_SPELLING_DEPTH (constructor_depth);
6605             }
6606           else
6607             /* Do the bookkeeping for an element that was
6608                directly output as a constructor.  */
6609             {
6610               constructor_bit_index = DECL_SIZE (constructor_fields);
6611               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6612             }
6613
6614           constructor_fields = 0;
6615         }
6616       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6617         {
6618           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6619           enum tree_code eltcode = TREE_CODE (elttype);
6620
6621           /* Accept a string constant to initialize a subarray.  */
6622           if (value.value != 0
6623               && eltcode == ARRAY_TYPE
6624               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
6625               && string_flag)
6626             value.value = orig_value;
6627           /* Otherwise, if we have come to a subaggregate,
6628              and we don't have an element of its type, push into it.  */
6629           else if (value.value != 0
6630                    && value.value != error_mark_node
6631                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
6632                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6633                        || eltcode == UNION_TYPE))
6634             {
6635               push_init_level (1);
6636               continue;
6637             }
6638
6639           if (constructor_max_index != 0
6640               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6641                   || integer_all_onesp (constructor_max_index)))
6642             {
6643               pedwarn_init ("excess elements in array initializer");
6644               break;
6645             }
6646
6647           /* Now output the actual element.  */
6648           if (value.value)
6649             {
6650               push_array_bounds (tree_low_cst (constructor_index, 1));
6651               output_init_element (value.value, strict_string,
6652                                    elttype, constructor_index, 1);
6653               RESTORE_SPELLING_DEPTH (constructor_depth);
6654             }
6655
6656           constructor_index
6657             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6658
6659           if (!value.value)
6660             /* If we are doing the bookkeeping for an element that was
6661                directly output as a constructor, we must update
6662                constructor_unfilled_index.  */
6663             constructor_unfilled_index = constructor_index;
6664         }
6665       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6666         {
6667           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6668
6669          /* Do a basic check of initializer size.  Note that vectors
6670             always have a fixed size derived from their type.  */
6671           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6672             {
6673               pedwarn_init ("excess elements in vector initializer");
6674               break;
6675             }
6676
6677           /* Now output the actual element.  */
6678           if (value.value)
6679             output_init_element (value.value, strict_string,
6680                                  elttype, constructor_index, 1);
6681
6682           constructor_index
6683             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6684
6685           if (!value.value)
6686             /* If we are doing the bookkeeping for an element that was
6687                directly output as a constructor, we must update
6688                constructor_unfilled_index.  */
6689             constructor_unfilled_index = constructor_index;
6690         }
6691
6692       /* Handle the sole element allowed in a braced initializer
6693          for a scalar variable.  */
6694       else if (constructor_type != error_mark_node
6695                && constructor_fields == 0)
6696         {
6697           pedwarn_init ("excess elements in scalar initializer");
6698           break;
6699         }
6700       else
6701         {
6702           if (value.value)
6703             output_init_element (value.value, strict_string,
6704                                  constructor_type, NULL_TREE, 1);
6705           constructor_fields = 0;
6706         }
6707
6708       /* Handle range initializers either at this level or anywhere higher
6709          in the designator stack.  */
6710       if (constructor_range_stack)
6711         {
6712           struct constructor_range_stack *p, *range_stack;
6713           int finish = 0;
6714
6715           range_stack = constructor_range_stack;
6716           constructor_range_stack = 0;
6717           while (constructor_stack != range_stack->stack)
6718             {
6719               gcc_assert (constructor_stack->implicit);
6720               process_init_element (pop_init_level (1));
6721             }
6722           for (p = range_stack;
6723                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6724                p = p->prev)
6725             {
6726               gcc_assert (constructor_stack->implicit);
6727               process_init_element (pop_init_level (1));
6728             }
6729
6730           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6731           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6732             finish = 1;
6733
6734           while (1)
6735             {
6736               constructor_index = p->index;
6737               constructor_fields = p->fields;
6738               if (finish && p->range_end && p->index == p->range_start)
6739                 {
6740                   finish = 0;
6741                   p->prev = 0;
6742                 }
6743               p = p->next;
6744               if (!p)
6745                 break;
6746               push_init_level (2);
6747               p->stack = constructor_stack;
6748               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6749                 p->index = p->range_start;
6750             }
6751
6752           if (!finish)
6753             constructor_range_stack = range_stack;
6754           continue;
6755         }
6756
6757       break;
6758     }
6759
6760   constructor_range_stack = 0;
6761 }
6762 \f
6763 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6764    (guaranteed to be 'volatile' or null) and ARGS (represented using
6765    an ASM_EXPR node).  */
6766 tree
6767 build_asm_stmt (tree cv_qualifier, tree args)
6768 {
6769   if (!ASM_VOLATILE_P (args) && cv_qualifier)
6770     ASM_VOLATILE_P (args) = 1;
6771   return add_stmt (args);
6772 }
6773
6774 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6775    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6776    SIMPLE indicates whether there was anything at all after the
6777    string in the asm expression -- asm("blah") and asm("blah" : )
6778    are subtly different.  We use a ASM_EXPR node to represent this.  */
6779 tree
6780 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6781                 bool simple)
6782 {
6783   tree tail;
6784   tree args;
6785   int i;
6786   const char *constraint;
6787   const char **oconstraints;
6788   bool allows_mem, allows_reg, is_inout;
6789   int ninputs, noutputs;
6790
6791   ninputs = list_length (inputs);
6792   noutputs = list_length (outputs);
6793   oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
6794
6795   string = resolve_asm_operand_names (string, outputs, inputs);
6796
6797   /* Remove output conversions that change the type but not the mode.  */
6798   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6799     {
6800       tree output = TREE_VALUE (tail);
6801
6802       /* ??? Really, this should not be here.  Users should be using a
6803          proper lvalue, dammit.  But there's a long history of using casts
6804          in the output operands.  In cases like longlong.h, this becomes a
6805          primitive form of typechecking -- if the cast can be removed, then
6806          the output operand had a type of the proper width; otherwise we'll
6807          get an error.  Gross, but ...  */
6808       STRIP_NOPS (output);
6809
6810       if (!lvalue_or_else (output, lv_asm))
6811         output = error_mark_node;
6812
6813       if (output != error_mark_node
6814           && (TREE_READONLY (output)
6815               || TYPE_READONLY (TREE_TYPE (output))
6816               || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
6817                    || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
6818                   && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
6819         readonly_error (output, lv_asm);
6820
6821       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6822       oconstraints[i] = constraint;
6823
6824       if (parse_output_constraint (&constraint, i, ninputs, noutputs,
6825                                    &allows_mem, &allows_reg, &is_inout))
6826         {
6827           /* If the operand is going to end up in memory,
6828              mark it addressable.  */
6829           if (!allows_reg && !c_mark_addressable (output))
6830             output = error_mark_node;
6831         }
6832       else
6833         output = error_mark_node;
6834
6835       TREE_VALUE (tail) = output;
6836     }
6837
6838   for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
6839     {
6840       tree input;
6841
6842       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6843       input = TREE_VALUE (tail);
6844
6845       if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
6846                                   oconstraints, &allows_mem, &allows_reg))
6847         {
6848           /* If the operand is going to end up in memory,
6849              mark it addressable.  */
6850           if (!allows_reg && allows_mem)
6851             {
6852               /* Strip the nops as we allow this case.  FIXME, this really
6853                  should be rejected or made deprecated.  */
6854               STRIP_NOPS (input);
6855               if (!c_mark_addressable (input))
6856                 input = error_mark_node;
6857           }
6858         }
6859       else
6860         input = error_mark_node;
6861
6862       TREE_VALUE (tail) = input;
6863     }
6864
6865   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6866
6867   /* asm statements without outputs, including simple ones, are treated
6868      as volatile.  */
6869   ASM_INPUT_P (args) = simple;
6870   ASM_VOLATILE_P (args) = (noutputs == 0);
6871
6872   return args;
6873 }
6874 \f
6875 /* Generate a goto statement to LABEL.  */
6876
6877 tree
6878 c_finish_goto_label (tree label)
6879 {
6880   tree decl = lookup_label (label);
6881   if (!decl)
6882     return NULL_TREE;
6883
6884   if (C_DECL_UNJUMPABLE_STMT_EXPR (decl))
6885     {
6886       error ("jump into statement expression");
6887       return NULL_TREE;
6888     }
6889
6890   if (C_DECL_UNJUMPABLE_VM (decl))
6891     {
6892       error ("jump into scope of identifier with variably modified type");
6893       return NULL_TREE;
6894     }
6895
6896   if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl))
6897     {
6898       /* No jump from outside this statement expression context, so
6899          record that there is a jump from within this context.  */
6900       struct c_label_list *nlist;
6901       nlist = XOBNEW (&parser_obstack, struct c_label_list);
6902       nlist->next = label_context_stack_se->labels_used;
6903       nlist->label = decl;
6904       label_context_stack_se->labels_used = nlist;
6905     }
6906
6907   if (!C_DECL_UNDEFINABLE_VM (decl))
6908     {
6909       /* No jump from outside this context context of identifiers with
6910          variably modified type, so record that there is a jump from
6911          within this context.  */
6912       struct c_label_list *nlist;
6913       nlist = XOBNEW (&parser_obstack, struct c_label_list);
6914       nlist->next = label_context_stack_vm->labels_used;
6915       nlist->label = decl;
6916       label_context_stack_vm->labels_used = nlist;
6917     }
6918
6919   TREE_USED (decl) = 1;
6920   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6921 }
6922
6923 /* Generate a computed goto statement to EXPR.  */
6924
6925 tree
6926 c_finish_goto_ptr (tree expr)
6927 {
6928   if (pedantic)
6929     pedwarn ("ISO C forbids %<goto *expr;%>");
6930   expr = convert (ptr_type_node, expr);
6931   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6932 }
6933
6934 /* Generate a C `return' statement.  RETVAL is the expression for what
6935    to return, or a null pointer for `return;' with no value.  */
6936
6937 tree
6938 c_finish_return (tree retval)
6939 {
6940   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
6941   bool no_warning = false;
6942
6943   if (TREE_THIS_VOLATILE (current_function_decl))
6944     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6945
6946   if (!retval)
6947     {
6948       current_function_returns_null = 1;
6949       if ((warn_return_type || flag_isoc99)
6950           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6951         {
6952           pedwarn_c99 ("%<return%> with no value, in "
6953                        "function returning non-void");
6954           no_warning = true;
6955         }
6956     }
6957   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6958     {
6959       current_function_returns_null = 1;
6960       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6961         pedwarn ("%<return%> with a value, in function returning void");
6962     }
6963   else
6964     {
6965       tree t = convert_for_assignment (valtype, retval, ic_return,
6966                                        NULL_TREE, NULL_TREE, 0);
6967       tree res = DECL_RESULT (current_function_decl);
6968       tree inner;
6969
6970       current_function_returns_value = 1;
6971       if (t == error_mark_node)
6972         return NULL_TREE;
6973
6974       inner = t = convert (TREE_TYPE (res), t);
6975
6976       /* Strip any conversions, additions, and subtractions, and see if
6977          we are returning the address of a local variable.  Warn if so.  */
6978       while (1)
6979         {
6980           switch (TREE_CODE (inner))
6981             {
6982             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6983             case PLUS_EXPR:
6984               inner = TREE_OPERAND (inner, 0);
6985               continue;
6986
6987             case MINUS_EXPR:
6988               /* If the second operand of the MINUS_EXPR has a pointer
6989                  type (or is converted from it), this may be valid, so
6990                  don't give a warning.  */
6991               {
6992                 tree op1 = TREE_OPERAND (inner, 1);
6993
6994                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
6995                        && (TREE_CODE (op1) == NOP_EXPR
6996                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6997                            || TREE_CODE (op1) == CONVERT_EXPR))
6998                   op1 = TREE_OPERAND (op1, 0);
6999
7000                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7001                   break;
7002
7003                 inner = TREE_OPERAND (inner, 0);
7004                 continue;
7005               }
7006
7007             case ADDR_EXPR:
7008               inner = TREE_OPERAND (inner, 0);
7009
7010               while (REFERENCE_CLASS_P (inner)
7011                      && TREE_CODE (inner) != INDIRECT_REF)
7012                 inner = TREE_OPERAND (inner, 0);
7013
7014               if (DECL_P (inner)
7015                   && !DECL_EXTERNAL (inner)
7016                   && !TREE_STATIC (inner)
7017                   && DECL_CONTEXT (inner) == current_function_decl)
7018                 warning (0, "function returns address of local variable");
7019               break;
7020
7021             default:
7022               break;
7023             }
7024
7025           break;
7026         }
7027
7028       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
7029     }
7030
7031   ret_stmt = build_stmt (RETURN_EXPR, retval);
7032   TREE_NO_WARNING (ret_stmt) |= no_warning;
7033   return add_stmt (ret_stmt);
7034 }
7035 \f
7036 struct c_switch {
7037   /* The SWITCH_EXPR being built.  */
7038   tree switch_expr;
7039
7040   /* The original type of the testing expression, i.e. before the
7041      default conversion is applied.  */
7042   tree orig_type;
7043
7044   /* A splay-tree mapping the low element of a case range to the high
7045      element, or NULL_TREE if there is no high element.  Used to
7046      determine whether or not a new case label duplicates an old case
7047      label.  We need a tree, rather than simply a hash table, because
7048      of the GNU case range extension.  */
7049   splay_tree cases;
7050
7051   /* Number of nested statement expressions within this switch
7052      statement; if nonzero, case and default labels may not
7053      appear.  */
7054   unsigned int blocked_stmt_expr;
7055
7056   /* Scope of outermost declarations of identifiers with variably
7057      modified type within this switch statement; if nonzero, case and
7058      default labels may not appear.  */
7059   unsigned int blocked_vm;
7060
7061   /* The next node on the stack.  */
7062   struct c_switch *next;
7063 };
7064
7065 /* A stack of the currently active switch statements.  The innermost
7066    switch statement is on the top of the stack.  There is no need to
7067    mark the stack for garbage collection because it is only active
7068    during the processing of the body of a function, and we never
7069    collect at that point.  */
7070
7071 struct c_switch *c_switch_stack;
7072
7073 /* Start a C switch statement, testing expression EXP.  Return the new
7074    SWITCH_EXPR.  */
7075
7076 tree
7077 c_start_case (tree exp)
7078 {
7079   tree orig_type = error_mark_node;
7080   struct c_switch *cs;
7081
7082   if (exp != error_mark_node)
7083     {
7084       orig_type = TREE_TYPE (exp);
7085
7086       if (!INTEGRAL_TYPE_P (orig_type))
7087         {
7088           if (orig_type != error_mark_node)
7089             {
7090               error ("switch quantity not an integer");
7091               orig_type = error_mark_node;
7092             }
7093           exp = integer_zero_node;
7094         }
7095       else
7096         {
7097           tree type = TYPE_MAIN_VARIANT (orig_type);
7098
7099           if (!in_system_header
7100               && (type == long_integer_type_node
7101                   || type == long_unsigned_type_node))
7102             warning (OPT_Wtraditional, "%<long%> switch expression not "
7103                      "converted to %<int%> in ISO C");
7104
7105           exp = default_conversion (exp);
7106         }
7107     }
7108
7109   /* Add this new SWITCH_EXPR to the stack.  */
7110   cs = XNEW (struct c_switch);
7111   cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
7112   cs->orig_type = orig_type;
7113   cs->cases = splay_tree_new (case_compare, NULL, NULL);
7114   cs->blocked_stmt_expr = 0;
7115   cs->blocked_vm = 0;
7116   cs->next = c_switch_stack;
7117   c_switch_stack = cs;
7118
7119   return add_stmt (cs->switch_expr);
7120 }
7121
7122 /* Process a case label.  */
7123
7124 tree
7125 do_case (tree low_value, tree high_value)
7126 {
7127   tree label = NULL_TREE;
7128
7129   if (c_switch_stack && !c_switch_stack->blocked_stmt_expr
7130       && !c_switch_stack->blocked_vm)
7131     {
7132       label = c_add_case_label (c_switch_stack->cases,
7133                                 SWITCH_COND (c_switch_stack->switch_expr),
7134                                 c_switch_stack->orig_type,
7135                                 low_value, high_value);
7136       if (label == error_mark_node)
7137         label = NULL_TREE;
7138     }
7139   else if (c_switch_stack && c_switch_stack->blocked_stmt_expr)
7140     {
7141       if (low_value)
7142         error ("case label in statement expression not containing "
7143                "enclosing switch statement");
7144       else
7145         error ("%<default%> label in statement expression not containing "
7146                "enclosing switch statement");
7147     }
7148   else if (c_switch_stack && c_switch_stack->blocked_vm)
7149     {
7150       if (low_value)
7151         error ("case label in scope of identifier with variably modified "
7152                "type not containing enclosing switch statement");
7153       else
7154         error ("%<default%> label in scope of identifier with variably "
7155                "modified type not containing enclosing switch statement");
7156     }
7157   else if (low_value)
7158     error ("case label not within a switch statement");
7159   else
7160     error ("%<default%> label not within a switch statement");
7161
7162   return label;
7163 }
7164
7165 /* Finish the switch statement.  */
7166
7167 void
7168 c_finish_case (tree body)
7169 {
7170   struct c_switch *cs = c_switch_stack;
7171   location_t switch_location;
7172
7173   SWITCH_BODY (cs->switch_expr) = body;
7174
7175   /* We must not be within a statement expression nested in the switch
7176      at this point; we might, however, be within the scope of an
7177      identifier with variably modified type nested in the switch.  */
7178   gcc_assert (!cs->blocked_stmt_expr);
7179
7180   /* Emit warnings as needed.  */
7181   if (EXPR_HAS_LOCATION (cs->switch_expr))
7182     switch_location = EXPR_LOCATION (cs->switch_expr);
7183   else
7184     switch_location = input_location;
7185   c_do_switch_warnings (cs->cases, switch_location,
7186                         TREE_TYPE (cs->switch_expr),
7187                         SWITCH_COND (cs->switch_expr));
7188
7189   /* Pop the stack.  */
7190   c_switch_stack = cs->next;
7191   splay_tree_delete (cs->cases);
7192   XDELETE (cs);
7193 }
7194 \f
7195 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
7196    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
7197    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
7198    statement, and was not surrounded with parenthesis.  */
7199
7200 void
7201 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
7202                   tree else_block, bool nested_if)
7203 {
7204   tree stmt;
7205
7206   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
7207   if (warn_parentheses && nested_if && else_block == NULL)
7208     {
7209       tree inner_if = then_block;
7210
7211       /* We know from the grammar productions that there is an IF nested
7212          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
7213          it might not be exactly THEN_BLOCK, but should be the last
7214          non-container statement within.  */
7215       while (1)
7216         switch (TREE_CODE (inner_if))
7217           {
7218           case COND_EXPR:
7219             goto found;
7220           case BIND_EXPR:
7221             inner_if = BIND_EXPR_BODY (inner_if);
7222             break;
7223           case STATEMENT_LIST:
7224             inner_if = expr_last (then_block);
7225             break;
7226           case TRY_FINALLY_EXPR:
7227           case TRY_CATCH_EXPR:
7228             inner_if = TREE_OPERAND (inner_if, 0);
7229             break;
7230           default:
7231             gcc_unreachable ();
7232           }
7233     found:
7234
7235       if (COND_EXPR_ELSE (inner_if))
7236          warning (OPT_Wparentheses,
7237                   "%Hsuggest explicit braces to avoid ambiguous %<else%>",
7238                   &if_locus);
7239     }
7240
7241   empty_body_warning (then_block, else_block);
7242
7243   stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
7244   SET_EXPR_LOCATION (stmt, if_locus);
7245   add_stmt (stmt);
7246 }
7247
7248 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
7249    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
7250    is false for DO loops.  INCR is the FOR increment expression.  BODY is
7251    the statement controlled by the loop.  BLAB is the break label.  CLAB is
7252    the continue label.  Everything is allowed to be NULL.  */
7253
7254 void
7255 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
7256                tree blab, tree clab, bool cond_is_first)
7257 {
7258   tree entry = NULL, exit = NULL, t;
7259
7260   /* If the condition is zero don't generate a loop construct.  */
7261   if (cond && integer_zerop (cond))
7262     {
7263       if (cond_is_first)
7264         {
7265           t = build_and_jump (&blab);
7266           SET_EXPR_LOCATION (t, start_locus);
7267           add_stmt (t);
7268         }
7269     }
7270   else
7271     {
7272       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
7273
7274       /* If we have an exit condition, then we build an IF with gotos either
7275          out of the loop, or to the top of it.  If there's no exit condition,
7276          then we just build a jump back to the top.  */
7277       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
7278
7279       if (cond && !integer_nonzerop (cond))
7280         {
7281           /* Canonicalize the loop condition to the end.  This means
7282              generating a branch to the loop condition.  Reuse the
7283              continue label, if possible.  */
7284           if (cond_is_first)
7285             {
7286               if (incr || !clab)
7287                 {
7288                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
7289                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
7290                 }
7291               else
7292                 t = build1 (GOTO_EXPR, void_type_node, clab);
7293               SET_EXPR_LOCATION (t, start_locus);
7294               add_stmt (t);
7295             }
7296
7297           t = build_and_jump (&blab);
7298           exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
7299           if (cond_is_first)
7300             SET_EXPR_LOCATION (exit, start_locus);
7301           else
7302             SET_EXPR_LOCATION (exit, input_location);
7303         }
7304
7305       add_stmt (top);
7306     }
7307
7308   if (body)
7309     add_stmt (body);
7310   if (clab)
7311     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
7312   if (incr)
7313     add_stmt (incr);
7314   if (entry)
7315     add_stmt (entry);
7316   if (exit)
7317     add_stmt (exit);
7318   if (blab)
7319     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
7320 }
7321
7322 tree
7323 c_finish_bc_stmt (tree *label_p, bool is_break)
7324 {
7325   bool skip;
7326   tree label = *label_p;
7327
7328   /* In switch statements break is sometimes stylistically used after
7329      a return statement.  This can lead to spurious warnings about
7330      control reaching the end of a non-void function when it is
7331      inlined.  Note that we are calling block_may_fallthru with
7332      language specific tree nodes; this works because
7333      block_may_fallthru returns true when given something it does not
7334      understand.  */
7335   skip = !block_may_fallthru (cur_stmt_list);
7336
7337   if (!label)
7338     {
7339       if (!skip)
7340         *label_p = label = create_artificial_label ();
7341     }
7342   else if (TREE_CODE (label) == LABEL_DECL)
7343     ;
7344   else switch (TREE_INT_CST_LOW (label))
7345     {
7346     case 0:
7347       if (is_break)
7348         error ("break statement not within loop or switch");
7349       else
7350         error ("continue statement not within a loop");
7351       return NULL_TREE;
7352
7353     case 1:
7354       gcc_assert (is_break);
7355       error ("break statement used with OpenMP for loop");
7356       return NULL_TREE;
7357
7358     default:
7359       gcc_unreachable ();
7360     }
7361
7362   if (skip)
7363     return NULL_TREE;
7364
7365   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
7366 }
7367
7368 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
7369
7370 static void
7371 emit_side_effect_warnings (tree expr)
7372 {
7373   if (expr == error_mark_node)
7374     ;
7375   else if (!TREE_SIDE_EFFECTS (expr))
7376     {
7377       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
7378         warning (0, "%Hstatement with no effect",
7379                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
7380     }
7381   else if (warn_unused_value)
7382     warn_if_unused_value (expr, input_location);
7383 }
7384
7385 /* Process an expression as if it were a complete statement.  Emit
7386    diagnostics, but do not call ADD_STMT.  */
7387
7388 tree
7389 c_process_expr_stmt (tree expr)
7390 {
7391   if (!expr)
7392     return NULL_TREE;
7393
7394   if (warn_sequence_point)
7395     verify_sequence_points (expr);
7396
7397   if (TREE_TYPE (expr) != error_mark_node
7398       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
7399       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
7400     error ("expression statement has incomplete type");
7401
7402   /* If we're not processing a statement expression, warn about unused values.
7403      Warnings for statement expressions will be emitted later, once we figure
7404      out which is the result.  */
7405   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
7406       && (extra_warnings || warn_unused_value))
7407     emit_side_effect_warnings (expr);
7408
7409   /* If the expression is not of a type to which we cannot assign a line
7410      number, wrap the thing in a no-op NOP_EXPR.  */
7411   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
7412     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
7413
7414   if (EXPR_P (expr))
7415     SET_EXPR_LOCATION (expr, input_location);
7416
7417   return expr;
7418 }
7419
7420 /* Emit an expression as a statement.  */
7421
7422 tree
7423 c_finish_expr_stmt (tree expr)
7424 {
7425   if (expr)
7426     return add_stmt (c_process_expr_stmt (expr));
7427   else
7428     return NULL;
7429 }
7430
7431 /* Do the opposite and emit a statement as an expression.  To begin,
7432    create a new binding level and return it.  */
7433
7434 tree
7435 c_begin_stmt_expr (void)
7436 {
7437   tree ret;
7438   struct c_label_context_se *nstack;
7439   struct c_label_list *glist;
7440
7441   /* We must force a BLOCK for this level so that, if it is not expanded
7442      later, there is a way to turn off the entire subtree of blocks that
7443      are contained in it.  */
7444   keep_next_level ();
7445   ret = c_begin_compound_stmt (true);
7446   if (c_switch_stack)
7447     {
7448       c_switch_stack->blocked_stmt_expr++;
7449       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
7450     }
7451   for (glist = label_context_stack_se->labels_used;
7452        glist != NULL;
7453        glist = glist->next)
7454     {
7455       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1;
7456     }
7457   nstack = XOBNEW (&parser_obstack, struct c_label_context_se);
7458   nstack->labels_def = NULL;
7459   nstack->labels_used = NULL;
7460   nstack->next = label_context_stack_se;
7461   label_context_stack_se = nstack;
7462
7463   /* Mark the current statement list as belonging to a statement list.  */
7464   STATEMENT_LIST_STMT_EXPR (ret) = 1;
7465
7466   return ret;
7467 }
7468
7469 tree
7470 c_finish_stmt_expr (tree body)
7471 {
7472   tree last, type, tmp, val;
7473   tree *last_p;
7474   struct c_label_list *dlist, *glist, *glist_prev = NULL;
7475
7476   body = c_end_compound_stmt (body, true);
7477   if (c_switch_stack)
7478     {
7479       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
7480       c_switch_stack->blocked_stmt_expr--;
7481     }
7482   /* It is no longer possible to jump to labels defined within this
7483      statement expression.  */
7484   for (dlist = label_context_stack_se->labels_def;
7485        dlist != NULL;
7486        dlist = dlist->next)
7487     {
7488       C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1;
7489     }
7490   /* It is again possible to define labels with a goto just outside
7491      this statement expression.  */
7492   for (glist = label_context_stack_se->next->labels_used;
7493        glist != NULL;
7494        glist = glist->next)
7495     {
7496       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0;
7497       glist_prev = glist;
7498     }
7499   if (glist_prev != NULL)
7500     glist_prev->next = label_context_stack_se->labels_used;
7501   else
7502     label_context_stack_se->next->labels_used
7503       = label_context_stack_se->labels_used;
7504   label_context_stack_se = label_context_stack_se->next;
7505
7506   /* Locate the last statement in BODY.  See c_end_compound_stmt
7507      about always returning a BIND_EXPR.  */
7508   last_p = &BIND_EXPR_BODY (body);
7509   last = BIND_EXPR_BODY (body);
7510
7511  continue_searching:
7512   if (TREE_CODE (last) == STATEMENT_LIST)
7513     {
7514       tree_stmt_iterator i;
7515
7516       /* This can happen with degenerate cases like ({ }).  No value.  */
7517       if (!TREE_SIDE_EFFECTS (last))
7518         return body;
7519
7520       /* If we're supposed to generate side effects warnings, process
7521          all of the statements except the last.  */
7522       if (extra_warnings || warn_unused_value)
7523         {
7524           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
7525             emit_side_effect_warnings (tsi_stmt (i));
7526         }
7527       else
7528         i = tsi_last (last);
7529       last_p = tsi_stmt_ptr (i);
7530       last = *last_p;
7531     }
7532
7533   /* If the end of the list is exception related, then the list was split
7534      by a call to push_cleanup.  Continue searching.  */
7535   if (TREE_CODE (last) == TRY_FINALLY_EXPR
7536       || TREE_CODE (last) == TRY_CATCH_EXPR)
7537     {
7538       last_p = &TREE_OPERAND (last, 0);
7539       last = *last_p;
7540       goto continue_searching;
7541     }
7542
7543   /* In the case that the BIND_EXPR is not necessary, return the
7544      expression out from inside it.  */
7545   if (last == error_mark_node
7546       || (last == BIND_EXPR_BODY (body)
7547           && BIND_EXPR_VARS (body) == NULL))
7548     {
7549       /* Do not warn if the return value of a statement expression is
7550          unused.  */
7551       if (EXPR_P (last))
7552         TREE_NO_WARNING (last) = 1;
7553       return last;
7554     }
7555
7556   /* Extract the type of said expression.  */
7557   type = TREE_TYPE (last);
7558
7559   /* If we're not returning a value at all, then the BIND_EXPR that
7560      we already have is a fine expression to return.  */
7561   if (!type || VOID_TYPE_P (type))
7562     return body;
7563
7564   /* Now that we've located the expression containing the value, it seems
7565      silly to make voidify_wrapper_expr repeat the process.  Create a
7566      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
7567   tmp = create_tmp_var_raw (type, NULL);
7568
7569   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
7570      tree_expr_nonnegative_p giving up immediately.  */
7571   val = last;
7572   if (TREE_CODE (val) == NOP_EXPR
7573       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
7574     val = TREE_OPERAND (val, 0);
7575
7576   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
7577   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
7578
7579   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
7580 }
7581
7582 /* Begin the scope of an identifier of variably modified type, scope
7583    number SCOPE.  Jumping from outside this scope to inside it is not
7584    permitted.  */
7585
7586 void
7587 c_begin_vm_scope (unsigned int scope)
7588 {
7589   struct c_label_context_vm *nstack;
7590   struct c_label_list *glist;
7591
7592   gcc_assert (scope > 0);
7593
7594   /* At file_scope, we don't have to do any processing.  */
7595   if (label_context_stack_vm == NULL)
7596     return;
7597
7598   if (c_switch_stack && !c_switch_stack->blocked_vm)
7599     c_switch_stack->blocked_vm = scope;
7600   for (glist = label_context_stack_vm->labels_used;
7601        glist != NULL;
7602        glist = glist->next)
7603     {
7604       C_DECL_UNDEFINABLE_VM (glist->label) = 1;
7605     }
7606   nstack = XOBNEW (&parser_obstack, struct c_label_context_vm);
7607   nstack->labels_def = NULL;
7608   nstack->labels_used = NULL;
7609   nstack->scope = scope;
7610   nstack->next = label_context_stack_vm;
7611   label_context_stack_vm = nstack;
7612 }
7613
7614 /* End a scope which may contain identifiers of variably modified
7615    type, scope number SCOPE.  */
7616
7617 void
7618 c_end_vm_scope (unsigned int scope)
7619 {
7620   if (label_context_stack_vm == NULL)
7621     return;
7622   if (c_switch_stack && c_switch_stack->blocked_vm == scope)
7623     c_switch_stack->blocked_vm = 0;
7624   /* We may have a number of nested scopes of identifiers with
7625      variably modified type, all at this depth.  Pop each in turn.  */
7626   while (label_context_stack_vm->scope == scope)
7627     {
7628       struct c_label_list *dlist, *glist, *glist_prev = NULL;
7629
7630       /* It is no longer possible to jump to labels defined within this
7631          scope.  */
7632       for (dlist = label_context_stack_vm->labels_def;
7633            dlist != NULL;
7634            dlist = dlist->next)
7635         {
7636           C_DECL_UNJUMPABLE_VM (dlist->label) = 1;
7637         }
7638       /* It is again possible to define labels with a goto just outside
7639          this scope.  */
7640       for (glist = label_context_stack_vm->next->labels_used;
7641            glist != NULL;
7642            glist = glist->next)
7643         {
7644           C_DECL_UNDEFINABLE_VM (glist->label) = 0;
7645           glist_prev = glist;
7646         }
7647       if (glist_prev != NULL)
7648         glist_prev->next = label_context_stack_vm->labels_used;
7649       else
7650         label_context_stack_vm->next->labels_used
7651           = label_context_stack_vm->labels_used;
7652       label_context_stack_vm = label_context_stack_vm->next;
7653     }
7654 }
7655 \f
7656 /* Begin and end compound statements.  This is as simple as pushing
7657    and popping new statement lists from the tree.  */
7658
7659 tree
7660 c_begin_compound_stmt (bool do_scope)
7661 {
7662   tree stmt = push_stmt_list ();
7663   if (do_scope)
7664     push_scope ();
7665   return stmt;
7666 }
7667
7668 tree
7669 c_end_compound_stmt (tree stmt, bool do_scope)
7670 {
7671   tree block = NULL;
7672
7673   if (do_scope)
7674     {
7675       if (c_dialect_objc ())
7676         objc_clear_super_receiver ();
7677       block = pop_scope ();
7678     }
7679
7680   stmt = pop_stmt_list (stmt);
7681   stmt = c_build_bind_expr (block, stmt);
7682
7683   /* If this compound statement is nested immediately inside a statement
7684      expression, then force a BIND_EXPR to be created.  Otherwise we'll
7685      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
7686      STATEMENT_LISTs merge, and thus we can lose track of what statement
7687      was really last.  */
7688   if (cur_stmt_list
7689       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
7690       && TREE_CODE (stmt) != BIND_EXPR)
7691     {
7692       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
7693       TREE_SIDE_EFFECTS (stmt) = 1;
7694     }
7695
7696   return stmt;
7697 }
7698
7699 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
7700    when the current scope is exited.  EH_ONLY is true when this is not
7701    meant to apply to normal control flow transfer.  */
7702
7703 void
7704 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
7705 {
7706   enum tree_code code;
7707   tree stmt, list;
7708   bool stmt_expr;
7709
7710   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
7711   stmt = build_stmt (code, NULL, cleanup);
7712   add_stmt (stmt);
7713   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
7714   list = push_stmt_list ();
7715   TREE_OPERAND (stmt, 0) = list;
7716   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
7717 }
7718 \f
7719 /* Build a binary-operation expression without default conversions.
7720    CODE is the kind of expression to build.
7721    This function differs from `build' in several ways:
7722    the data type of the result is computed and recorded in it,
7723    warnings are generated if arg data types are invalid,
7724    special handling for addition and subtraction of pointers is known,
7725    and some optimization is done (operations on narrow ints
7726    are done in the narrower type when that gives the same result).
7727    Constant folding is also done before the result is returned.
7728
7729    Note that the operands will never have enumeral types, or function
7730    or array types, because either they will have the default conversions
7731    performed or they have both just been converted to some other type in which
7732    the arithmetic is to be done.  */
7733
7734 tree
7735 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
7736                  int convert_p)
7737 {
7738   tree type0, type1;
7739   enum tree_code code0, code1;
7740   tree op0, op1;
7741   const char *invalid_op_diag;
7742
7743   /* Expression code to give to the expression when it is built.
7744      Normally this is CODE, which is what the caller asked for,
7745      but in some special cases we change it.  */
7746   enum tree_code resultcode = code;
7747
7748   /* Data type in which the computation is to be performed.
7749      In the simplest cases this is the common type of the arguments.  */
7750   tree result_type = NULL;
7751
7752   /* Nonzero means operands have already been type-converted
7753      in whatever way is necessary.
7754      Zero means they need to be converted to RESULT_TYPE.  */
7755   int converted = 0;
7756
7757   /* Nonzero means create the expression with this type, rather than
7758      RESULT_TYPE.  */
7759   tree build_type = 0;
7760
7761   /* Nonzero means after finally constructing the expression
7762      convert it to this type.  */
7763   tree final_type = 0;
7764
7765   /* Nonzero if this is an operation like MIN or MAX which can
7766      safely be computed in short if both args are promoted shorts.
7767      Also implies COMMON.
7768      -1 indicates a bitwise operation; this makes a difference
7769      in the exact conditions for when it is safe to do the operation
7770      in a narrower mode.  */
7771   int shorten = 0;
7772
7773   /* Nonzero if this is a comparison operation;
7774      if both args are promoted shorts, compare the original shorts.
7775      Also implies COMMON.  */
7776   int short_compare = 0;
7777
7778   /* Nonzero if this is a right-shift operation, which can be computed on the
7779      original short and then promoted if the operand is a promoted short.  */
7780   int short_shift = 0;
7781
7782   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
7783   int common = 0;
7784
7785   /* True means types are compatible as far as ObjC is concerned.  */
7786   bool objc_ok;
7787
7788   if (convert_p)
7789     {
7790       op0 = default_conversion (orig_op0);
7791       op1 = default_conversion (orig_op1);
7792     }
7793   else
7794     {
7795       op0 = orig_op0;
7796       op1 = orig_op1;
7797     }
7798
7799   type0 = TREE_TYPE (op0);
7800   type1 = TREE_TYPE (op1);
7801
7802   /* The expression codes of the data types of the arguments tell us
7803      whether the arguments are integers, floating, pointers, etc.  */
7804   code0 = TREE_CODE (type0);
7805   code1 = TREE_CODE (type1);
7806
7807   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
7808   STRIP_TYPE_NOPS (op0);
7809   STRIP_TYPE_NOPS (op1);
7810
7811   /* If an error was already reported for one of the arguments,
7812      avoid reporting another error.  */
7813
7814   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7815     return error_mark_node;
7816
7817   if ((invalid_op_diag
7818        = targetm.invalid_binary_op (code, type0, type1)))
7819     {
7820       error (invalid_op_diag);
7821       return error_mark_node;
7822     }
7823
7824   objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
7825
7826   switch (code)
7827     {
7828     case PLUS_EXPR:
7829       /* Handle the pointer + int case.  */
7830       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7831         return pointer_int_sum (PLUS_EXPR, op0, op1);
7832       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
7833         return pointer_int_sum (PLUS_EXPR, op1, op0);
7834       else
7835         common = 1;
7836       break;
7837
7838     case MINUS_EXPR:
7839       /* Subtraction of two similar pointers.
7840          We must subtract them as integers, then divide by object size.  */
7841       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
7842           && comp_target_types (type0, type1))
7843         return pointer_diff (op0, op1);
7844       /* Handle pointer minus int.  Just like pointer plus int.  */
7845       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7846         return pointer_int_sum (MINUS_EXPR, op0, op1);
7847       else
7848         common = 1;
7849       break;
7850
7851     case MULT_EXPR:
7852       common = 1;
7853       break;
7854
7855     case TRUNC_DIV_EXPR:
7856     case CEIL_DIV_EXPR:
7857     case FLOOR_DIV_EXPR:
7858     case ROUND_DIV_EXPR:
7859     case EXACT_DIV_EXPR:
7860       /* Floating point division by zero is a legitimate way to obtain
7861          infinities and NaNs.  */
7862       if (skip_evaluation == 0 && integer_zerop (op1))
7863         warning (OPT_Wdiv_by_zero, "division by zero");
7864
7865       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7866            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7867           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7868               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
7869         {
7870           enum tree_code tcode0 = code0, tcode1 = code1;
7871
7872           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7873             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
7874           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
7875             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
7876
7877           if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
7878             resultcode = RDIV_EXPR;
7879           else
7880             /* Although it would be tempting to shorten always here, that
7881                loses on some targets, since the modulo instruction is
7882                undefined if the quotient can't be represented in the
7883                computation mode.  We shorten only if unsigned or if
7884                dividing by something we know != -1.  */
7885             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7886                        || (TREE_CODE (op1) == INTEGER_CST
7887                            && !integer_all_onesp (op1)));
7888           common = 1;
7889         }
7890       break;
7891
7892     case BIT_AND_EXPR:
7893     case BIT_IOR_EXPR:
7894     case BIT_XOR_EXPR:
7895       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7896         shorten = -1;
7897       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
7898         common = 1;
7899       break;
7900
7901     case TRUNC_MOD_EXPR:
7902     case FLOOR_MOD_EXPR:
7903       if (skip_evaluation == 0 && integer_zerop (op1))
7904         warning (OPT_Wdiv_by_zero, "division by zero");
7905
7906       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7907         {
7908           /* Although it would be tempting to shorten always here, that loses
7909              on some targets, since the modulo instruction is undefined if the
7910              quotient can't be represented in the computation mode.  We shorten
7911              only if unsigned or if dividing by something we know != -1.  */
7912           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7913                      || (TREE_CODE (op1) == INTEGER_CST
7914                          && !integer_all_onesp (op1)));
7915           common = 1;
7916         }
7917       break;
7918
7919     case TRUTH_ANDIF_EXPR:
7920     case TRUTH_ORIF_EXPR:
7921     case TRUTH_AND_EXPR:
7922     case TRUTH_OR_EXPR:
7923     case TRUTH_XOR_EXPR:
7924       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7925            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7926           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7927               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7928         {
7929           /* Result of these operations is always an int,
7930              but that does not mean the operands should be
7931              converted to ints!  */
7932           result_type = integer_type_node;
7933           op0 = c_common_truthvalue_conversion (op0);
7934           op1 = c_common_truthvalue_conversion (op1);
7935           converted = 1;
7936         }
7937       break;
7938
7939       /* Shift operations: result has same type as first operand;
7940          always convert second operand to int.
7941          Also set SHORT_SHIFT if shifting rightward.  */
7942
7943     case RSHIFT_EXPR:
7944       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7945         {
7946           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7947             {
7948               if (tree_int_cst_sgn (op1) < 0)
7949                 warning (0, "right shift count is negative");
7950               else
7951                 {
7952                   if (!integer_zerop (op1))
7953                     short_shift = 1;
7954
7955                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7956                     warning (0, "right shift count >= width of type");
7957                 }
7958             }
7959
7960           /* Use the type of the value to be shifted.  */
7961           result_type = type0;
7962           /* Convert the shift-count to an integer, regardless of size
7963              of value being shifted.  */
7964           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7965             op1 = convert (integer_type_node, op1);
7966           /* Avoid converting op1 to result_type later.  */
7967           converted = 1;
7968         }
7969       break;
7970
7971     case LSHIFT_EXPR:
7972       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7973         {
7974           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7975             {
7976               if (tree_int_cst_sgn (op1) < 0)
7977                 warning (0, "left shift count is negative");
7978
7979               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7980                 warning (0, "left shift count >= width of type");
7981             }
7982
7983           /* Use the type of the value to be shifted.  */
7984           result_type = type0;
7985           /* Convert the shift-count to an integer, regardless of size
7986              of value being shifted.  */
7987           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7988             op1 = convert (integer_type_node, op1);
7989           /* Avoid converting op1 to result_type later.  */
7990           converted = 1;
7991         }
7992       break;
7993
7994     case EQ_EXPR:
7995     case NE_EXPR:
7996       if (code0 == REAL_TYPE || code1 == REAL_TYPE)
7997         warning (OPT_Wfloat_equal,
7998                  "comparing floating point with == or != is unsafe");
7999       /* Result of comparison is always int,
8000          but don't convert the args to int!  */
8001       build_type = integer_type_node;
8002       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
8003            || code0 == COMPLEX_TYPE)
8004           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
8005               || code1 == COMPLEX_TYPE))
8006         short_compare = 1;
8007       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
8008         {
8009           tree tt0 = TREE_TYPE (type0);
8010           tree tt1 = TREE_TYPE (type1);
8011           /* Anything compares with void *.  void * compares with anything.
8012              Otherwise, the targets must be compatible
8013              and both must be object or both incomplete.  */
8014           if (comp_target_types (type0, type1))
8015             result_type = common_pointer_type (type0, type1);
8016           else if (VOID_TYPE_P (tt0))
8017             {
8018               /* op0 != orig_op0 detects the case of something
8019                  whose value is 0 but which isn't a valid null ptr const.  */
8020               if (pedantic && !null_pointer_constant_p (orig_op0)
8021                   && TREE_CODE (tt1) == FUNCTION_TYPE)
8022                 pedwarn ("ISO C forbids comparison of %<void *%>"
8023                          " with function pointer");
8024             }
8025           else if (VOID_TYPE_P (tt1))
8026             {
8027               if (pedantic && !null_pointer_constant_p (orig_op1)
8028                   && TREE_CODE (tt0) == FUNCTION_TYPE)
8029                 pedwarn ("ISO C forbids comparison of %<void *%>"
8030                          " with function pointer");
8031             }
8032           else
8033             /* Avoid warning about the volatile ObjC EH puts on decls.  */
8034             if (!objc_ok)
8035               pedwarn ("comparison of distinct pointer types lacks a cast");
8036
8037           if (result_type == NULL_TREE)
8038             result_type = ptr_type_node;
8039         }
8040       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
8041         {
8042           if (TREE_CODE (op0) == ADDR_EXPR
8043               && DECL_P (TREE_OPERAND (op0, 0))
8044               && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL
8045                   || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
8046                   || !DECL_WEAK (TREE_OPERAND (op0, 0))))
8047             warning (OPT_Walways_true, "the address of %qD will never be NULL",
8048                      TREE_OPERAND (op0, 0));
8049           result_type = type0;
8050         }
8051       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
8052         {
8053           if (TREE_CODE (op1) == ADDR_EXPR
8054               && DECL_P (TREE_OPERAND (op1, 0))
8055               && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL
8056                   || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL
8057                   || !DECL_WEAK (TREE_OPERAND (op1, 0))))
8058             warning (OPT_Walways_true, "the address of %qD will never be NULL",
8059                      TREE_OPERAND (op1, 0));
8060           result_type = type1;
8061         }
8062       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
8063         {
8064           result_type = type0;
8065           pedwarn ("comparison between pointer and integer");
8066         }
8067       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
8068         {
8069           result_type = type1;
8070           pedwarn ("comparison between pointer and integer");
8071         }
8072       break;
8073
8074     case LE_EXPR:
8075     case GE_EXPR:
8076     case LT_EXPR:
8077     case GT_EXPR:
8078       build_type = integer_type_node;
8079       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
8080           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
8081         short_compare = 1;
8082       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
8083         {
8084           if (comp_target_types (type0, type1))
8085             {
8086               result_type = common_pointer_type (type0, type1);
8087               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
8088                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
8089                 pedwarn ("comparison of complete and incomplete pointers");
8090               else if (pedantic
8091                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
8092                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
8093             }
8094           else
8095             {
8096               result_type = ptr_type_node;
8097               pedwarn ("comparison of distinct pointer types lacks a cast");
8098             }
8099         }
8100       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
8101         {
8102           result_type = type0;
8103           if (pedantic || extra_warnings)
8104             pedwarn ("ordered comparison of pointer with integer zero");
8105         }
8106       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
8107         {
8108           result_type = type1;
8109           if (pedantic)
8110             pedwarn ("ordered comparison of pointer with integer zero");
8111         }
8112       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
8113         {
8114           result_type = type0;
8115           pedwarn ("comparison between pointer and integer");
8116         }
8117       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
8118         {
8119           result_type = type1;
8120           pedwarn ("comparison between pointer and integer");
8121         }
8122       break;
8123
8124     default:
8125       gcc_unreachable ();
8126     }
8127
8128   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
8129     return error_mark_node;
8130
8131   if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
8132       && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
8133           || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
8134                                                     TREE_TYPE (type1))))
8135     {
8136       binary_op_error (code);
8137       return error_mark_node;
8138     }
8139
8140   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
8141        || code0 == VECTOR_TYPE)
8142       &&
8143       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
8144        || code1 == VECTOR_TYPE))
8145     {
8146       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
8147
8148       if (shorten || common || short_compare)
8149         result_type = c_common_type (type0, type1);
8150
8151       /* For certain operations (which identify themselves by shorten != 0)
8152          if both args were extended from the same smaller type,
8153          do the arithmetic in that type and then extend.
8154
8155          shorten !=0 and !=1 indicates a bitwise operation.
8156          For them, this optimization is safe only if
8157          both args are zero-extended or both are sign-extended.
8158          Otherwise, we might change the result.
8159          Eg, (short)-1 | (unsigned short)-1 is (int)-1
8160          but calculated in (unsigned short) it would be (unsigned short)-1.  */
8161
8162       if (shorten && none_complex)
8163         {
8164           int unsigned0, unsigned1;
8165           tree arg0, arg1;
8166           int uns;
8167           tree type;
8168
8169           /* Cast OP0 and OP1 to RESULT_TYPE.  Doing so prevents
8170              excessive narrowing when we call get_narrower below.  For
8171              example, suppose that OP0 is of unsigned int extended
8172              from signed char and that RESULT_TYPE is long long int.
8173              If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
8174              like
8175
8176                (long long int) (unsigned int) signed_char
8177
8178              which get_narrower would narrow down to
8179
8180                (unsigned int) signed char
8181
8182              If we do not cast OP0 first, get_narrower would return
8183              signed_char, which is inconsistent with the case of the
8184              explicit cast.  */
8185           op0 = convert (result_type, op0);
8186           op1 = convert (result_type, op1);
8187
8188           arg0 = get_narrower (op0, &unsigned0);
8189           arg1 = get_narrower (op1, &unsigned1);
8190
8191           /* UNS is 1 if the operation to be done is an unsigned one.  */
8192           uns = TYPE_UNSIGNED (result_type);
8193
8194           final_type = result_type;
8195
8196           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
8197              but it *requires* conversion to FINAL_TYPE.  */
8198
8199           if ((TYPE_PRECISION (TREE_TYPE (op0))
8200                == TYPE_PRECISION (TREE_TYPE (arg0)))
8201               && TREE_TYPE (op0) != final_type)
8202             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
8203           if ((TYPE_PRECISION (TREE_TYPE (op1))
8204                == TYPE_PRECISION (TREE_TYPE (arg1)))
8205               && TREE_TYPE (op1) != final_type)
8206             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
8207
8208           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
8209
8210           /* For bitwise operations, signedness of nominal type
8211              does not matter.  Consider only how operands were extended.  */
8212           if (shorten == -1)
8213             uns = unsigned0;
8214
8215           /* Note that in all three cases below we refrain from optimizing
8216              an unsigned operation on sign-extended args.
8217              That would not be valid.  */
8218
8219           /* Both args variable: if both extended in same way
8220              from same width, do it in that width.
8221              Do it unsigned if args were zero-extended.  */
8222           if ((TYPE_PRECISION (TREE_TYPE (arg0))
8223                < TYPE_PRECISION (result_type))
8224               && (TYPE_PRECISION (TREE_TYPE (arg1))
8225                   == TYPE_PRECISION (TREE_TYPE (arg0)))
8226               && unsigned0 == unsigned1
8227               && (unsigned0 || !uns))
8228             result_type
8229               = c_common_signed_or_unsigned_type
8230               (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
8231           else if (TREE_CODE (arg0) == INTEGER_CST
8232                    && (unsigned1 || !uns)
8233                    && (TYPE_PRECISION (TREE_TYPE (arg1))
8234                        < TYPE_PRECISION (result_type))
8235                    && (type
8236                        = c_common_signed_or_unsigned_type (unsigned1,
8237                                                            TREE_TYPE (arg1)),
8238                        int_fits_type_p (arg0, type)))
8239             result_type = type;
8240           else if (TREE_CODE (arg1) == INTEGER_CST
8241                    && (unsigned0 || !uns)
8242                    && (TYPE_PRECISION (TREE_TYPE (arg0))
8243                        < TYPE_PRECISION (result_type))
8244                    && (type
8245                        = c_common_signed_or_unsigned_type (unsigned0,
8246                                                            TREE_TYPE (arg0)),
8247                        int_fits_type_p (arg1, type)))
8248             result_type = type;
8249         }
8250
8251       /* Shifts can be shortened if shifting right.  */
8252
8253       if (short_shift)
8254         {
8255           int unsigned_arg;
8256           tree arg0 = get_narrower (op0, &unsigned_arg);
8257
8258           final_type = result_type;
8259
8260           if (arg0 == op0 && final_type == TREE_TYPE (op0))
8261             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
8262
8263           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
8264               /* We can shorten only if the shift count is less than the
8265                  number of bits in the smaller type size.  */
8266               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
8267               /* We cannot drop an unsigned shift after sign-extension.  */
8268               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
8269             {
8270               /* Do an unsigned shift if the operand was zero-extended.  */
8271               result_type
8272                 = c_common_signed_or_unsigned_type (unsigned_arg,
8273                                                     TREE_TYPE (arg0));
8274               /* Convert value-to-be-shifted to that type.  */
8275               if (TREE_TYPE (op0) != result_type)
8276                 op0 = convert (result_type, op0);
8277               converted = 1;
8278             }
8279         }
8280
8281       /* Comparison operations are shortened too but differently.
8282          They identify themselves by setting short_compare = 1.  */
8283
8284       if (short_compare)
8285         {
8286           /* Don't write &op0, etc., because that would prevent op0
8287              from being kept in a register.
8288              Instead, make copies of the our local variables and
8289              pass the copies by reference, then copy them back afterward.  */
8290           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
8291           enum tree_code xresultcode = resultcode;
8292           tree val
8293             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
8294
8295           if (val != 0)
8296             return val;
8297
8298           op0 = xop0, op1 = xop1;
8299           converted = 1;
8300           resultcode = xresultcode;
8301
8302           if (warn_sign_compare && skip_evaluation == 0)
8303             {
8304               int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
8305               int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
8306               int unsignedp0, unsignedp1;
8307               tree primop0 = get_narrower (op0, &unsignedp0);
8308               tree primop1 = get_narrower (op1, &unsignedp1);
8309
8310               xop0 = orig_op0;
8311               xop1 = orig_op1;
8312               STRIP_TYPE_NOPS (xop0);
8313               STRIP_TYPE_NOPS (xop1);
8314
8315               /* Give warnings for comparisons between signed and unsigned
8316                  quantities that may fail.
8317
8318                  Do the checking based on the original operand trees, so that
8319                  casts will be considered, but default promotions won't be.
8320
8321                  Do not warn if the comparison is being done in a signed type,
8322                  since the signed type will only be chosen if it can represent
8323                  all the values of the unsigned type.  */
8324               if (!TYPE_UNSIGNED (result_type))
8325                 /* OK */;
8326               /* Do not warn if both operands are the same signedness.  */
8327               else if (op0_signed == op1_signed)
8328                 /* OK */;
8329               else
8330                 {
8331                   tree sop, uop;
8332
8333                   if (op0_signed)
8334                     sop = xop0, uop = xop1;
8335                   else
8336                     sop = xop1, uop = xop0;
8337
8338                   /* Do not warn if the signed quantity is an
8339                      unsuffixed integer literal (or some static
8340                      constant expression involving such literals or a
8341                      conditional expression involving such literals)
8342                      and it is non-negative.  */
8343                   if (tree_expr_nonnegative_p (sop))
8344                     /* OK */;
8345                   /* Do not warn if the comparison is an equality operation,
8346                      the unsigned quantity is an integral constant, and it
8347                      would fit in the result if the result were signed.  */
8348                   else if (TREE_CODE (uop) == INTEGER_CST
8349                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
8350                            && int_fits_type_p
8351                            (uop, c_common_signed_type (result_type)))
8352                     /* OK */;
8353                   /* Do not warn if the unsigned quantity is an enumeration
8354                      constant and its maximum value would fit in the result
8355                      if the result were signed.  */
8356                   else if (TREE_CODE (uop) == INTEGER_CST
8357                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
8358                            && int_fits_type_p
8359                            (TYPE_MAX_VALUE (TREE_TYPE (uop)),
8360                             c_common_signed_type (result_type)))
8361                     /* OK */;
8362                   else
8363                     warning (0, "comparison between signed and unsigned");
8364                 }
8365
8366               /* Warn if two unsigned values are being compared in a size
8367                  larger than their original size, and one (and only one) is the
8368                  result of a `~' operator.  This comparison will always fail.
8369
8370                  Also warn if one operand is a constant, and the constant
8371                  does not have all bits set that are set in the ~ operand
8372                  when it is extended.  */
8373
8374               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
8375                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
8376                 {
8377                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
8378                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
8379                                             &unsignedp0);
8380                   else
8381                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
8382                                             &unsignedp1);
8383
8384                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
8385                     {
8386                       tree primop;
8387                       HOST_WIDE_INT constant, mask;
8388                       int unsignedp, bits;
8389
8390                       if (host_integerp (primop0, 0))
8391                         {
8392                           primop = primop1;
8393                           unsignedp = unsignedp1;
8394                           constant = tree_low_cst (primop0, 0);
8395                         }
8396                       else
8397                         {
8398                           primop = primop0;
8399                           unsignedp = unsignedp0;
8400                           constant = tree_low_cst (primop1, 0);
8401                         }
8402
8403                       bits = TYPE_PRECISION (TREE_TYPE (primop));
8404                       if (bits < TYPE_PRECISION (result_type)
8405                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
8406                         {
8407                           mask = (~(HOST_WIDE_INT) 0) << bits;
8408                           if ((mask & constant) != mask)
8409                             warning (0, "comparison of promoted ~unsigned with constant");
8410                         }
8411                     }
8412                   else if (unsignedp0 && unsignedp1
8413                            && (TYPE_PRECISION (TREE_TYPE (primop0))
8414                                < TYPE_PRECISION (result_type))
8415                            && (TYPE_PRECISION (TREE_TYPE (primop1))
8416                                < TYPE_PRECISION (result_type)))
8417                     warning (0, "comparison of promoted ~unsigned with unsigned");
8418                 }
8419             }
8420         }
8421     }
8422
8423   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
8424      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
8425      Then the expression will be built.
8426      It will be given type FINAL_TYPE if that is nonzero;
8427      otherwise, it will be given type RESULT_TYPE.  */
8428
8429   if (!result_type)
8430     {
8431       binary_op_error (code);
8432       return error_mark_node;
8433     }
8434
8435   if (!converted)
8436     {
8437       if (TREE_TYPE (op0) != result_type)
8438         op0 = convert_and_check (result_type, op0);
8439       if (TREE_TYPE (op1) != result_type)
8440         op1 = convert_and_check (result_type, op1);
8441
8442       /* This can happen if one operand has a vector type, and the other
8443          has a different type.  */
8444       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
8445         return error_mark_node;
8446     }
8447
8448   if (build_type == NULL_TREE)
8449     build_type = result_type;
8450
8451   {
8452     /* Treat expressions in initializers specially as they can't trap.  */
8453     tree result = require_constant_value ? fold_build2_initializer (resultcode,
8454                                                                     build_type,
8455                                                                     op0, op1)
8456                                          : fold_build2 (resultcode, build_type,
8457                                                         op0, op1);
8458
8459     if (final_type != 0)
8460       result = convert (final_type, result);
8461     return result;
8462   }
8463 }
8464
8465
8466 /* Convert EXPR to be a truth-value, validating its type for this
8467    purpose.  */
8468
8469 tree
8470 c_objc_common_truthvalue_conversion (tree expr)
8471 {
8472   switch (TREE_CODE (TREE_TYPE (expr)))
8473     {
8474     case ARRAY_TYPE:
8475       error ("used array that cannot be converted to pointer where scalar is required");
8476       return error_mark_node;
8477
8478     case RECORD_TYPE:
8479       error ("used struct type value where scalar is required");
8480       return error_mark_node;
8481
8482     case UNION_TYPE:
8483       error ("used union type value where scalar is required");
8484       return error_mark_node;
8485
8486     case FUNCTION_TYPE:
8487       gcc_unreachable ();
8488
8489     default:
8490       break;
8491     }
8492
8493   /* ??? Should we also give an error for void and vectors rather than
8494      leaving those to give errors later?  */
8495   return c_common_truthvalue_conversion (expr);
8496 }
8497 \f
8498
8499 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
8500    required.  */
8501
8502 tree
8503 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED,
8504                 bool *ti ATTRIBUTE_UNUSED, bool *se)
8505 {
8506   if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
8507     {
8508       tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
8509       /* Executing a compound literal inside a function reinitializes
8510          it.  */
8511       if (!TREE_STATIC (decl))
8512         *se = true;
8513       return decl;
8514     }
8515   else
8516     return expr;
8517 }
8518 \f
8519 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
8520
8521 tree
8522 c_begin_omp_parallel (void)
8523 {
8524   tree block;
8525
8526   keep_next_level ();
8527   block = c_begin_compound_stmt (true);
8528
8529   return block;
8530 }
8531
8532 tree
8533 c_finish_omp_parallel (tree clauses, tree block)
8534 {
8535   tree stmt;
8536
8537   block = c_end_compound_stmt (block, true);
8538
8539   stmt = make_node (OMP_PARALLEL);
8540   TREE_TYPE (stmt) = void_type_node;
8541   OMP_PARALLEL_CLAUSES (stmt) = clauses;
8542   OMP_PARALLEL_BODY (stmt) = block;
8543
8544   return add_stmt (stmt);
8545 }
8546
8547 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
8548    Remove any elements from the list that are invalid.  */
8549
8550 tree
8551 c_finish_omp_clauses (tree clauses)
8552 {
8553   bitmap_head generic_head, firstprivate_head, lastprivate_head;
8554   tree c, t, *pc = &clauses;
8555   const char *name;
8556
8557   bitmap_obstack_initialize (NULL);
8558   bitmap_initialize (&generic_head, &bitmap_default_obstack);
8559   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
8560   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
8561
8562   for (pc = &clauses, c = clauses; c ; c = *pc)
8563     {
8564       bool remove = false;
8565       bool need_complete = false;
8566       bool need_implicitly_determined = false;
8567
8568       switch (OMP_CLAUSE_CODE (c))
8569         {
8570         case OMP_CLAUSE_SHARED:
8571           name = "shared";
8572           need_implicitly_determined = true;
8573           goto check_dup_generic;
8574
8575         case OMP_CLAUSE_PRIVATE:
8576           name = "private";
8577           need_complete = true;
8578           need_implicitly_determined = true;
8579           goto check_dup_generic;
8580
8581         case OMP_CLAUSE_REDUCTION:
8582           name = "reduction";
8583           need_implicitly_determined = true;
8584           t = OMP_CLAUSE_DECL (c);
8585           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
8586               || POINTER_TYPE_P (TREE_TYPE (t)))
8587             {
8588               error ("%qE has invalid type for %<reduction%>", t);
8589               remove = true;
8590             }
8591           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
8592             {
8593               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
8594               const char *r_name = NULL;
8595
8596               switch (r_code)
8597                 {
8598                 case PLUS_EXPR:
8599                 case MULT_EXPR:
8600                 case MINUS_EXPR:
8601                   break;
8602                 case BIT_AND_EXPR:
8603                   r_name = "&";
8604                   break;
8605                 case BIT_XOR_EXPR:
8606                   r_name = "^";
8607                   break;
8608                 case BIT_IOR_EXPR:
8609                   r_name = "|";
8610                   break;
8611                 case TRUTH_ANDIF_EXPR:
8612                   r_name = "&&";
8613                   break;
8614                 case TRUTH_ORIF_EXPR:
8615                   r_name = "||";
8616                   break;
8617                 default:
8618                   gcc_unreachable ();
8619                 }
8620               if (r_name)
8621                 {
8622                   error ("%qE has invalid type for %<reduction(%s)%>",
8623                          t, r_name);
8624                   remove = true;
8625                 }
8626             }
8627           goto check_dup_generic;
8628
8629         case OMP_CLAUSE_COPYPRIVATE:
8630           name = "copyprivate";
8631           goto check_dup_generic;
8632
8633         case OMP_CLAUSE_COPYIN:
8634           name = "copyin";
8635           t = OMP_CLAUSE_DECL (c);
8636           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
8637             {
8638               error ("%qE must be %<threadprivate%> for %<copyin%>", t);
8639               remove = true;
8640             }
8641           goto check_dup_generic;
8642
8643         check_dup_generic:
8644           t = OMP_CLAUSE_DECL (c);
8645           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8646             {
8647               error ("%qE is not a variable in clause %qs", t, name);
8648               remove = true;
8649             }
8650           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
8651                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
8652                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
8653             {
8654               error ("%qE appears more than once in data clauses", t);
8655               remove = true;
8656             }
8657           else
8658             bitmap_set_bit (&generic_head, DECL_UID (t));
8659           break;
8660
8661         case OMP_CLAUSE_FIRSTPRIVATE:
8662           name = "firstprivate";
8663           t = OMP_CLAUSE_DECL (c);
8664           need_complete = true;
8665           need_implicitly_determined = true;
8666           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8667             {
8668               error ("%qE is not a variable in clause %<firstprivate%>", t);
8669               remove = true;
8670             }
8671           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
8672                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
8673             {
8674               error ("%qE appears more than once in data clauses", t);
8675               remove = true;
8676             }
8677           else
8678             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
8679           break;
8680
8681         case OMP_CLAUSE_LASTPRIVATE:
8682           name = "lastprivate";
8683           t = OMP_CLAUSE_DECL (c);
8684           need_complete = true;
8685           need_implicitly_determined = true;
8686           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
8687             {
8688               error ("%qE is not a variable in clause %<lastprivate%>", t);
8689               remove = true;
8690             }
8691           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
8692                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
8693             {
8694               error ("%qE appears more than once in data clauses", t);
8695               remove = true;
8696             }
8697           else
8698             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
8699           break;
8700
8701         case OMP_CLAUSE_IF:
8702         case OMP_CLAUSE_NUM_THREADS:
8703         case OMP_CLAUSE_SCHEDULE:
8704         case OMP_CLAUSE_NOWAIT:
8705         case OMP_CLAUSE_ORDERED:
8706         case OMP_CLAUSE_DEFAULT:
8707           pc = &OMP_CLAUSE_CHAIN (c);
8708           continue;
8709
8710         default:
8711           gcc_unreachable ();
8712         }
8713
8714       if (!remove)
8715         {
8716           t = OMP_CLAUSE_DECL (c);
8717
8718           if (need_complete)
8719             {
8720               t = require_complete_type (t);
8721               if (t == error_mark_node)
8722                 remove = true;
8723             }
8724
8725           if (need_implicitly_determined)
8726             {
8727               const char *share_name = NULL;
8728
8729               if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
8730                 share_name = "threadprivate";
8731               else switch (c_omp_predetermined_sharing (t))
8732                 {
8733                 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
8734                   break;
8735                 case OMP_CLAUSE_DEFAULT_SHARED:
8736                   share_name = "shared";
8737                   break;
8738                 case OMP_CLAUSE_DEFAULT_PRIVATE:
8739                   share_name = "private";
8740                   break;
8741                 default:
8742                   gcc_unreachable ();
8743                 }
8744               if (share_name)
8745                 {
8746                   error ("%qE is predetermined %qs for %qs",
8747                          t, share_name, name);
8748                   remove = true;
8749                 }
8750             }
8751         }
8752
8753       if (remove)
8754         *pc = OMP_CLAUSE_CHAIN (c);
8755       else
8756         pc = &OMP_CLAUSE_CHAIN (c);
8757     }
8758
8759   bitmap_obstack_release (NULL);
8760   return clauses;
8761 }