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