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