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 (0, 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 (warn_char_subscripts && !swapped
1725       && TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node)
1726     warning (0, "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 (0, "passing argument %d of %qE with different "
2238                                  "width due to prototype", argnum, rname);
2239                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
2240                         ;
2241                       /* Don't complain if the formal parameter type
2242                          is an enum, because we can't tell now whether
2243                          the value was an enum--even the same enum.  */
2244                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
2245                         ;
2246                       else if (TREE_CODE (val) == INTEGER_CST
2247                                && int_fits_type_p (val, type))
2248                         /* Change in signedness doesn't matter
2249                            if a constant value is unaffected.  */
2250                         ;
2251                       /* If the value is extended from a narrower
2252                          unsigned type, it doesn't matter whether we
2253                          pass it as signed or unsigned; the value
2254                          certainly is the same either way.  */
2255                       else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type)
2256                                && TYPE_UNSIGNED (TREE_TYPE (val)))
2257                         ;
2258                       else if (TYPE_UNSIGNED (type))
2259                         warning (0, "passing argument %d of %qE as unsigned "
2260                                  "due to prototype", argnum, rname);
2261                       else
2262                         warning (0, "passing argument %d of %qE as signed "
2263                                  "due to prototype", argnum, rname);
2264                     }
2265                 }
2266
2267               parmval = convert_for_assignment (type, val, ic_argpass,
2268                                                 fundecl, function,
2269                                                 parmnum + 1);
2270
2271               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
2272                   && INTEGRAL_TYPE_P (type)
2273                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
2274                 parmval = default_conversion (parmval);
2275             }
2276           result = tree_cons (NULL_TREE, parmval, result);
2277         }
2278       else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE
2279                && (TYPE_PRECISION (TREE_TYPE (val))
2280                    < TYPE_PRECISION (double_type_node)))
2281         /* Convert `float' to `double'.  */
2282         result = tree_cons (NULL_TREE, convert (double_type_node, val), result);
2283       else if ((invalid_func_diag =
2284                 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
2285         {
2286           error (invalid_func_diag);
2287           return error_mark_node;
2288         }
2289       else
2290         /* Convert `short' and `char' to full-size `int'.  */
2291         result = tree_cons (NULL_TREE, default_conversion (val), result);
2292
2293       if (typetail)
2294         typetail = TREE_CHAIN (typetail);
2295     }
2296
2297   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
2298     {
2299       error ("too few arguments to function %qE", function);
2300       return error_mark_node;
2301     }
2302
2303   return nreverse (result);
2304 }
2305 \f
2306 /* This is the entry point used by the parser to build unary operators
2307    in the input.  CODE, a tree_code, specifies the unary operator, and
2308    ARG is the operand.  For unary plus, the C parser currently uses
2309    CONVERT_EXPR for code.  */
2310
2311 struct c_expr
2312 parser_build_unary_op (enum tree_code code, struct c_expr arg)
2313 {
2314   struct c_expr result;
2315
2316   result.original_code = ERROR_MARK;
2317   result.value = build_unary_op (code, arg.value, 0);
2318   overflow_warning (result.value);
2319   return result;
2320 }
2321
2322 /* This is the entry point used by the parser to build binary operators
2323    in the input.  CODE, a tree_code, specifies the binary operator, and
2324    ARG1 and ARG2 are the operands.  In addition to constructing the
2325    expression, we check for operands that were written with other binary
2326    operators in a way that is likely to confuse the user.  */
2327
2328 struct c_expr
2329 parser_build_binary_op (enum tree_code code, struct c_expr arg1,
2330                         struct c_expr arg2)
2331 {
2332   struct c_expr result;
2333
2334   enum tree_code code1 = arg1.original_code;
2335   enum tree_code code2 = arg2.original_code;
2336
2337   result.value = build_binary_op (code, arg1.value, arg2.value, 1);
2338   result.original_code = code;
2339
2340   if (TREE_CODE (result.value) == ERROR_MARK)
2341     return result;
2342
2343   /* Check for cases such as x+y<<z which users are likely
2344      to misinterpret.  */
2345   if (warn_parentheses)
2346     {
2347       if (code == LSHIFT_EXPR || code == RSHIFT_EXPR)
2348         {
2349           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2350               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2351             warning (0, "suggest parentheses around + or - inside shift");
2352         }
2353
2354       if (code == TRUTH_ORIF_EXPR)
2355         {
2356           if (code1 == TRUTH_ANDIF_EXPR
2357               || code2 == TRUTH_ANDIF_EXPR)
2358             warning (0, "suggest parentheses around && within ||");
2359         }
2360
2361       if (code == BIT_IOR_EXPR)
2362         {
2363           if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR
2364               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2365               || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR
2366               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2367             warning (0, "suggest parentheses around arithmetic in operand of |");
2368           /* Check cases like x|y==z */
2369           if (TREE_CODE_CLASS (code1) == tcc_comparison
2370               || TREE_CODE_CLASS (code2) == tcc_comparison)
2371             warning (0, "suggest parentheses around comparison in operand of |");
2372         }
2373
2374       if (code == BIT_XOR_EXPR)
2375         {
2376           if (code1 == BIT_AND_EXPR
2377               || code1 == PLUS_EXPR || code1 == MINUS_EXPR
2378               || code2 == BIT_AND_EXPR
2379               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2380             warning (0, "suggest parentheses around arithmetic in operand of ^");
2381           /* Check cases like x^y==z */
2382           if (TREE_CODE_CLASS (code1) == tcc_comparison
2383               || TREE_CODE_CLASS (code2) == tcc_comparison)
2384             warning (0, "suggest parentheses around comparison in operand of ^");
2385         }
2386
2387       if (code == BIT_AND_EXPR)
2388         {
2389           if (code1 == PLUS_EXPR || code1 == MINUS_EXPR
2390               || code2 == PLUS_EXPR || code2 == MINUS_EXPR)
2391             warning (0, "suggest parentheses around + or - in operand of &");
2392           /* Check cases like x&y==z */
2393           if (TREE_CODE_CLASS (code1) == tcc_comparison
2394               || TREE_CODE_CLASS (code2) == tcc_comparison)
2395             warning (0, "suggest parentheses around comparison in operand of &");
2396         }
2397       /* Similarly, check for cases like 1<=i<=10 that are probably errors.  */
2398       if (TREE_CODE_CLASS (code) == tcc_comparison
2399           && (TREE_CODE_CLASS (code1) == tcc_comparison
2400               || TREE_CODE_CLASS (code2) == tcc_comparison))
2401         warning (0, "comparisons like X<=Y<=Z do not have their mathematical meaning");
2402
2403     }
2404
2405   unsigned_conversion_warning (result.value, arg1.value);
2406   unsigned_conversion_warning (result.value, arg2.value);
2407   overflow_warning (result.value);
2408
2409   return result;
2410 }
2411 \f
2412 /* Return a tree for the difference of pointers OP0 and OP1.
2413    The resulting tree has type int.  */
2414
2415 static tree
2416 pointer_diff (tree op0, tree op1)
2417 {
2418   tree restype = ptrdiff_type_node;
2419
2420   tree target_type = TREE_TYPE (TREE_TYPE (op0));
2421   tree con0, con1, lit0, lit1;
2422   tree orig_op1 = op1;
2423
2424   if (pedantic || warn_pointer_arith)
2425     {
2426       if (TREE_CODE (target_type) == VOID_TYPE)
2427         pedwarn ("pointer of type %<void *%> used in subtraction");
2428       if (TREE_CODE (target_type) == FUNCTION_TYPE)
2429         pedwarn ("pointer to a function used in subtraction");
2430     }
2431
2432   /* If the conversion to ptrdiff_type does anything like widening or
2433      converting a partial to an integral mode, we get a convert_expression
2434      that is in the way to do any simplifications.
2435      (fold-const.c doesn't know that the extra bits won't be needed.
2436      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
2437      different mode in place.)
2438      So first try to find a common term here 'by hand'; we want to cover
2439      at least the cases that occur in legal static initializers.  */
2440   con0 = TREE_CODE (op0) == NOP_EXPR ? TREE_OPERAND (op0, 0) : op0;
2441   con1 = TREE_CODE (op1) == NOP_EXPR ? TREE_OPERAND (op1, 0) : op1;
2442
2443   if (TREE_CODE (con0) == PLUS_EXPR)
2444     {
2445       lit0 = TREE_OPERAND (con0, 1);
2446       con0 = TREE_OPERAND (con0, 0);
2447     }
2448   else
2449     lit0 = integer_zero_node;
2450
2451   if (TREE_CODE (con1) == PLUS_EXPR)
2452     {
2453       lit1 = TREE_OPERAND (con1, 1);
2454       con1 = TREE_OPERAND (con1, 0);
2455     }
2456   else
2457     lit1 = integer_zero_node;
2458
2459   if (operand_equal_p (con0, con1, 0))
2460     {
2461       op0 = lit0;
2462       op1 = lit1;
2463     }
2464
2465
2466   /* First do the subtraction as integers;
2467      then drop through to build the divide operator.
2468      Do not do default conversions on the minus operator
2469      in case restype is a short type.  */
2470
2471   op0 = build_binary_op (MINUS_EXPR, convert (restype, op0),
2472                          convert (restype, op1), 0);
2473   /* This generates an error if op1 is pointer to incomplete type.  */
2474   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
2475     error ("arithmetic on pointer to an incomplete type");
2476
2477   /* This generates an error if op0 is pointer to incomplete type.  */
2478   op1 = c_size_in_bytes (target_type);
2479
2480   /* Divide by the size, in easiest possible way.  */
2481   return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1));
2482 }
2483 \f
2484 /* Construct and perhaps optimize a tree representation
2485    for a unary operation.  CODE, a tree_code, specifies the operation
2486    and XARG is the operand.
2487    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
2488    the default promotions (such as from short to int).
2489    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
2490    allows non-lvalues; this is only used to handle conversion of non-lvalue
2491    arrays to pointers in C99.  */
2492
2493 tree
2494 build_unary_op (enum tree_code code, tree xarg, int flag)
2495 {
2496   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
2497   tree arg = xarg;
2498   tree argtype = 0;
2499   enum tree_code typecode = TREE_CODE (TREE_TYPE (arg));
2500   tree val;
2501   int noconvert = flag;
2502
2503   if (typecode == ERROR_MARK)
2504     return error_mark_node;
2505   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
2506     typecode = INTEGER_TYPE;
2507
2508   switch (code)
2509     {
2510     case CONVERT_EXPR:
2511       /* This is used for unary plus, because a CONVERT_EXPR
2512          is enough to prevent anybody from looking inside for
2513          associativity, but won't generate any code.  */
2514       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2515             || typecode == COMPLEX_TYPE
2516             || typecode == VECTOR_TYPE))
2517         {
2518           error ("wrong type argument to unary plus");
2519           return error_mark_node;
2520         }
2521       else if (!noconvert)
2522         arg = default_conversion (arg);
2523       arg = non_lvalue (arg);
2524       break;
2525
2526     case NEGATE_EXPR:
2527       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2528             || typecode == COMPLEX_TYPE
2529             || typecode == VECTOR_TYPE))
2530         {
2531           error ("wrong type argument to unary minus");
2532           return error_mark_node;
2533         }
2534       else if (!noconvert)
2535         arg = default_conversion (arg);
2536       break;
2537
2538     case BIT_NOT_EXPR:
2539       if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE)
2540         {
2541           if (!noconvert)
2542             arg = default_conversion (arg);
2543         }
2544       else if (typecode == COMPLEX_TYPE)
2545         {
2546           code = CONJ_EXPR;
2547           if (pedantic)
2548             pedwarn ("ISO C does not support %<~%> for complex conjugation");
2549           if (!noconvert)
2550             arg = default_conversion (arg);
2551         }
2552       else
2553         {
2554           error ("wrong type argument to bit-complement");
2555           return error_mark_node;
2556         }
2557       break;
2558
2559     case ABS_EXPR:
2560       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
2561         {
2562           error ("wrong type argument to abs");
2563           return error_mark_node;
2564         }
2565       else if (!noconvert)
2566         arg = default_conversion (arg);
2567       break;
2568
2569     case CONJ_EXPR:
2570       /* Conjugating a real value is a no-op, but allow it anyway.  */
2571       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
2572             || typecode == COMPLEX_TYPE))
2573         {
2574           error ("wrong type argument to conjugation");
2575           return error_mark_node;
2576         }
2577       else if (!noconvert)
2578         arg = default_conversion (arg);
2579       break;
2580
2581     case TRUTH_NOT_EXPR:
2582       if (typecode != INTEGER_TYPE
2583           && typecode != REAL_TYPE && typecode != POINTER_TYPE
2584           && typecode != COMPLEX_TYPE)
2585         {
2586           error ("wrong type argument to unary exclamation mark");
2587           return error_mark_node;
2588         }
2589       arg = c_objc_common_truthvalue_conversion (arg);
2590       return invert_truthvalue (arg);
2591
2592     case NOP_EXPR:
2593       break;
2594
2595     case REALPART_EXPR:
2596       if (TREE_CODE (arg) == COMPLEX_CST)
2597         return TREE_REALPART (arg);
2598       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2599         return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
2600       else
2601         return arg;
2602
2603     case IMAGPART_EXPR:
2604       if (TREE_CODE (arg) == COMPLEX_CST)
2605         return TREE_IMAGPART (arg);
2606       else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE)
2607         return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg);
2608       else
2609         return convert (TREE_TYPE (arg), integer_zero_node);
2610
2611     case PREINCREMENT_EXPR:
2612     case POSTINCREMENT_EXPR:
2613     case PREDECREMENT_EXPR:
2614     case POSTDECREMENT_EXPR:
2615
2616       /* Increment or decrement the real part of the value,
2617          and don't change the imaginary part.  */
2618       if (typecode == COMPLEX_TYPE)
2619         {
2620           tree real, imag;
2621
2622           if (pedantic)
2623             pedwarn ("ISO C does not support %<++%> and %<--%>"
2624                      " on complex types");
2625
2626           arg = stabilize_reference (arg);
2627           real = build_unary_op (REALPART_EXPR, arg, 1);
2628           imag = build_unary_op (IMAGPART_EXPR, arg, 1);
2629           return build2 (COMPLEX_EXPR, TREE_TYPE (arg),
2630                          build_unary_op (code, real, 1), imag);
2631         }
2632
2633       /* Report invalid types.  */
2634
2635       if (typecode != POINTER_TYPE
2636           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
2637         {
2638           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2639             error ("wrong type argument to increment");
2640           else
2641             error ("wrong type argument to decrement");
2642
2643           return error_mark_node;
2644         }
2645
2646       {
2647         tree inc;
2648         tree result_type = TREE_TYPE (arg);
2649
2650         arg = get_unwidened (arg, 0);
2651         argtype = TREE_TYPE (arg);
2652
2653         /* Compute the increment.  */
2654
2655         if (typecode == POINTER_TYPE)
2656           {
2657             /* If pointer target is an undefined struct,
2658                we just cannot know how to do the arithmetic.  */
2659             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type)))
2660               {
2661                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2662                   error ("increment of pointer to unknown structure");
2663                 else
2664                   error ("decrement of pointer to unknown structure");
2665               }
2666             else if ((pedantic || warn_pointer_arith)
2667                      && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE
2668                          || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE))
2669               {
2670                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2671                   pedwarn ("wrong type argument to increment");
2672                 else
2673                   pedwarn ("wrong type argument to decrement");
2674               }
2675
2676             inc = c_size_in_bytes (TREE_TYPE (result_type));
2677           }
2678         else
2679           inc = integer_one_node;
2680
2681         inc = convert (argtype, inc);
2682
2683         /* Complain about anything else that is not a true lvalue.  */
2684         if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR
2685                                     || code == POSTINCREMENT_EXPR)
2686                                    ? lv_increment
2687                                    : lv_decrement)))
2688           return error_mark_node;
2689
2690         /* Report a read-only lvalue.  */
2691         if (TREE_READONLY (arg))
2692           readonly_error (arg,
2693                           ((code == PREINCREMENT_EXPR
2694                             || code == POSTINCREMENT_EXPR)
2695                            ? lv_increment : lv_decrement));
2696
2697         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
2698           val = boolean_increment (code, arg);
2699         else
2700           val = build2 (code, TREE_TYPE (arg), arg, inc);
2701         TREE_SIDE_EFFECTS (val) = 1;
2702         val = convert (result_type, val);
2703         if (TREE_CODE (val) != code)
2704           TREE_NO_WARNING (val) = 1;
2705         return val;
2706       }
2707
2708     case ADDR_EXPR:
2709       /* Note that this operation never does default_conversion.  */
2710
2711       /* Let &* cancel out to simplify resulting code.  */
2712       if (TREE_CODE (arg) == INDIRECT_REF)
2713         {
2714           /* Don't let this be an lvalue.  */
2715           if (lvalue_p (TREE_OPERAND (arg, 0)))
2716             return non_lvalue (TREE_OPERAND (arg, 0));
2717           return TREE_OPERAND (arg, 0);
2718         }
2719
2720       /* For &x[y], return x+y */
2721       if (TREE_CODE (arg) == ARRAY_REF)
2722         {
2723           if (!c_mark_addressable (TREE_OPERAND (arg, 0)))
2724             return error_mark_node;
2725           return build_binary_op (PLUS_EXPR,
2726                                   default_function_array_conversion
2727                                     (TREE_OPERAND (arg, 0)),
2728                                   TREE_OPERAND (arg, 1), 1);
2729         }
2730
2731       /* Anything not already handled and not a true memory reference
2732          or a non-lvalue array is an error.  */
2733       else if (typecode != FUNCTION_TYPE && !flag
2734                && !lvalue_or_else (arg, lv_addressof))
2735         return error_mark_node;
2736
2737       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
2738       argtype = TREE_TYPE (arg);
2739
2740       /* If the lvalue is const or volatile, merge that into the type
2741          to which the address will point.  Note that you can't get a
2742          restricted pointer by taking the address of something, so we
2743          only have to deal with `const' and `volatile' here.  */
2744       if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
2745           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)))
2746           argtype = c_build_type_variant (argtype,
2747                                           TREE_READONLY (arg),
2748                                           TREE_THIS_VOLATILE (arg));
2749
2750       if (!c_mark_addressable (arg))
2751         return error_mark_node;
2752
2753       gcc_assert (TREE_CODE (arg) != COMPONENT_REF
2754                   || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
2755
2756       argtype = build_pointer_type (argtype);
2757
2758       /* ??? Cope with user tricks that amount to offsetof.  Delete this
2759          when we have proper support for integer constant expressions.  */
2760       val = get_base_address (arg);
2761       if (val && TREE_CODE (val) == INDIRECT_REF
2762           && integer_zerop (TREE_OPERAND (val, 0)))
2763         return fold_convert (argtype, fold_offsetof (arg));
2764
2765       val = build1 (ADDR_EXPR, argtype, arg);
2766
2767       if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
2768         TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
2769
2770       return val;
2771
2772     default:
2773       break;
2774     }
2775
2776   if (argtype == 0)
2777     argtype = TREE_TYPE (arg);
2778   val = build1 (code, argtype, arg);
2779   return require_constant_value ? fold_initializer (val) : fold (val);
2780 }
2781
2782 /* Return nonzero if REF is an lvalue valid for this language.
2783    Lvalues can be assigned, unless their type has TYPE_READONLY.
2784    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
2785
2786 static int
2787 lvalue_p (tree ref)
2788 {
2789   enum tree_code code = TREE_CODE (ref);
2790
2791   switch (code)
2792     {
2793     case REALPART_EXPR:
2794     case IMAGPART_EXPR:
2795     case COMPONENT_REF:
2796       return lvalue_p (TREE_OPERAND (ref, 0));
2797
2798     case COMPOUND_LITERAL_EXPR:
2799     case STRING_CST:
2800       return 1;
2801
2802     case INDIRECT_REF:
2803     case ARRAY_REF:
2804     case VAR_DECL:
2805     case PARM_DECL:
2806     case RESULT_DECL:
2807     case ERROR_MARK:
2808       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
2809               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
2810
2811     case BIND_EXPR:
2812       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
2813
2814     default:
2815       return 0;
2816     }
2817 }
2818 \f
2819 /* Give an error for storing in something that is 'const'.  */
2820
2821 static void
2822 readonly_error (tree arg, enum lvalue_use use)
2823 {
2824   gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement);
2825   /* Using this macro rather than (for example) arrays of messages
2826      ensures that all the format strings are checked at compile
2827      time.  */
2828 #define READONLY_MSG(A, I, D) (use == lv_assign                         \
2829                                ? (A)                                    \
2830                                : (use == lv_increment ? (I) : (D)))
2831   if (TREE_CODE (arg) == COMPONENT_REF)
2832     {
2833       if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0))))
2834         readonly_error (TREE_OPERAND (arg, 0), use);
2835       else
2836         error (READONLY_MSG (G_("assignment of read-only member %qD"),
2837                              G_("increment of read-only member %qD"),
2838                              G_("decrement of read-only member %qD")),
2839                TREE_OPERAND (arg, 1));
2840     }
2841   else if (TREE_CODE (arg) == VAR_DECL)
2842     error (READONLY_MSG (G_("assignment of read-only variable %qD"),
2843                          G_("increment of read-only variable %qD"),
2844                          G_("decrement of read-only variable %qD")),
2845            arg);
2846   else
2847     error (READONLY_MSG (G_("assignment of read-only location"),
2848                          G_("increment of read-only location"),
2849                          G_("decrement of read-only location")));
2850 }
2851
2852
2853 /* Return nonzero if REF is an lvalue valid for this language;
2854    otherwise, print an error message and return zero.  USE says
2855    how the lvalue is being used and so selects the error message.  */
2856
2857 static int
2858 lvalue_or_else (tree ref, enum lvalue_use use)
2859 {
2860   int win = lvalue_p (ref);
2861
2862   if (!win)
2863     lvalue_error (use);
2864
2865   return win;
2866 }
2867 \f
2868 /* Mark EXP saying that we need to be able to take the
2869    address of it; it should not be allocated in a register.
2870    Returns true if successful.  */
2871
2872 bool
2873 c_mark_addressable (tree exp)
2874 {
2875   tree x = exp;
2876
2877   while (1)
2878     switch (TREE_CODE (x))
2879       {
2880       case COMPONENT_REF:
2881         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
2882           {
2883             error
2884               ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
2885             return false;
2886           }
2887
2888         /* ... fall through ...  */
2889
2890       case ADDR_EXPR:
2891       case ARRAY_REF:
2892       case REALPART_EXPR:
2893       case IMAGPART_EXPR:
2894         x = TREE_OPERAND (x, 0);
2895         break;
2896
2897       case COMPOUND_LITERAL_EXPR:
2898       case CONSTRUCTOR:
2899         TREE_ADDRESSABLE (x) = 1;
2900         return true;
2901
2902       case VAR_DECL:
2903       case CONST_DECL:
2904       case PARM_DECL:
2905       case RESULT_DECL:
2906         if (C_DECL_REGISTER (x)
2907             && DECL_NONLOCAL (x))
2908           {
2909             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2910               {
2911                 error
2912                   ("global register variable %qD used in nested function", x);
2913                 return false;
2914               }
2915             pedwarn ("register variable %qD used in nested function", x);
2916           }
2917         else if (C_DECL_REGISTER (x))
2918           {
2919             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
2920               error ("address of global register variable %qD requested", x);
2921             else
2922               error ("address of register variable %qD requested", x);
2923             return false;
2924           }
2925
2926         /* drops in */
2927       case FUNCTION_DECL:
2928         TREE_ADDRESSABLE (x) = 1;
2929         /* drops out */
2930       default:
2931         return true;
2932     }
2933 }
2934 \f
2935 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  */
2936
2937 tree
2938 build_conditional_expr (tree ifexp, tree op1, tree op2)
2939 {
2940   tree type1;
2941   tree type2;
2942   enum tree_code code1;
2943   enum tree_code code2;
2944   tree result_type = NULL;
2945   tree orig_op1 = op1, orig_op2 = op2;
2946
2947   /* Promote both alternatives.  */
2948
2949   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
2950     op1 = default_conversion (op1);
2951   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
2952     op2 = default_conversion (op2);
2953
2954   if (TREE_CODE (ifexp) == ERROR_MARK
2955       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
2956       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
2957     return error_mark_node;
2958
2959   type1 = TREE_TYPE (op1);
2960   code1 = TREE_CODE (type1);
2961   type2 = TREE_TYPE (op2);
2962   code2 = TREE_CODE (type2);
2963
2964   /* C90 does not permit non-lvalue arrays in conditional expressions.
2965      In C99 they will be pointers by now.  */
2966   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
2967     {
2968       error ("non-lvalue array in conditional expression");
2969       return error_mark_node;
2970     }
2971
2972   /* Quickly detect the usual case where op1 and op2 have the same type
2973      after promotion.  */
2974   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
2975     {
2976       if (type1 == type2)
2977         result_type = type1;
2978       else
2979         result_type = TYPE_MAIN_VARIANT (type1);
2980     }
2981   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
2982             || code1 == COMPLEX_TYPE)
2983            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
2984                || code2 == COMPLEX_TYPE))
2985     {
2986       result_type = c_common_type (type1, type2);
2987
2988       /* If -Wsign-compare, warn here if type1 and type2 have
2989          different signedness.  We'll promote the signed to unsigned
2990          and later code won't know it used to be different.
2991          Do this check on the original types, so that explicit casts
2992          will be considered, but default promotions won't.  */
2993       if (warn_sign_compare && !skip_evaluation)
2994         {
2995           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
2996           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
2997
2998           if (unsigned_op1 ^ unsigned_op2)
2999             {
3000               /* Do not warn if the result type is signed, since the
3001                  signed type will only be chosen if it can represent
3002                  all the values of the unsigned type.  */
3003               if (!TYPE_UNSIGNED (result_type))
3004                 /* OK */;
3005               /* Do not warn if the signed quantity is an unsuffixed
3006                  integer literal (or some static constant expression
3007                  involving such literals) and it is non-negative.  */
3008               else if ((unsigned_op2 && tree_expr_nonnegative_p (op1))
3009                        || (unsigned_op1 && tree_expr_nonnegative_p (op2)))
3010                 /* OK */;
3011               else
3012                 warning (0, "signed and unsigned type in conditional expression");
3013             }
3014         }
3015     }
3016   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
3017     {
3018       if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE))
3019         pedwarn ("ISO C forbids conditional expr with only one void side");
3020       result_type = void_type_node;
3021     }
3022   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
3023     {
3024       if (comp_target_types (type1, type2))
3025         result_type = common_pointer_type (type1, type2);
3026       else if (integer_zerop (op1) && TREE_TYPE (type1) == void_type_node
3027                && TREE_CODE (orig_op1) != NOP_EXPR)
3028         result_type = qualify_type (type2, type1);
3029       else if (integer_zerop (op2) && TREE_TYPE (type2) == void_type_node
3030                && TREE_CODE (orig_op2) != NOP_EXPR)
3031         result_type = qualify_type (type1, type2);
3032       else if (VOID_TYPE_P (TREE_TYPE (type1)))
3033         {
3034           if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
3035             pedwarn ("ISO C forbids conditional expr between "
3036                      "%<void *%> and function pointer");
3037           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
3038                                                           TREE_TYPE (type2)));
3039         }
3040       else if (VOID_TYPE_P (TREE_TYPE (type2)))
3041         {
3042           if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
3043             pedwarn ("ISO C forbids conditional expr between "
3044                      "%<void *%> and function pointer");
3045           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
3046                                                           TREE_TYPE (type1)));
3047         }
3048       else
3049         {
3050           pedwarn ("pointer type mismatch in conditional expression");
3051           result_type = build_pointer_type (void_type_node);
3052         }
3053     }
3054   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
3055     {
3056       if (!integer_zerop (op2))
3057         pedwarn ("pointer/integer type mismatch in conditional expression");
3058       else
3059         {
3060           op2 = null_pointer_node;
3061         }
3062       result_type = type1;
3063     }
3064   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
3065     {
3066       if (!integer_zerop (op1))
3067         pedwarn ("pointer/integer type mismatch in conditional expression");
3068       else
3069         {
3070           op1 = null_pointer_node;
3071         }
3072       result_type = type2;
3073     }
3074
3075   if (!result_type)
3076     {
3077       if (flag_cond_mismatch)
3078         result_type = void_type_node;
3079       else
3080         {
3081           error ("type mismatch in conditional expression");
3082           return error_mark_node;
3083         }
3084     }
3085
3086   /* Merge const and volatile flags of the incoming types.  */
3087   result_type
3088     = build_type_variant (result_type,
3089                           TREE_READONLY (op1) || TREE_READONLY (op2),
3090                           TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2));
3091
3092   if (result_type != TREE_TYPE (op1))
3093     op1 = convert_and_check (result_type, op1);
3094   if (result_type != TREE_TYPE (op2))
3095     op2 = convert_and_check (result_type, op2);
3096
3097   return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2);
3098 }
3099 \f
3100 /* Return a compound expression that performs two expressions and
3101    returns the value of the second of them.  */
3102
3103 tree
3104 build_compound_expr (tree expr1, tree expr2)
3105 {
3106   if (!TREE_SIDE_EFFECTS (expr1))
3107     {
3108       /* The left-hand operand of a comma expression is like an expression
3109          statement: with -Wextra or -Wunused, we should warn if it doesn't have
3110          any side-effects, unless it was explicitly cast to (void).  */
3111       if (warn_unused_value)
3112         {
3113           if (VOID_TYPE_P (TREE_TYPE (expr1))
3114               && TREE_CODE (expr1) == CONVERT_EXPR)
3115             ; /* (void) a, b */
3116           else if (VOID_TYPE_P (TREE_TYPE (expr1))
3117                    && TREE_CODE (expr1) == COMPOUND_EXPR
3118                    && TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR)
3119             ; /* (void) a, (void) b, c */
3120           else
3121             warning (0, "left-hand operand of comma expression has no effect");
3122         }
3123     }
3124
3125   /* With -Wunused, we should also warn if the left-hand operand does have
3126      side-effects, but computes a value which is not used.  For example, in
3127      `foo() + bar(), baz()' the result of the `+' operator is not used,
3128      so we should issue a warning.  */
3129   else if (warn_unused_value)
3130     warn_if_unused_value (expr1, input_location);
3131
3132   return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
3133 }
3134
3135 /* Build an expression representing a cast to type TYPE of expression EXPR.  */
3136
3137 tree
3138 build_c_cast (tree type, tree expr)
3139 {
3140   tree value = expr;
3141
3142   if (type == error_mark_node || expr == error_mark_node)
3143     return error_mark_node;
3144
3145   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
3146      only in <protocol> qualifications.  But when constructing cast expressions,
3147      the protocols do matter and must be kept around.  */
3148   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
3149     return build1 (NOP_EXPR, type, expr);
3150
3151   type = TYPE_MAIN_VARIANT (type);
3152
3153   if (TREE_CODE (type) == ARRAY_TYPE)
3154     {
3155       error ("cast specifies array type");
3156       return error_mark_node;
3157     }
3158
3159   if (TREE_CODE (type) == FUNCTION_TYPE)
3160     {
3161       error ("cast specifies function type");
3162       return error_mark_node;
3163     }
3164
3165   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
3166     {
3167       if (pedantic)
3168         {
3169           if (TREE_CODE (type) == RECORD_TYPE
3170               || TREE_CODE (type) == UNION_TYPE)
3171             pedwarn ("ISO C forbids casting nonscalar to the same type");
3172         }
3173     }
3174   else if (TREE_CODE (type) == UNION_TYPE)
3175     {
3176       tree field;
3177
3178       for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
3179         if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
3180                        TYPE_MAIN_VARIANT (TREE_TYPE (value))))
3181           break;
3182
3183       if (field)
3184         {
3185           tree t;
3186
3187           if (pedantic)
3188             pedwarn ("ISO C forbids casts to union type");
3189           t = digest_init (type,
3190                            build_constructor (type,
3191                                               build_tree_list (field, value)),
3192                            true, 0);
3193           TREE_CONSTANT (t) = TREE_CONSTANT (value);
3194           TREE_INVARIANT (t) = TREE_INVARIANT (value);
3195           return t;
3196         }
3197       error ("cast to union type from type not present in union");
3198       return error_mark_node;
3199     }
3200   else
3201     {
3202       tree otype, ovalue;
3203
3204       if (type == void_type_node)
3205         return build1 (CONVERT_EXPR, type, value);
3206
3207       otype = TREE_TYPE (value);
3208
3209       /* Optionally warn about potentially worrisome casts.  */
3210
3211       if (warn_cast_qual
3212           && TREE_CODE (type) == POINTER_TYPE
3213           && TREE_CODE (otype) == POINTER_TYPE)
3214         {
3215           tree in_type = type;
3216           tree in_otype = otype;
3217           int added = 0;
3218           int discarded = 0;
3219
3220           /* Check that the qualifiers on IN_TYPE are a superset of
3221              the qualifiers of IN_OTYPE.  The outermost level of
3222              POINTER_TYPE nodes is uninteresting and we stop as soon
3223              as we hit a non-POINTER_TYPE node on either type.  */
3224           do
3225             {
3226               in_otype = TREE_TYPE (in_otype);
3227               in_type = TREE_TYPE (in_type);
3228
3229               /* GNU C allows cv-qualified function types.  'const'
3230                  means the function is very pure, 'volatile' means it
3231                  can't return.  We need to warn when such qualifiers
3232                  are added, not when they're taken away.  */
3233               if (TREE_CODE (in_otype) == FUNCTION_TYPE
3234                   && TREE_CODE (in_type) == FUNCTION_TYPE)
3235                 added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype));
3236               else
3237                 discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type));
3238             }
3239           while (TREE_CODE (in_type) == POINTER_TYPE
3240                  && TREE_CODE (in_otype) == POINTER_TYPE);
3241
3242           if (added)
3243             warning (0, "cast adds new qualifiers to function type");
3244
3245           if (discarded)
3246             /* There are qualifiers present in IN_OTYPE that are not
3247                present in IN_TYPE.  */
3248             warning (0, "cast discards qualifiers from pointer target type");
3249         }
3250
3251       /* Warn about possible alignment problems.  */
3252       if (STRICT_ALIGNMENT && warn_cast_align
3253           && TREE_CODE (type) == POINTER_TYPE
3254           && TREE_CODE (otype) == POINTER_TYPE
3255           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
3256           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3257           /* Don't warn about opaque types, where the actual alignment
3258              restriction is unknown.  */
3259           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
3260                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
3261                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
3262           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
3263         warning (0, "cast increases required alignment of target type");
3264
3265       if (warn_pointer_to_int_cast
3266           && TREE_CODE (type) == INTEGER_TYPE
3267           && TREE_CODE (otype) == POINTER_TYPE
3268           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3269           && !TREE_CONSTANT (value))
3270         warning (0, "cast from pointer to integer of different size");
3271
3272       if (warn_bad_function_cast
3273           && TREE_CODE (value) == CALL_EXPR
3274           && TREE_CODE (type) != TREE_CODE (otype))
3275         warning (0, "cast from function call of type %qT to non-matching "
3276                  "type %qT", otype, type);
3277
3278       if (warn_int_to_pointer_cast
3279           && TREE_CODE (type) == POINTER_TYPE
3280           && TREE_CODE (otype) == INTEGER_TYPE
3281           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
3282           /* Don't warn about converting any constant.  */
3283           && !TREE_CONSTANT (value))
3284         warning (0, "cast to pointer from integer of different size");
3285
3286       if (flag_strict_aliasing && warn_strict_aliasing
3287           && TREE_CODE (type) == POINTER_TYPE
3288           && TREE_CODE (otype) == POINTER_TYPE
3289           && TREE_CODE (expr) == ADDR_EXPR
3290           && (DECL_P (TREE_OPERAND (expr, 0))
3291               || TREE_CODE (TREE_OPERAND (expr, 0)) == COMPONENT_REF)
3292           && !VOID_TYPE_P (TREE_TYPE (type)))
3293         {
3294           /* Casting the address of an object to non void pointer. Warn
3295              if the cast breaks type based aliasing.  */
3296           if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
3297             warning (0, "type-punning to incomplete type might break strict-aliasing rules");
3298           else
3299             {
3300               HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
3301               HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
3302
3303               if (!alias_sets_conflict_p (set1, set2))
3304                 warning (0, "dereferencing type-punned pointer will break strict-aliasing rules");
3305               else if (warn_strict_aliasing > 1
3306                        && !alias_sets_might_conflict_p (set1, set2))
3307                 warning (0, "dereferencing type-punned pointer might break strict-aliasing rules");
3308             }
3309         }
3310
3311       /* If pedantic, warn for conversions between function and object
3312          pointer types, except for converting a null pointer constant
3313          to function pointer type.  */
3314       if (pedantic
3315           && TREE_CODE (type) == POINTER_TYPE
3316           && TREE_CODE (otype) == POINTER_TYPE
3317           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
3318           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
3319         pedwarn ("ISO C forbids conversion of function pointer to object pointer type");
3320
3321       if (pedantic
3322           && TREE_CODE (type) == POINTER_TYPE
3323           && TREE_CODE (otype) == POINTER_TYPE
3324           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
3325           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
3326           && !(integer_zerop (value) && TREE_TYPE (otype) == void_type_node
3327                && TREE_CODE (expr) != NOP_EXPR))
3328         pedwarn ("ISO C forbids conversion of object pointer to function pointer type");
3329
3330       ovalue = value;
3331       value = convert (type, value);
3332
3333       /* Ignore any integer overflow caused by the cast.  */
3334       if (TREE_CODE (value) == INTEGER_CST)
3335         {
3336           /* If OVALUE had overflow set, then so will VALUE, so it
3337              is safe to overwrite.  */
3338           if (CONSTANT_CLASS_P (ovalue))
3339             {
3340               TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
3341               /* Similarly, constant_overflow cannot have become cleared.  */
3342               TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue);
3343             }
3344           else
3345             TREE_OVERFLOW (value) = 0;
3346         }
3347     }
3348
3349   /* Don't let a cast be an lvalue.  */
3350   if (value == expr)
3351     value = non_lvalue (value);
3352
3353   return value;
3354 }
3355
3356 /* Interpret a cast of expression EXPR to type TYPE.  */
3357 tree
3358 c_cast_expr (struct c_type_name *type_name, tree expr)
3359 {
3360   tree type;
3361   int saved_wsp = warn_strict_prototypes;
3362
3363   /* This avoids warnings about unprototyped casts on
3364      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
3365   if (TREE_CODE (expr) == INTEGER_CST)
3366     warn_strict_prototypes = 0;
3367   type = groktypename (type_name);
3368   warn_strict_prototypes = saved_wsp;
3369
3370   return build_c_cast (type, expr);
3371 }
3372
3373 \f
3374 /* Build an assignment expression of lvalue LHS from value RHS.
3375    MODIFYCODE is the code for a binary operator that we use
3376    to combine the old value of LHS with RHS to get the new value.
3377    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.  */
3378
3379 tree
3380 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
3381 {
3382   tree result;
3383   tree newrhs;
3384   tree lhstype = TREE_TYPE (lhs);
3385   tree olhstype = lhstype;
3386
3387   /* Types that aren't fully specified cannot be used in assignments.  */
3388   lhs = require_complete_type (lhs);
3389
3390   /* Avoid duplicate error messages from operands that had errors.  */
3391   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
3392     return error_mark_node;
3393
3394   STRIP_TYPE_NOPS (rhs);
3395
3396   newrhs = rhs;
3397
3398   /* If a binary op has been requested, combine the old LHS value with the RHS
3399      producing the value we should actually store into the LHS.  */
3400
3401   if (modifycode != NOP_EXPR)
3402     {
3403       lhs = stabilize_reference (lhs);
3404       newrhs = build_binary_op (modifycode, lhs, rhs, 1);
3405     }
3406
3407   if (!lvalue_or_else (lhs, lv_assign))
3408     return error_mark_node;
3409
3410   /* Give an error for storing in something that is 'const'.  */
3411
3412   if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype)
3413       || ((TREE_CODE (lhstype) == RECORD_TYPE
3414            || TREE_CODE (lhstype) == UNION_TYPE)
3415           && C_TYPE_FIELDS_READONLY (lhstype)))
3416     readonly_error (lhs, lv_assign);
3417
3418   /* If storing into a structure or union member,
3419      it has probably been given type `int'.
3420      Compute the type that would go with
3421      the actual amount of storage the member occupies.  */
3422
3423   if (TREE_CODE (lhs) == COMPONENT_REF
3424       && (TREE_CODE (lhstype) == INTEGER_TYPE
3425           || TREE_CODE (lhstype) == BOOLEAN_TYPE
3426           || TREE_CODE (lhstype) == REAL_TYPE
3427           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
3428     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
3429
3430   /* If storing in a field that is in actuality a short or narrower than one,
3431      we must store in the field in its actual type.  */
3432
3433   if (lhstype != TREE_TYPE (lhs))
3434     {
3435       lhs = copy_node (lhs);
3436       TREE_TYPE (lhs) = lhstype;
3437     }
3438
3439   /* Convert new value to destination type.  */
3440
3441   newrhs = convert_for_assignment (lhstype, newrhs, ic_assign,
3442                                    NULL_TREE, NULL_TREE, 0);
3443   if (TREE_CODE (newrhs) == ERROR_MARK)
3444     return error_mark_node;
3445
3446   /* Emit ObjC write barrier, if necessary.  */
3447   if (c_dialect_objc () && flag_objc_gc)
3448     {
3449       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
3450       if (result)
3451         return result;
3452     }
3453
3454   /* Scan operands.  */
3455
3456   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
3457   TREE_SIDE_EFFECTS (result) = 1;
3458
3459   /* If we got the LHS in a different type for storing in,
3460      convert the result back to the nominal type of LHS
3461      so that the value we return always has the same type
3462      as the LHS argument.  */
3463
3464   if (olhstype == TREE_TYPE (result))
3465     return result;
3466   return convert_for_assignment (olhstype, result, ic_assign,
3467                                  NULL_TREE, NULL_TREE, 0);
3468 }
3469 \f
3470 /* Convert value RHS to type TYPE as preparation for an assignment
3471    to an lvalue of type TYPE.
3472    The real work of conversion is done by `convert'.
3473    The purpose of this function is to generate error messages
3474    for assignments that are not allowed in C.
3475    ERRTYPE says whether it is argument passing, assignment,
3476    initialization or return.
3477
3478    FUNCTION is a tree for the function being called.
3479    PARMNUM is the number of the argument, for printing in error messages.  */
3480
3481 static tree
3482 convert_for_assignment (tree type, tree rhs, enum impl_conv errtype,
3483                         tree fundecl, tree function, int parmnum)
3484 {
3485   enum tree_code codel = TREE_CODE (type);
3486   tree rhstype;
3487   enum tree_code coder;
3488   tree rname = NULL_TREE;
3489   bool objc_ok = false;
3490
3491   if (errtype == ic_argpass || errtype == ic_argpass_nonproto)
3492     {
3493       tree selector;
3494       /* Change pointer to function to the function itself for
3495          diagnostics.  */
3496       if (TREE_CODE (function) == ADDR_EXPR
3497           && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
3498         function = TREE_OPERAND (function, 0);
3499
3500       /* Handle an ObjC selector specially for diagnostics.  */
3501       selector = objc_message_selector ();
3502       rname = function;
3503       if (selector && parmnum > 2)
3504         {
3505           rname = selector;
3506           parmnum -= 2;
3507         }
3508     }
3509
3510   /* This macro is used to emit diagnostics to ensure that all format
3511      strings are complete sentences, visible to gettext and checked at
3512      compile time.  */
3513 #define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE)     \
3514   do {                                          \
3515     switch (errtype)                            \
3516       {                                         \
3517       case ic_argpass:                          \
3518         pedwarn (AR, parmnum, rname);           \
3519         break;                                  \
3520       case ic_argpass_nonproto:                 \
3521         warning (0, AR, parmnum, rname);                \
3522         break;                                  \
3523       case ic_assign:                           \
3524         pedwarn (AS);                           \
3525         break;                                  \
3526       case ic_init:                             \
3527         pedwarn (IN);                           \
3528         break;                                  \
3529       case ic_return:                           \
3530         pedwarn (RE);                           \
3531         break;                                  \
3532       default:                                  \
3533         gcc_unreachable ();                     \
3534       }                                         \
3535   } while (0)
3536
3537   STRIP_TYPE_NOPS (rhs);
3538
3539   if (optimize && TREE_CODE (rhs) == VAR_DECL
3540            && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE)
3541     rhs = decl_constant_value_for_broken_optimization (rhs);
3542
3543   rhstype = TREE_TYPE (rhs);
3544   coder = TREE_CODE (rhstype);
3545
3546   if (coder == ERROR_MARK)
3547     return error_mark_node;
3548
3549   if (c_dialect_objc ())
3550     {
3551       int parmno;
3552
3553       switch (errtype)
3554         {
3555         case ic_return:
3556           parmno = 0;
3557           break;
3558
3559         case ic_assign:
3560           parmno = -1;
3561           break;
3562
3563         case ic_init:
3564           parmno = -2;
3565           break;
3566
3567         default:
3568           parmno = parmnum;
3569           break;
3570         }
3571
3572       objc_ok = objc_compare_types (type, rhstype, parmno, rname);
3573     }
3574
3575   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
3576     {
3577       overflow_warning (rhs);
3578       return rhs;
3579     }
3580
3581   if (coder == VOID_TYPE)
3582     {
3583       /* Except for passing an argument to an unprototyped function,
3584          this is a constraint violation.  When passing an argument to
3585          an unprototyped function, it is compile-time undefined;
3586          making it a constraint in that case was rejected in
3587          DR#252.  */
3588       error ("void value not ignored as it ought to be");
3589       return error_mark_node;
3590     }
3591   /* A type converts to a reference to it.
3592      This code doesn't fully support references, it's just for the
3593      special case of va_start and va_copy.  */
3594   if (codel == REFERENCE_TYPE
3595       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
3596     {
3597       if (!lvalue_p (rhs))
3598         {
3599           error ("cannot pass rvalue to reference parameter");
3600           return error_mark_node;
3601         }
3602       if (!c_mark_addressable (rhs))
3603         return error_mark_node;
3604       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
3605
3606       /* We already know that these two types are compatible, but they
3607          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
3608          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
3609          likely to be va_list, a typedef to __builtin_va_list, which
3610          is different enough that it will cause problems later.  */
3611       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
3612         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
3613
3614       rhs = build1 (NOP_EXPR, type, rhs);
3615       return rhs;
3616     }
3617   /* Some types can interconvert without explicit casts.  */
3618   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
3619            && vector_types_convertible_p (type, TREE_TYPE (rhs)))
3620     return convert (type, rhs);
3621   /* Arithmetic types all interconvert, and enum is treated like int.  */
3622   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
3623             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
3624             || codel == BOOLEAN_TYPE)
3625            && (coder == INTEGER_TYPE || coder == REAL_TYPE
3626                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
3627                || coder == BOOLEAN_TYPE))
3628     return convert_and_check (type, rhs);
3629
3630   /* Conversion to a transparent union from its member types.
3631      This applies only to function arguments.  */
3632   else if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
3633            && (errtype == ic_argpass || errtype == ic_argpass_nonproto))
3634     {
3635       tree memb_types;
3636       tree marginal_memb_type = 0;
3637
3638       for (memb_types = TYPE_FIELDS (type); memb_types;
3639            memb_types = TREE_CHAIN (memb_types))
3640         {
3641           tree memb_type = TREE_TYPE (memb_types);
3642
3643           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
3644                          TYPE_MAIN_VARIANT (rhstype)))
3645             break;
3646
3647           if (TREE_CODE (memb_type) != POINTER_TYPE)
3648             continue;
3649
3650           if (coder == POINTER_TYPE)
3651             {
3652               tree ttl = TREE_TYPE (memb_type);
3653               tree ttr = TREE_TYPE (rhstype);
3654
3655               /* Any non-function converts to a [const][volatile] void *
3656                  and vice versa; otherwise, targets must be the same.
3657                  Meanwhile, the lhs target must have all the qualifiers of
3658                  the rhs.  */
3659               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3660                   || comp_target_types (memb_type, rhstype))
3661                 {
3662                   /* If this type won't generate any warnings, use it.  */
3663                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
3664                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
3665                            && TREE_CODE (ttl) == FUNCTION_TYPE)
3666                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3667                              == TYPE_QUALS (ttr))
3668                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
3669                              == TYPE_QUALS (ttl))))
3670                     break;
3671
3672                   /* Keep looking for a better type, but remember this one.  */
3673                   if (!marginal_memb_type)
3674                     marginal_memb_type = memb_type;
3675                 }
3676             }
3677
3678           /* Can convert integer zero to any pointer type.  */
3679           if (integer_zerop (rhs)
3680               || (TREE_CODE (rhs) == NOP_EXPR
3681                   && integer_zerop (TREE_OPERAND (rhs, 0))))
3682             {
3683               rhs = null_pointer_node;
3684               break;
3685             }
3686         }
3687
3688       if (memb_types || marginal_memb_type)
3689         {
3690           if (!memb_types)
3691             {
3692               /* We have only a marginally acceptable member type;
3693                  it needs a warning.  */
3694               tree ttl = TREE_TYPE (marginal_memb_type);
3695               tree ttr = TREE_TYPE (rhstype);
3696
3697               /* Const and volatile mean something different for function
3698                  types, so the usual warnings are not appropriate.  */
3699               if (TREE_CODE (ttr) == FUNCTION_TYPE
3700                   && TREE_CODE (ttl) == FUNCTION_TYPE)
3701                 {
3702                   /* Because const and volatile on functions are
3703                      restrictions that say the function will not do
3704                      certain things, it is okay to use a const or volatile
3705                      function where an ordinary one is wanted, but not
3706                      vice-versa.  */
3707                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3708                     WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE "
3709                                             "makes qualified function "
3710                                             "pointer from unqualified"),
3711                                          G_("assignment makes qualified "
3712                                             "function pointer from "
3713                                             "unqualified"),
3714                                          G_("initialization makes qualified "
3715                                             "function pointer from "
3716                                             "unqualified"),
3717                                          G_("return makes qualified function "
3718                                             "pointer from unqualified"));
3719                 }
3720               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3721                 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
3722                                         "qualifiers from pointer target type"),
3723                                      G_("assignment discards qualifiers "
3724                                         "from pointer target type"),
3725                                      G_("initialization discards qualifiers "
3726                                         "from pointer target type"),
3727                                      G_("return discards qualifiers from "
3728                                         "pointer target type"));
3729             }
3730
3731           if (pedantic && !DECL_IN_SYSTEM_HEADER (fundecl))
3732             pedwarn ("ISO C prohibits argument conversion to union type");
3733
3734           return build1 (NOP_EXPR, type, rhs);
3735         }
3736     }
3737
3738   /* Conversions among pointers */
3739   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
3740            && (coder == codel))
3741     {
3742       tree ttl = TREE_TYPE (type);
3743       tree ttr = TREE_TYPE (rhstype);
3744       tree mvl = ttl;
3745       tree mvr = ttr;
3746       bool is_opaque_pointer;
3747       int target_cmp = 0;   /* Cache comp_target_types () result.  */
3748
3749       if (TREE_CODE (mvl) != ARRAY_TYPE)
3750         mvl = TYPE_MAIN_VARIANT (mvl);
3751       if (TREE_CODE (mvr) != ARRAY_TYPE)
3752         mvr = TYPE_MAIN_VARIANT (mvr);
3753       /* Opaque pointers are treated like void pointers.  */
3754       is_opaque_pointer = (targetm.vector_opaque_p (type)
3755                            || targetm.vector_opaque_p (rhstype))
3756         && TREE_CODE (ttl) == VECTOR_TYPE
3757         && TREE_CODE (ttr) == VECTOR_TYPE;
3758
3759       /* C++ does not allow the implicit conversion void* -> T*.  However,
3760          for the purpose of reducing the number of false positives, we
3761          tolerate the special case of
3762
3763                 int *p = NULL;
3764
3765          where NULL is typically defined in C to be '(void *) 0'.  */
3766       if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
3767         warning (OPT_Wc___compat, "request for implicit conversion from "
3768                  "%qT to %qT not permitted in C++", rhstype, type);
3769
3770       /* Any non-function converts to a [const][volatile] void *
3771          and vice versa; otherwise, targets must be the same.
3772          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
3773       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3774           || (target_cmp = comp_target_types (type, rhstype))
3775           || is_opaque_pointer
3776           || (c_common_unsigned_type (mvl)
3777               == c_common_unsigned_type (mvr)))
3778         {
3779           if (pedantic
3780               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
3781                   ||
3782                   (VOID_TYPE_P (ttr)
3783                    /* Check TREE_CODE to catch cases like (void *) (char *) 0
3784                       which are not ANSI null ptr constants.  */
3785                    && (!integer_zerop (rhs) || TREE_CODE (rhs) == NOP_EXPR)
3786                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
3787             WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of "
3788                                     "%qE between function pointer "
3789                                     "and %<void *%>"),
3790                                  G_("ISO C forbids assignment between "
3791                                     "function pointer and %<void *%>"),
3792                                  G_("ISO C forbids initialization between "
3793                                     "function pointer and %<void *%>"),
3794                                  G_("ISO C forbids return between function "
3795                                     "pointer and %<void *%>"));
3796           /* Const and volatile mean something different for function types,
3797              so the usual warnings are not appropriate.  */
3798           else if (TREE_CODE (ttr) != FUNCTION_TYPE
3799                    && TREE_CODE (ttl) != FUNCTION_TYPE)
3800             {
3801               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
3802                 {
3803                   /* Types differing only by the presence of the 'volatile'
3804                      qualifier are acceptable if the 'volatile' has been added
3805                      in by the Objective-C EH machinery.  */
3806                   if (!objc_type_quals_match (ttl, ttr))
3807                     WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards "
3808                                             "qualifiers from pointer target type"),
3809                                          G_("assignment discards qualifiers "
3810                                             "from pointer target type"),
3811                                          G_("initialization discards qualifiers "
3812                                             "from pointer target type"),
3813                                          G_("return discards qualifiers from "
3814                                             "pointer target type"));
3815                 }
3816               /* If this is not a case of ignoring a mismatch in signedness,
3817                  no warning.  */
3818               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
3819                        || target_cmp)
3820                 ;
3821               /* If there is a mismatch, do warn.  */
3822               else if (warn_pointer_sign)
3823                 WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument "
3824                                         "%d of %qE differ in signedness"),
3825                                      G_("pointer targets in assignment "
3826                                         "differ in signedness"),
3827                                      G_("pointer targets in initialization "
3828                                         "differ in signedness"),
3829                                      G_("pointer targets in return differ "
3830                                         "in signedness"));
3831             }
3832           else if (TREE_CODE (ttl) == FUNCTION_TYPE
3833                    && TREE_CODE (ttr) == FUNCTION_TYPE)
3834             {
3835               /* Because const and volatile on functions are restrictions
3836                  that say the function will not do certain things,
3837                  it is okay to use a const or volatile function
3838                  where an ordinary one is wanted, but not vice-versa.  */
3839               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
3840                 WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
3841                                         "qualified function pointer "
3842                                         "from unqualified"),
3843                                      G_("assignment makes qualified function "
3844                                         "pointer from unqualified"),
3845                                      G_("initialization makes qualified "
3846                                         "function pointer from unqualified"),
3847                                      G_("return makes qualified function "
3848                                         "pointer from unqualified"));
3849             }
3850         }
3851       else
3852         /* Avoid warning about the volatile ObjC EH puts on decls.  */
3853         if (!objc_ok)
3854           WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from "
3855                                   "incompatible pointer type"),
3856                                G_("assignment from incompatible pointer type"),
3857                                G_("initialization from incompatible "
3858                                   "pointer type"),
3859                                G_("return from incompatible pointer type"));
3860
3861       return convert (type, rhs);
3862     }
3863   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
3864     {
3865       /* ??? This should not be an error when inlining calls to
3866          unprototyped functions.  */
3867       error ("invalid use of non-lvalue array");
3868       return error_mark_node;
3869     }
3870   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
3871     {
3872       /* An explicit constant 0 can convert to a pointer,
3873          or one that results from arithmetic, even including
3874          a cast to integer type.  */
3875       if (!(TREE_CODE (rhs) == INTEGER_CST && integer_zerop (rhs))
3876           &&
3877           !(TREE_CODE (rhs) == NOP_EXPR
3878             && TREE_CODE (TREE_TYPE (rhs)) == INTEGER_TYPE
3879             && TREE_CODE (TREE_OPERAND (rhs, 0)) == INTEGER_CST
3880             && integer_zerop (TREE_OPERAND (rhs, 0))))
3881         WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes "
3882                                 "pointer from integer without a cast"),
3883                              G_("assignment makes pointer from integer "
3884                                 "without a cast"),
3885                              G_("initialization makes pointer from "
3886                                 "integer without a cast"),
3887                              G_("return makes pointer from integer "
3888                                 "without a cast"));
3889
3890       return convert (type, rhs);
3891     }
3892   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
3893     {
3894       WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer "
3895                               "from pointer without a cast"),
3896                            G_("assignment makes integer from pointer "
3897                               "without a cast"),
3898                            G_("initialization makes integer from pointer "
3899                               "without a cast"),
3900                            G_("return makes integer from pointer "
3901                               "without a cast"));
3902       return convert (type, rhs);
3903     }
3904   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
3905     return convert (type, rhs);
3906
3907   switch (errtype)
3908     {
3909     case ic_argpass:
3910     case ic_argpass_nonproto:
3911       /* ??? This should not be an error when inlining calls to
3912          unprototyped functions.  */
3913       error ("incompatible type for argument %d of %qE", parmnum, rname);
3914       break;
3915     case ic_assign:
3916       error ("incompatible types in assignment");
3917       break;
3918     case ic_init:
3919       error ("incompatible types in initialization");
3920       break;
3921     case ic_return:
3922       error ("incompatible types in return");
3923       break;
3924     default:
3925       gcc_unreachable ();
3926     }
3927
3928   return error_mark_node;
3929 }
3930
3931 /* Convert VALUE for assignment into inlined parameter PARM.  ARGNUM
3932    is used for error and waring reporting and indicates which argument
3933    is being processed.  */
3934
3935 tree
3936 c_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum)
3937 {
3938   tree ret, type;
3939
3940   /* If FN was prototyped, the value has been converted already
3941      in convert_arguments.  */
3942   if (!value || TYPE_ARG_TYPES (TREE_TYPE (fn)))
3943     return value;
3944
3945   type = TREE_TYPE (parm);
3946   ret = convert_for_assignment (type, value,
3947                                 ic_argpass_nonproto, fn,
3948                                 fn, argnum);
3949   if (targetm.calls.promote_prototypes (TREE_TYPE (fn))
3950       && INTEGRAL_TYPE_P (type)
3951       && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3952     ret = default_conversion (ret);
3953   return ret;
3954 }
3955 \f
3956 /* If VALUE is a compound expr all of whose expressions are constant, then
3957    return its value.  Otherwise, return error_mark_node.
3958
3959    This is for handling COMPOUND_EXPRs as initializer elements
3960    which is allowed with a warning when -pedantic is specified.  */
3961
3962 static tree
3963 valid_compound_expr_initializer (tree value, tree endtype)
3964 {
3965   if (TREE_CODE (value) == COMPOUND_EXPR)
3966     {
3967       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
3968           == error_mark_node)
3969         return error_mark_node;
3970       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
3971                                               endtype);
3972     }
3973   else if (!initializer_constant_valid_p (value, endtype))
3974     return error_mark_node;
3975   else
3976     return value;
3977 }
3978 \f
3979 /* Perform appropriate conversions on the initial value of a variable,
3980    store it in the declaration DECL,
3981    and print any error messages that are appropriate.
3982    If the init is invalid, store an ERROR_MARK.  */
3983
3984 void
3985 store_init_value (tree decl, tree init)
3986 {
3987   tree value, type;
3988
3989   /* If variable's type was invalidly declared, just ignore it.  */
3990
3991   type = TREE_TYPE (decl);
3992   if (TREE_CODE (type) == ERROR_MARK)
3993     return;
3994
3995   /* Digest the specified initializer into an expression.  */
3996
3997   value = digest_init (type, init, true, TREE_STATIC (decl));
3998
3999   /* Store the expression if valid; else report error.  */
4000
4001   if (warn_traditional && !in_system_header
4002       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
4003     warning (0, "traditional C rejects automatic aggregate initialization");
4004
4005   DECL_INITIAL (decl) = value;
4006
4007   /* ANSI wants warnings about out-of-range constant initializers.  */
4008   STRIP_TYPE_NOPS (value);
4009   constant_expression_warning (value);
4010
4011   /* Check if we need to set array size from compound literal size.  */
4012   if (TREE_CODE (type) == ARRAY_TYPE
4013       && TYPE_DOMAIN (type) == 0
4014       && value != error_mark_node)
4015     {
4016       tree inside_init = init;
4017
4018       STRIP_TYPE_NOPS (inside_init);
4019       inside_init = fold (inside_init);
4020
4021       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4022         {
4023           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4024
4025           if (TYPE_DOMAIN (TREE_TYPE (decl)))
4026             {
4027               /* For int foo[] = (int [3]){1}; we need to set array size
4028                  now since later on array initializer will be just the
4029                  brace enclosed list of the compound literal.  */
4030               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (decl));
4031               layout_type (type);
4032               layout_decl (decl, 0);
4033             }
4034         }
4035     }
4036 }
4037 \f
4038 /* Methods for storing and printing names for error messages.  */
4039
4040 /* Implement a spelling stack that allows components of a name to be pushed
4041    and popped.  Each element on the stack is this structure.  */
4042
4043 struct spelling
4044 {
4045   int kind;
4046   union
4047     {
4048       int i;
4049       const char *s;
4050     } u;
4051 };
4052
4053 #define SPELLING_STRING 1
4054 #define SPELLING_MEMBER 2
4055 #define SPELLING_BOUNDS 3
4056
4057 static struct spelling *spelling;       /* Next stack element (unused).  */
4058 static struct spelling *spelling_base;  /* Spelling stack base.  */
4059 static int spelling_size;               /* Size of the spelling stack.  */
4060
4061 /* Macros to save and restore the spelling stack around push_... functions.
4062    Alternative to SAVE_SPELLING_STACK.  */
4063
4064 #define SPELLING_DEPTH() (spelling - spelling_base)
4065 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
4066
4067 /* Push an element on the spelling stack with type KIND and assign VALUE
4068    to MEMBER.  */
4069
4070 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
4071 {                                                                       \
4072   int depth = SPELLING_DEPTH ();                                        \
4073                                                                         \
4074   if (depth >= spelling_size)                                           \
4075     {                                                                   \
4076       spelling_size += 10;                                              \
4077       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
4078                                   spelling_size);                       \
4079       RESTORE_SPELLING_DEPTH (depth);                                   \
4080     }                                                                   \
4081                                                                         \
4082   spelling->kind = (KIND);                                              \
4083   spelling->MEMBER = (VALUE);                                           \
4084   spelling++;                                                           \
4085 }
4086
4087 /* Push STRING on the stack.  Printed literally.  */
4088
4089 static void
4090 push_string (const char *string)
4091 {
4092   PUSH_SPELLING (SPELLING_STRING, string, u.s);
4093 }
4094
4095 /* Push a member name on the stack.  Printed as '.' STRING.  */
4096
4097 static void
4098 push_member_name (tree decl)
4099 {
4100   const char *const string
4101     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
4102   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
4103 }
4104
4105 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
4106
4107 static void
4108 push_array_bounds (int bounds)
4109 {
4110   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
4111 }
4112
4113 /* Compute the maximum size in bytes of the printed spelling.  */
4114
4115 static int
4116 spelling_length (void)
4117 {
4118   int size = 0;
4119   struct spelling *p;
4120
4121   for (p = spelling_base; p < spelling; p++)
4122     {
4123       if (p->kind == SPELLING_BOUNDS)
4124         size += 25;
4125       else
4126         size += strlen (p->u.s) + 1;
4127     }
4128
4129   return size;
4130 }
4131
4132 /* Print the spelling to BUFFER and return it.  */
4133
4134 static char *
4135 print_spelling (char *buffer)
4136 {
4137   char *d = buffer;
4138   struct spelling *p;
4139
4140   for (p = spelling_base; p < spelling; p++)
4141     if (p->kind == SPELLING_BOUNDS)
4142       {
4143         sprintf (d, "[%d]", p->u.i);
4144         d += strlen (d);
4145       }
4146     else
4147       {
4148         const char *s;
4149         if (p->kind == SPELLING_MEMBER)
4150           *d++ = '.';
4151         for (s = p->u.s; (*d = *s++); d++)
4152           ;
4153       }
4154   *d++ = '\0';
4155   return buffer;
4156 }
4157
4158 /* Issue an error message for a bad initializer component.
4159    MSGID identifies the message.
4160    The component name is taken from the spelling stack.  */
4161
4162 void
4163 error_init (const char *msgid)
4164 {
4165   char *ofwhat;
4166
4167   error ("%s", _(msgid));
4168   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4169   if (*ofwhat)
4170     error ("(near initialization for %qs)", ofwhat);
4171 }
4172
4173 /* Issue a pedantic warning for a bad initializer component.
4174    MSGID identifies the message.
4175    The component name is taken from the spelling stack.  */
4176
4177 void
4178 pedwarn_init (const char *msgid)
4179 {
4180   char *ofwhat;
4181
4182   pedwarn ("%s", _(msgid));
4183   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4184   if (*ofwhat)
4185     pedwarn ("(near initialization for %qs)", ofwhat);
4186 }
4187
4188 /* Issue a warning for a bad initializer component.
4189    MSGID identifies the message.
4190    The component name is taken from the spelling stack.  */
4191
4192 static void
4193 warning_init (const char *msgid)
4194 {
4195   char *ofwhat;
4196
4197   warning (0, "%s", _(msgid));
4198   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
4199   if (*ofwhat)
4200     warning (0, "(near initialization for %qs)", ofwhat);
4201 }
4202 \f
4203 /* If TYPE is an array type and EXPR is a parenthesized string
4204    constant, warn if pedantic that EXPR is being used to initialize an
4205    object of type TYPE.  */
4206
4207 void
4208 maybe_warn_string_init (tree type, struct c_expr expr)
4209 {
4210   if (pedantic
4211       && TREE_CODE (type) == ARRAY_TYPE
4212       && TREE_CODE (expr.value) == STRING_CST
4213       && expr.original_code != STRING_CST)
4214     pedwarn_init ("array initialized from parenthesized string constant");
4215 }
4216
4217 /* Digest the parser output INIT as an initializer for type TYPE.
4218    Return a C expression of type TYPE to represent the initial value.
4219
4220    If INIT is a string constant, STRICT_STRING is true if it is
4221    unparenthesized or we should not warn here for it being parenthesized.
4222    For other types of INIT, STRICT_STRING is not used.
4223
4224    REQUIRE_CONSTANT requests an error if non-constant initializers or
4225    elements are seen.  */
4226
4227 static tree
4228 digest_init (tree type, tree init, bool strict_string, int require_constant)
4229 {
4230   enum tree_code code = TREE_CODE (type);
4231   tree inside_init = init;
4232
4233   if (type == error_mark_node
4234       || init == error_mark_node
4235       || TREE_TYPE (init) == error_mark_node)
4236     return error_mark_node;
4237
4238   STRIP_TYPE_NOPS (inside_init);
4239
4240   inside_init = fold (inside_init);
4241
4242   /* Initialization of an array of chars from a string constant
4243      optionally enclosed in braces.  */
4244
4245   if (code == ARRAY_TYPE && inside_init
4246       && TREE_CODE (inside_init) == STRING_CST)
4247     {
4248       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
4249       /* Note that an array could be both an array of character type
4250          and an array of wchar_t if wchar_t is signed char or unsigned
4251          char.  */
4252       bool char_array = (typ1 == char_type_node
4253                          || typ1 == signed_char_type_node
4254                          || typ1 == unsigned_char_type_node);
4255       bool wchar_array = !!comptypes (typ1, wchar_type_node);
4256       if (char_array || wchar_array)
4257         {
4258           struct c_expr expr;
4259           bool char_string;
4260           expr.value = inside_init;
4261           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
4262           maybe_warn_string_init (type, expr);
4263
4264           char_string
4265             = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)))
4266                == char_type_node);
4267
4268           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4269                          TYPE_MAIN_VARIANT (type)))
4270             return inside_init;
4271
4272           if (!wchar_array && !char_string)
4273             {
4274               error_init ("char-array initialized from wide string");
4275               return error_mark_node;
4276             }
4277           if (char_string && !char_array)
4278             {
4279               error_init ("wchar_t-array initialized from non-wide string");
4280               return error_mark_node;
4281             }
4282
4283           TREE_TYPE (inside_init) = type;
4284           if (TYPE_DOMAIN (type) != 0
4285               && TYPE_SIZE (type) != 0
4286               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
4287               /* Subtract 1 (or sizeof (wchar_t))
4288                  because it's ok to ignore the terminating null char
4289                  that is counted in the length of the constant.  */
4290               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
4291                                        TREE_STRING_LENGTH (inside_init)
4292                                        - ((TYPE_PRECISION (typ1)
4293                                            != TYPE_PRECISION (char_type_node))
4294                                           ? (TYPE_PRECISION (wchar_type_node)
4295                                              / BITS_PER_UNIT)
4296                                           : 1)))
4297             pedwarn_init ("initializer-string for array of chars is too long");
4298
4299           return inside_init;
4300         }
4301       else if (INTEGRAL_TYPE_P (typ1))
4302         {
4303           error_init ("array of inappropriate type initialized "
4304                       "from string constant");
4305           return error_mark_node;
4306         }
4307     }
4308
4309   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
4310      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
4311      below and handle as a constructor.  */
4312   if (code == VECTOR_TYPE
4313       && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
4314       && vector_types_convertible_p (TREE_TYPE (inside_init), type)
4315       && TREE_CONSTANT (inside_init))
4316     {
4317       if (TREE_CODE (inside_init) == VECTOR_CST
4318           && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4319                         TYPE_MAIN_VARIANT (type)))
4320         return inside_init;
4321
4322       if (TREE_CODE (inside_init) == CONSTRUCTOR)
4323         {
4324           tree link;
4325
4326           /* Iterate through elements and check if all constructor
4327              elements are *_CSTs.  */
4328           for (link = CONSTRUCTOR_ELTS (inside_init);
4329                link;
4330                link = TREE_CHAIN (link))
4331             if (! CONSTANT_CLASS_P (TREE_VALUE (link)))
4332               break;
4333
4334           if (link == NULL)
4335             return build_vector (type, CONSTRUCTOR_ELTS (inside_init));
4336         }
4337     }
4338
4339   /* Any type can be initialized
4340      from an expression of the same type, optionally with braces.  */
4341
4342   if (inside_init && TREE_TYPE (inside_init) != 0
4343       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
4344                      TYPE_MAIN_VARIANT (type))
4345           || (code == ARRAY_TYPE
4346               && comptypes (TREE_TYPE (inside_init), type))
4347           || (code == VECTOR_TYPE
4348               && comptypes (TREE_TYPE (inside_init), type))
4349           || (code == POINTER_TYPE
4350               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
4351               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
4352                             TREE_TYPE (type)))))
4353     {
4354       if (code == POINTER_TYPE)
4355         {
4356           if (TREE_CODE (inside_init) == STRING_CST
4357               || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4358             inside_init = default_function_array_conversion (inside_init);
4359
4360           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
4361             {
4362               error_init ("invalid use of non-lvalue array");
4363               return error_mark_node;
4364             }
4365          }
4366
4367       if (code == VECTOR_TYPE)
4368         /* Although the types are compatible, we may require a
4369            conversion.  */
4370         inside_init = convert (type, inside_init);
4371
4372       if (require_constant && !flag_isoc99
4373           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
4374         {
4375           /* As an extension, allow initializing objects with static storage
4376              duration with compound literals (which are then treated just as
4377              the brace enclosed list they contain).  */
4378           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
4379           inside_init = DECL_INITIAL (decl);
4380         }
4381
4382       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
4383           && TREE_CODE (inside_init) != CONSTRUCTOR)
4384         {
4385           error_init ("array initialized from non-constant array expression");
4386           return error_mark_node;
4387         }
4388
4389       if (optimize && TREE_CODE (inside_init) == VAR_DECL)
4390         inside_init = decl_constant_value_for_broken_optimization (inside_init);
4391
4392       /* Compound expressions can only occur here if -pedantic or
4393          -pedantic-errors is specified.  In the later case, we always want
4394          an error.  In the former case, we simply want a warning.  */
4395       if (require_constant && pedantic
4396           && TREE_CODE (inside_init) == COMPOUND_EXPR)
4397         {
4398           inside_init
4399             = valid_compound_expr_initializer (inside_init,
4400                                                TREE_TYPE (inside_init));
4401           if (inside_init == error_mark_node)
4402             error_init ("initializer element is not constant");
4403           else
4404             pedwarn_init ("initializer element is not constant");
4405           if (flag_pedantic_errors)
4406             inside_init = error_mark_node;
4407         }
4408       else if (require_constant
4409                && !initializer_constant_valid_p (inside_init,
4410                                                  TREE_TYPE (inside_init)))
4411         {
4412           error_init ("initializer element is not constant");
4413           inside_init = error_mark_node;
4414         }
4415
4416       return inside_init;
4417     }
4418
4419   /* Handle scalar types, including conversions.  */
4420
4421   if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE
4422       || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE
4423       || code == VECTOR_TYPE)
4424     {
4425       if (TREE_CODE (init) == STRING_CST
4426           || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)
4427         init = default_function_array_conversion (init);
4428       inside_init
4429         = convert_for_assignment (type, init, ic_init,
4430                                   NULL_TREE, NULL_TREE, 0);
4431
4432       /* Check to see if we have already given an error message.  */
4433       if (inside_init == error_mark_node)
4434         ;
4435       else if (require_constant && !TREE_CONSTANT (inside_init))
4436         {
4437           error_init ("initializer element is not constant");
4438           inside_init = error_mark_node;
4439         }
4440       else if (require_constant
4441                && !initializer_constant_valid_p (inside_init,
4442                                                  TREE_TYPE (inside_init)))
4443         {
4444           error_init ("initializer element is not computable at load time");
4445           inside_init = error_mark_node;
4446         }
4447
4448       return inside_init;
4449     }
4450
4451   /* Come here only for records and arrays.  */
4452
4453   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4454     {
4455       error_init ("variable-sized object may not be initialized");
4456       return error_mark_node;
4457     }
4458
4459   error_init ("invalid initializer");
4460   return error_mark_node;
4461 }
4462 \f
4463 /* Handle initializers that use braces.  */
4464
4465 /* Type of object we are accumulating a constructor for.
4466    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
4467 static tree constructor_type;
4468
4469 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
4470    left to fill.  */
4471 static tree constructor_fields;
4472
4473 /* For an ARRAY_TYPE, this is the specified index
4474    at which to store the next element we get.  */
4475 static tree constructor_index;
4476
4477 /* For an ARRAY_TYPE, this is the maximum index.  */
4478 static tree constructor_max_index;
4479
4480 /* For a RECORD_TYPE, this is the first field not yet written out.  */
4481 static tree constructor_unfilled_fields;
4482
4483 /* For an ARRAY_TYPE, this is the index of the first element
4484    not yet written out.  */
4485 static tree constructor_unfilled_index;
4486
4487 /* In a RECORD_TYPE, the byte index of the next consecutive field.
4488    This is so we can generate gaps between fields, when appropriate.  */
4489 static tree constructor_bit_index;
4490
4491 /* If we are saving up the elements rather than allocating them,
4492    this is the list of elements so far (in reverse order,
4493    most recent first).  */
4494 static tree constructor_elements;
4495
4496 /* 1 if constructor should be incrementally stored into a constructor chain,
4497    0 if all the elements should be kept in AVL tree.  */
4498 static int constructor_incremental;
4499
4500 /* 1 if so far this constructor's elements are all compile-time constants.  */
4501 static int constructor_constant;
4502
4503 /* 1 if so far this constructor's elements are all valid address constants.  */
4504 static int constructor_simple;
4505
4506 /* 1 if this constructor is erroneous so far.  */
4507 static int constructor_erroneous;
4508
4509 /* Structure for managing pending initializer elements, organized as an
4510    AVL tree.  */
4511
4512 struct init_node
4513 {
4514   struct init_node *left, *right;
4515   struct init_node *parent;
4516   int balance;
4517   tree purpose;
4518   tree value;
4519 };
4520
4521 /* Tree of pending elements at this constructor level.
4522    These are elements encountered out of order
4523    which belong at places we haven't reached yet in actually
4524    writing the output.
4525    Will never hold tree nodes across GC runs.  */
4526 static struct init_node *constructor_pending_elts;
4527
4528 /* The SPELLING_DEPTH of this constructor.  */
4529 static int constructor_depth;
4530
4531 /* DECL node for which an initializer is being read.
4532    0 means we are reading a constructor expression
4533    such as (struct foo) {...}.  */
4534 static tree constructor_decl;
4535
4536 /* Nonzero if this is an initializer for a top-level decl.  */
4537 static int constructor_top_level;
4538
4539 /* Nonzero if there were any member designators in this initializer.  */
4540 static int constructor_designated;
4541
4542 /* Nesting depth of designator list.  */
4543 static int designator_depth;
4544
4545 /* Nonzero if there were diagnosed errors in this designator list.  */
4546 static int designator_errorneous;
4547
4548 \f
4549 /* This stack has a level for each implicit or explicit level of
4550    structuring in the initializer, including the outermost one.  It
4551    saves the values of most of the variables above.  */
4552
4553 struct constructor_range_stack;
4554
4555 struct constructor_stack
4556 {
4557   struct constructor_stack *next;
4558   tree type;
4559   tree fields;
4560   tree index;
4561   tree max_index;
4562   tree unfilled_index;
4563   tree unfilled_fields;
4564   tree bit_index;
4565   tree elements;
4566   struct init_node *pending_elts;
4567   int offset;
4568   int depth;
4569   /* If value nonzero, this value should replace the entire
4570      constructor at this level.  */
4571   struct c_expr replacement_value;
4572   struct constructor_range_stack *range_stack;
4573   char constant;
4574   char simple;
4575   char implicit;
4576   char erroneous;
4577   char outer;
4578   char incremental;
4579   char designated;
4580 };
4581
4582 static struct constructor_stack *constructor_stack;
4583
4584 /* This stack represents designators from some range designator up to
4585    the last designator in the list.  */
4586
4587 struct constructor_range_stack
4588 {
4589   struct constructor_range_stack *next, *prev;
4590   struct constructor_stack *stack;
4591   tree range_start;
4592   tree index;
4593   tree range_end;
4594   tree fields;
4595 };
4596
4597 static struct constructor_range_stack *constructor_range_stack;
4598
4599 /* This stack records separate initializers that are nested.
4600    Nested initializers can't happen in ANSI C, but GNU C allows them
4601    in cases like { ... (struct foo) { ... } ... }.  */
4602
4603 struct initializer_stack
4604 {
4605   struct initializer_stack *next;
4606   tree decl;
4607   struct constructor_stack *constructor_stack;
4608   struct constructor_range_stack *constructor_range_stack;
4609   tree elements;
4610   struct spelling *spelling;
4611   struct spelling *spelling_base;
4612   int spelling_size;
4613   char top_level;
4614   char require_constant_value;
4615   char require_constant_elements;
4616 };
4617
4618 static struct initializer_stack *initializer_stack;
4619 \f
4620 /* Prepare to parse and output the initializer for variable DECL.  */
4621
4622 void
4623 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
4624 {
4625   const char *locus;
4626   struct initializer_stack *p = xmalloc (sizeof (struct initializer_stack));
4627
4628   p->decl = constructor_decl;
4629   p->require_constant_value = require_constant_value;
4630   p->require_constant_elements = require_constant_elements;
4631   p->constructor_stack = constructor_stack;
4632   p->constructor_range_stack = constructor_range_stack;
4633   p->elements = constructor_elements;
4634   p->spelling = spelling;
4635   p->spelling_base = spelling_base;
4636   p->spelling_size = spelling_size;
4637   p->top_level = constructor_top_level;
4638   p->next = initializer_stack;
4639   initializer_stack = p;
4640
4641   constructor_decl = decl;
4642   constructor_designated = 0;
4643   constructor_top_level = top_level;
4644
4645   if (decl != 0 && decl != error_mark_node)
4646     {
4647       require_constant_value = TREE_STATIC (decl);
4648       require_constant_elements
4649         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
4650            /* For a scalar, you can always use any value to initialize,
4651               even within braces.  */
4652            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
4653                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
4654                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
4655                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
4656       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
4657     }
4658   else
4659     {
4660       require_constant_value = 0;
4661       require_constant_elements = 0;
4662       locus = "(anonymous)";
4663     }
4664
4665   constructor_stack = 0;
4666   constructor_range_stack = 0;
4667
4668   missing_braces_mentioned = 0;
4669
4670   spelling_base = 0;
4671   spelling_size = 0;
4672   RESTORE_SPELLING_DEPTH (0);
4673
4674   if (locus)
4675     push_string (locus);
4676 }
4677
4678 void
4679 finish_init (void)
4680 {
4681   struct initializer_stack *p = initializer_stack;
4682
4683   /* Free the whole constructor stack of this initializer.  */
4684   while (constructor_stack)
4685     {
4686       struct constructor_stack *q = constructor_stack;
4687       constructor_stack = q->next;
4688       free (q);
4689     }
4690
4691   gcc_assert (!constructor_range_stack);
4692
4693   /* Pop back to the data of the outer initializer (if any).  */
4694   free (spelling_base);
4695
4696   constructor_decl = p->decl;
4697   require_constant_value = p->require_constant_value;
4698   require_constant_elements = p->require_constant_elements;
4699   constructor_stack = p->constructor_stack;
4700   constructor_range_stack = p->constructor_range_stack;
4701   constructor_elements = p->elements;
4702   spelling = p->spelling;
4703   spelling_base = p->spelling_base;
4704   spelling_size = p->spelling_size;
4705   constructor_top_level = p->top_level;
4706   initializer_stack = p->next;
4707   free (p);
4708 }
4709 \f
4710 /* Call here when we see the initializer is surrounded by braces.
4711    This is instead of a call to push_init_level;
4712    it is matched by a call to pop_init_level.
4713
4714    TYPE is the type to initialize, for a constructor expression.
4715    For an initializer for a decl, TYPE is zero.  */
4716
4717 void
4718 really_start_incremental_init (tree type)
4719 {
4720   struct constructor_stack *p = XNEW (struct constructor_stack);
4721
4722   if (type == 0)
4723     type = TREE_TYPE (constructor_decl);
4724
4725   if (targetm.vector_opaque_p (type))
4726     error ("opaque vector types cannot be initialized");
4727
4728   p->type = constructor_type;
4729   p->fields = constructor_fields;
4730   p->index = constructor_index;
4731   p->max_index = constructor_max_index;
4732   p->unfilled_index = constructor_unfilled_index;
4733   p->unfilled_fields = constructor_unfilled_fields;
4734   p->bit_index = constructor_bit_index;
4735   p->elements = constructor_elements;
4736   p->constant = constructor_constant;
4737   p->simple = constructor_simple;
4738   p->erroneous = constructor_erroneous;
4739   p->pending_elts = constructor_pending_elts;
4740   p->depth = constructor_depth;
4741   p->replacement_value.value = 0;
4742   p->replacement_value.original_code = ERROR_MARK;
4743   p->implicit = 0;
4744   p->range_stack = 0;
4745   p->outer = 0;
4746   p->incremental = constructor_incremental;
4747   p->designated = constructor_designated;
4748   p->next = 0;
4749   constructor_stack = p;
4750
4751   constructor_constant = 1;
4752   constructor_simple = 1;
4753   constructor_depth = SPELLING_DEPTH ();
4754   constructor_elements = 0;
4755   constructor_pending_elts = 0;
4756   constructor_type = type;
4757   constructor_incremental = 1;
4758   constructor_designated = 0;
4759   designator_depth = 0;
4760   designator_errorneous = 0;
4761
4762   if (TREE_CODE (constructor_type) == RECORD_TYPE
4763       || TREE_CODE (constructor_type) == UNION_TYPE)
4764     {
4765       constructor_fields = TYPE_FIELDS (constructor_type);
4766       /* Skip any nameless bit fields at the beginning.  */
4767       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4768              && DECL_NAME (constructor_fields) == 0)
4769         constructor_fields = TREE_CHAIN (constructor_fields);
4770
4771       constructor_unfilled_fields = constructor_fields;
4772       constructor_bit_index = bitsize_zero_node;
4773     }
4774   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4775     {
4776       if (TYPE_DOMAIN (constructor_type))
4777         {
4778           constructor_max_index
4779             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4780
4781           /* Detect non-empty initializations of zero-length arrays.  */
4782           if (constructor_max_index == NULL_TREE
4783               && TYPE_SIZE (constructor_type))
4784             constructor_max_index = build_int_cst (NULL_TREE, -1);
4785
4786           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4787              to initialize VLAs will cause a proper error; avoid tree
4788              checking errors as well by setting a safe value.  */
4789           if (constructor_max_index
4790               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4791             constructor_max_index = build_int_cst (NULL_TREE, -1);
4792
4793           constructor_index
4794             = convert (bitsizetype,
4795                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4796         }
4797       else
4798         {
4799           constructor_index = bitsize_zero_node;
4800           constructor_max_index = NULL_TREE;
4801         }
4802
4803       constructor_unfilled_index = constructor_index;
4804     }
4805   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4806     {
4807       /* Vectors are like simple fixed-size arrays.  */
4808       constructor_max_index =
4809         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4810       constructor_index = convert (bitsizetype, bitsize_zero_node);
4811       constructor_unfilled_index = constructor_index;
4812     }
4813   else
4814     {
4815       /* Handle the case of int x = {5}; */
4816       constructor_fields = constructor_type;
4817       constructor_unfilled_fields = constructor_type;
4818     }
4819 }
4820 \f
4821 /* Push down into a subobject, for initialization.
4822    If this is for an explicit set of braces, IMPLICIT is 0.
4823    If it is because the next element belongs at a lower level,
4824    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
4825
4826 void
4827 push_init_level (int implicit)
4828 {
4829   struct constructor_stack *p;
4830   tree value = NULL_TREE;
4831
4832   /* If we've exhausted any levels that didn't have braces,
4833      pop them now.  If implicit == 1, this will have been done in
4834      process_init_element; do not repeat it here because in the case
4835      of excess initializers for an empty aggregate this leads to an
4836      infinite cycle of popping a level and immediately recreating
4837      it.  */
4838   if (implicit != 1)
4839     {
4840       while (constructor_stack->implicit)
4841         {
4842           if ((TREE_CODE (constructor_type) == RECORD_TYPE
4843                || TREE_CODE (constructor_type) == UNION_TYPE)
4844               && constructor_fields == 0)
4845             process_init_element (pop_init_level (1));
4846           else if (TREE_CODE (constructor_type) == ARRAY_TYPE
4847                    && constructor_max_index
4848                    && tree_int_cst_lt (constructor_max_index,
4849                                        constructor_index))
4850             process_init_element (pop_init_level (1));
4851           else
4852             break;
4853         }
4854     }
4855
4856   /* Unless this is an explicit brace, we need to preserve previous
4857      content if any.  */
4858   if (implicit)
4859     {
4860       if ((TREE_CODE (constructor_type) == RECORD_TYPE
4861            || TREE_CODE (constructor_type) == UNION_TYPE)
4862           && constructor_fields)
4863         value = find_init_member (constructor_fields);
4864       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4865         value = find_init_member (constructor_index);
4866     }
4867
4868   p = XNEW (struct constructor_stack);
4869   p->type = constructor_type;
4870   p->fields = constructor_fields;
4871   p->index = constructor_index;
4872   p->max_index = constructor_max_index;
4873   p->unfilled_index = constructor_unfilled_index;
4874   p->unfilled_fields = constructor_unfilled_fields;
4875   p->bit_index = constructor_bit_index;
4876   p->elements = constructor_elements;
4877   p->constant = constructor_constant;
4878   p->simple = constructor_simple;
4879   p->erroneous = constructor_erroneous;
4880   p->pending_elts = constructor_pending_elts;
4881   p->depth = constructor_depth;
4882   p->replacement_value.value = 0;
4883   p->replacement_value.original_code = ERROR_MARK;
4884   p->implicit = implicit;
4885   p->outer = 0;
4886   p->incremental = constructor_incremental;
4887   p->designated = constructor_designated;
4888   p->next = constructor_stack;
4889   p->range_stack = 0;
4890   constructor_stack = p;
4891
4892   constructor_constant = 1;
4893   constructor_simple = 1;
4894   constructor_depth = SPELLING_DEPTH ();
4895   constructor_elements = 0;
4896   constructor_incremental = 1;
4897   constructor_designated = 0;
4898   constructor_pending_elts = 0;
4899   if (!implicit)
4900     {
4901       p->range_stack = constructor_range_stack;
4902       constructor_range_stack = 0;
4903       designator_depth = 0;
4904       designator_errorneous = 0;
4905     }
4906
4907   /* Don't die if an entire brace-pair level is superfluous
4908      in the containing level.  */
4909   if (constructor_type == 0)
4910     ;
4911   else if (TREE_CODE (constructor_type) == RECORD_TYPE
4912            || TREE_CODE (constructor_type) == UNION_TYPE)
4913     {
4914       /* Don't die if there are extra init elts at the end.  */
4915       if (constructor_fields == 0)
4916         constructor_type = 0;
4917       else
4918         {
4919           constructor_type = TREE_TYPE (constructor_fields);
4920           push_member_name (constructor_fields);
4921           constructor_depth++;
4922         }
4923     }
4924   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4925     {
4926       constructor_type = TREE_TYPE (constructor_type);
4927       push_array_bounds (tree_low_cst (constructor_index, 0));
4928       constructor_depth++;
4929     }
4930
4931   if (constructor_type == 0)
4932     {
4933       error_init ("extra brace group at end of initializer");
4934       constructor_fields = 0;
4935       constructor_unfilled_fields = 0;
4936       return;
4937     }
4938
4939   if (value && TREE_CODE (value) == CONSTRUCTOR)
4940     {
4941       constructor_constant = TREE_CONSTANT (value);
4942       constructor_simple = TREE_STATIC (value);
4943       constructor_elements = CONSTRUCTOR_ELTS (value);
4944       if (constructor_elements
4945           && (TREE_CODE (constructor_type) == RECORD_TYPE
4946               || TREE_CODE (constructor_type) == ARRAY_TYPE))
4947         set_nonincremental_init ();
4948     }
4949
4950   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
4951     {
4952       missing_braces_mentioned = 1;
4953       warning_init ("missing braces around initializer");
4954     }
4955
4956   if (TREE_CODE (constructor_type) == RECORD_TYPE
4957            || TREE_CODE (constructor_type) == UNION_TYPE)
4958     {
4959       constructor_fields = TYPE_FIELDS (constructor_type);
4960       /* Skip any nameless bit fields at the beginning.  */
4961       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
4962              && DECL_NAME (constructor_fields) == 0)
4963         constructor_fields = TREE_CHAIN (constructor_fields);
4964
4965       constructor_unfilled_fields = constructor_fields;
4966       constructor_bit_index = bitsize_zero_node;
4967     }
4968   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
4969     {
4970       /* Vectors are like simple fixed-size arrays.  */
4971       constructor_max_index =
4972         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
4973       constructor_index = convert (bitsizetype, integer_zero_node);
4974       constructor_unfilled_index = constructor_index;
4975     }
4976   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
4977     {
4978       if (TYPE_DOMAIN (constructor_type))
4979         {
4980           constructor_max_index
4981             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
4982
4983           /* Detect non-empty initializations of zero-length arrays.  */
4984           if (constructor_max_index == NULL_TREE
4985               && TYPE_SIZE (constructor_type))
4986             constructor_max_index = build_int_cst (NULL_TREE, -1);
4987
4988           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
4989              to initialize VLAs will cause a proper error; avoid tree
4990              checking errors as well by setting a safe value.  */
4991           if (constructor_max_index
4992               && TREE_CODE (constructor_max_index) != INTEGER_CST)
4993             constructor_max_index = build_int_cst (NULL_TREE, -1);
4994
4995           constructor_index
4996             = convert (bitsizetype,
4997                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
4998         }
4999       else
5000         constructor_index = bitsize_zero_node;
5001
5002       constructor_unfilled_index = constructor_index;
5003       if (value && TREE_CODE (value) == STRING_CST)
5004         {
5005           /* We need to split the char/wchar array into individual
5006              characters, so that we don't have to special case it
5007              everywhere.  */
5008           set_nonincremental_init_from_string (value);
5009         }
5010     }
5011   else
5012     {
5013       if (constructor_type != error_mark_node)
5014         warning_init ("braces around scalar initializer");
5015       constructor_fields = constructor_type;
5016       constructor_unfilled_fields = constructor_type;
5017     }
5018 }
5019
5020 /* At the end of an implicit or explicit brace level,
5021    finish up that level of constructor.  If a single expression
5022    with redundant braces initialized that level, return the
5023    c_expr structure for that expression.  Otherwise, the original_code
5024    element is set to ERROR_MARK.
5025    If we were outputting the elements as they are read, return 0 as the value
5026    from inner levels (process_init_element ignores that),
5027    but return error_mark_node as the value from the outermost level
5028    (that's what we want to put in DECL_INITIAL).
5029    Otherwise, return a CONSTRUCTOR expression as the value.  */
5030
5031 struct c_expr
5032 pop_init_level (int implicit)
5033 {
5034   struct constructor_stack *p;
5035   struct c_expr ret;
5036   ret.value = 0;
5037   ret.original_code = ERROR_MARK;
5038
5039   if (implicit == 0)
5040     {
5041       /* When we come to an explicit close brace,
5042          pop any inner levels that didn't have explicit braces.  */
5043       while (constructor_stack->implicit)
5044         process_init_element (pop_init_level (1));
5045
5046       gcc_assert (!constructor_range_stack);
5047     }
5048
5049   /* Now output all pending elements.  */
5050   constructor_incremental = 1;
5051   output_pending_init_elements (1);
5052
5053   p = constructor_stack;
5054
5055   /* Error for initializing a flexible array member, or a zero-length
5056      array member in an inappropriate context.  */
5057   if (constructor_type && constructor_fields
5058       && TREE_CODE (constructor_type) == ARRAY_TYPE
5059       && TYPE_DOMAIN (constructor_type)
5060       && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
5061     {
5062       /* Silently discard empty initializations.  The parser will
5063          already have pedwarned for empty brackets.  */
5064       if (integer_zerop (constructor_unfilled_index))
5065         constructor_type = NULL_TREE;
5066       else
5067         {
5068           gcc_assert (!TYPE_SIZE (constructor_type));
5069
5070           if (constructor_depth > 2)
5071             error_init ("initialization of flexible array member in a nested context");
5072           else if (pedantic)
5073             pedwarn_init ("initialization of a flexible array member");
5074
5075           /* We have already issued an error message for the existence
5076              of a flexible array member not at the end of the structure.
5077              Discard the initializer so that we do not die later.  */
5078           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
5079             constructor_type = NULL_TREE;
5080         }
5081     }
5082
5083   /* Warn when some struct elements are implicitly initialized to zero.  */
5084   if (warn_missing_field_initializers
5085       && constructor_type
5086       && TREE_CODE (constructor_type) == RECORD_TYPE
5087       && constructor_unfilled_fields)
5088     {
5089         /* Do not warn for flexible array members or zero-length arrays.  */
5090         while (constructor_unfilled_fields
5091                && (!DECL_SIZE (constructor_unfilled_fields)
5092                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
5093           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5094
5095         /* Do not warn if this level of the initializer uses member
5096            designators; it is likely to be deliberate.  */
5097         if (constructor_unfilled_fields && !constructor_designated)
5098           {
5099             push_member_name (constructor_unfilled_fields);
5100             warning_init ("missing initializer");
5101             RESTORE_SPELLING_DEPTH (constructor_depth);
5102           }
5103     }
5104
5105   /* Pad out the end of the structure.  */
5106   if (p->replacement_value.value)
5107     /* If this closes a superfluous brace pair,
5108        just pass out the element between them.  */
5109     ret = p->replacement_value;
5110   else if (constructor_type == 0)
5111     ;
5112   else if (TREE_CODE (constructor_type) != RECORD_TYPE
5113            && TREE_CODE (constructor_type) != UNION_TYPE
5114            && TREE_CODE (constructor_type) != ARRAY_TYPE
5115            && TREE_CODE (constructor_type) != VECTOR_TYPE)
5116     {
5117       /* A nonincremental scalar initializer--just return
5118          the element, after verifying there is just one.  */
5119       if (constructor_elements == 0)
5120         {
5121           if (!constructor_erroneous)
5122             error_init ("empty scalar initializer");
5123           ret.value = error_mark_node;
5124         }
5125       else if (TREE_CHAIN (constructor_elements) != 0)
5126         {
5127           error_init ("extra elements in scalar initializer");
5128           ret.value = TREE_VALUE (constructor_elements);
5129         }
5130       else
5131         ret.value = TREE_VALUE (constructor_elements);
5132     }
5133   else
5134     {
5135       if (constructor_erroneous)
5136         ret.value = error_mark_node;
5137       else
5138         {
5139           ret.value = build_constructor (constructor_type,
5140                                          nreverse (constructor_elements));
5141           if (constructor_constant)
5142             TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1;
5143           if (constructor_constant && constructor_simple)
5144             TREE_STATIC (ret.value) = 1;
5145         }
5146     }
5147
5148   constructor_type = p->type;
5149   constructor_fields = p->fields;
5150   constructor_index = p->index;
5151   constructor_max_index = p->max_index;
5152   constructor_unfilled_index = p->unfilled_index;
5153   constructor_unfilled_fields = p->unfilled_fields;
5154   constructor_bit_index = p->bit_index;
5155   constructor_elements = p->elements;
5156   constructor_constant = p->constant;
5157   constructor_simple = p->simple;
5158   constructor_erroneous = p->erroneous;
5159   constructor_incremental = p->incremental;
5160   constructor_designated = p->designated;
5161   constructor_pending_elts = p->pending_elts;
5162   constructor_depth = p->depth;
5163   if (!p->implicit)
5164     constructor_range_stack = p->range_stack;
5165   RESTORE_SPELLING_DEPTH (constructor_depth);
5166
5167   constructor_stack = p->next;
5168   free (p);
5169
5170   if (ret.value == 0)
5171     {
5172       if (constructor_stack == 0)
5173         {
5174           ret.value = error_mark_node;
5175           return ret;
5176         }
5177       return ret;
5178     }
5179   return ret;
5180 }
5181
5182 /* Common handling for both array range and field name designators.
5183    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
5184
5185 static int
5186 set_designator (int array)
5187 {
5188   tree subtype;
5189   enum tree_code subcode;
5190
5191   /* Don't die if an entire brace-pair level is superfluous
5192      in the containing level.  */
5193   if (constructor_type == 0)
5194     return 1;
5195
5196   /* If there were errors in this designator list already, bail out
5197      silently.  */
5198   if (designator_errorneous)
5199     return 1;
5200
5201   if (!designator_depth)
5202     {
5203       gcc_assert (!constructor_range_stack);
5204
5205       /* Designator list starts at the level of closest explicit
5206          braces.  */
5207       while (constructor_stack->implicit)
5208         process_init_element (pop_init_level (1));
5209       constructor_designated = 1;
5210       return 0;
5211     }
5212
5213   switch (TREE_CODE (constructor_type))
5214     {
5215     case  RECORD_TYPE:
5216     case  UNION_TYPE:
5217       subtype = TREE_TYPE (constructor_fields);
5218       if (subtype != error_mark_node)
5219         subtype = TYPE_MAIN_VARIANT (subtype);
5220       break;
5221     case ARRAY_TYPE:
5222       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
5223       break;
5224     default:
5225       gcc_unreachable ();
5226     }
5227
5228   subcode = TREE_CODE (subtype);
5229   if (array && subcode != ARRAY_TYPE)
5230     {
5231       error_init ("array index in non-array initializer");
5232       return 1;
5233     }
5234   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
5235     {
5236       error_init ("field name not in record or union initializer");
5237       return 1;
5238     }
5239
5240   constructor_designated = 1;
5241   push_init_level (2);
5242   return 0;
5243 }
5244
5245 /* If there are range designators in designator list, push a new designator
5246    to constructor_range_stack.  RANGE_END is end of such stack range or
5247    NULL_TREE if there is no range designator at this level.  */
5248
5249 static void
5250 push_range_stack (tree range_end)
5251 {
5252   struct constructor_range_stack *p;
5253
5254   p = GGC_NEW (struct constructor_range_stack);
5255   p->prev = constructor_range_stack;
5256   p->next = 0;
5257   p->fields = constructor_fields;
5258   p->range_start = constructor_index;
5259   p->index = constructor_index;
5260   p->stack = constructor_stack;
5261   p->range_end = range_end;
5262   if (constructor_range_stack)
5263     constructor_range_stack->next = p;
5264   constructor_range_stack = p;
5265 }
5266
5267 /* Within an array initializer, specify the next index to be initialized.
5268    FIRST is that index.  If LAST is nonzero, then initialize a range
5269    of indices, running from FIRST through LAST.  */
5270
5271 void
5272 set_init_index (tree first, tree last)
5273 {
5274   if (set_designator (1))
5275     return;
5276
5277   designator_errorneous = 1;
5278
5279   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
5280       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
5281     {
5282       error_init ("array index in initializer not of integer type");
5283       return;
5284     }
5285
5286   if (TREE_CODE (first) != INTEGER_CST)
5287     error_init ("nonconstant array index in initializer");
5288   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
5289     error_init ("nonconstant array index in initializer");
5290   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
5291     error_init ("array index in non-array initializer");
5292   else if (tree_int_cst_sgn (first) == -1)
5293     error_init ("array index in initializer exceeds array bounds");
5294   else if (constructor_max_index
5295            && tree_int_cst_lt (constructor_max_index, first))
5296     error_init ("array index in initializer exceeds array bounds");
5297   else
5298     {
5299       constructor_index = convert (bitsizetype, first);
5300
5301       if (last)
5302         {
5303           if (tree_int_cst_equal (first, last))
5304             last = 0;
5305           else if (tree_int_cst_lt (last, first))
5306             {
5307               error_init ("empty index range in initializer");
5308               last = 0;
5309             }
5310           else
5311             {
5312               last = convert (bitsizetype, last);
5313               if (constructor_max_index != 0
5314                   && tree_int_cst_lt (constructor_max_index, last))
5315                 {
5316                   error_init ("array index range in initializer exceeds array bounds");
5317                   last = 0;
5318                 }
5319             }
5320         }
5321
5322       designator_depth++;
5323       designator_errorneous = 0;
5324       if (constructor_range_stack || last)
5325         push_range_stack (last);
5326     }
5327 }
5328
5329 /* Within a struct initializer, specify the next field to be initialized.  */
5330
5331 void
5332 set_init_label (tree fieldname)
5333 {
5334   tree tail;
5335
5336   if (set_designator (0))
5337     return;
5338
5339   designator_errorneous = 1;
5340
5341   if (TREE_CODE (constructor_type) != RECORD_TYPE
5342       && TREE_CODE (constructor_type) != UNION_TYPE)
5343     {
5344       error_init ("field name not in record or union initializer");
5345       return;
5346     }
5347
5348   for (tail = TYPE_FIELDS (constructor_type); tail;
5349        tail = TREE_CHAIN (tail))
5350     {
5351       if (DECL_NAME (tail) == fieldname)
5352         break;
5353     }
5354
5355   if (tail == 0)
5356     error ("unknown field %qE specified in initializer", fieldname);
5357   else
5358     {
5359       constructor_fields = tail;
5360       designator_depth++;
5361       designator_errorneous = 0;
5362       if (constructor_range_stack)
5363         push_range_stack (NULL_TREE);
5364     }
5365 }
5366 \f
5367 /* Add a new initializer to the tree of pending initializers.  PURPOSE
5368    identifies the initializer, either array index or field in a structure.
5369    VALUE is the value of that index or field.  */
5370
5371 static void
5372 add_pending_init (tree purpose, tree value)
5373 {
5374   struct init_node *p, **q, *r;
5375
5376   q = &constructor_pending_elts;
5377   p = 0;
5378
5379   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5380     {
5381       while (*q != 0)
5382         {
5383           p = *q;
5384           if (tree_int_cst_lt (purpose, p->purpose))
5385             q = &p->left;
5386           else if (tree_int_cst_lt (p->purpose, purpose))
5387             q = &p->right;
5388           else
5389             {
5390               if (TREE_SIDE_EFFECTS (p->value))
5391                 warning_init ("initialized field with side-effects overwritten");
5392               p->value = value;
5393               return;
5394             }
5395         }
5396     }
5397   else
5398     {
5399       tree bitpos;
5400
5401       bitpos = bit_position (purpose);
5402       while (*q != NULL)
5403         {
5404           p = *q;
5405           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5406             q = &p->left;
5407           else if (p->purpose != purpose)
5408             q = &p->right;
5409           else
5410             {
5411               if (TREE_SIDE_EFFECTS (p->value))
5412                 warning_init ("initialized field with side-effects overwritten");
5413               p->value = value;
5414               return;
5415             }
5416         }
5417     }
5418
5419   r = GGC_NEW (struct init_node);
5420   r->purpose = purpose;
5421   r->value = value;
5422
5423   *q = r;
5424   r->parent = p;
5425   r->left = 0;
5426   r->right = 0;
5427   r->balance = 0;
5428
5429   while (p)
5430     {
5431       struct init_node *s;
5432
5433       if (r == p->left)
5434         {
5435           if (p->balance == 0)
5436             p->balance = -1;
5437           else if (p->balance < 0)
5438             {
5439               if (r->balance < 0)
5440                 {
5441                   /* L rotation.  */
5442                   p->left = r->right;
5443                   if (p->left)
5444                     p->left->parent = p;
5445                   r->right = p;
5446
5447                   p->balance = 0;
5448                   r->balance = 0;
5449
5450                   s = p->parent;
5451                   p->parent = r;
5452                   r->parent = s;
5453                   if (s)
5454                     {
5455                       if (s->left == p)
5456                         s->left = r;
5457                       else
5458                         s->right = r;
5459                     }
5460                   else
5461                     constructor_pending_elts = r;
5462                 }
5463               else
5464                 {
5465                   /* LR rotation.  */
5466                   struct init_node *t = r->right;
5467
5468                   r->right = t->left;
5469                   if (r->right)
5470                     r->right->parent = r;
5471                   t->left = r;
5472
5473                   p->left = t->right;
5474                   if (p->left)
5475                     p->left->parent = p;
5476                   t->right = p;
5477
5478                   p->balance = t->balance < 0;
5479                   r->balance = -(t->balance > 0);
5480                   t->balance = 0;
5481
5482                   s = p->parent;
5483                   p->parent = t;
5484                   r->parent = t;
5485                   t->parent = s;
5486                   if (s)
5487                     {
5488                       if (s->left == p)
5489                         s->left = t;
5490                       else
5491                         s->right = t;
5492                     }
5493                   else
5494                     constructor_pending_elts = t;
5495                 }
5496               break;
5497             }
5498           else
5499             {
5500               /* p->balance == +1; growth of left side balances the node.  */
5501               p->balance = 0;
5502               break;
5503             }
5504         }
5505       else /* r == p->right */
5506         {
5507           if (p->balance == 0)
5508             /* Growth propagation from right side.  */
5509             p->balance++;
5510           else if (p->balance > 0)
5511             {
5512               if (r->balance > 0)
5513                 {
5514                   /* R rotation.  */
5515                   p->right = r->left;
5516                   if (p->right)
5517                     p->right->parent = p;
5518                   r->left = p;
5519
5520                   p->balance = 0;
5521                   r->balance = 0;
5522
5523                   s = p->parent;
5524                   p->parent = r;
5525                   r->parent = s;
5526                   if (s)
5527                     {
5528                       if (s->left == p)
5529                         s->left = r;
5530                       else
5531                         s->right = r;
5532                     }
5533                   else
5534                     constructor_pending_elts = r;
5535                 }
5536               else /* r->balance == -1 */
5537                 {
5538                   /* RL rotation */
5539                   struct init_node *t = r->left;
5540
5541                   r->left = t->right;
5542                   if (r->left)
5543                     r->left->parent = r;
5544                   t->right = r;
5545
5546                   p->right = t->left;
5547                   if (p->right)
5548                     p->right->parent = p;
5549                   t->left = p;
5550
5551                   r->balance = (t->balance < 0);
5552                   p->balance = -(t->balance > 0);
5553                   t->balance = 0;
5554
5555                   s = p->parent;
5556                   p->parent = t;
5557                   r->parent = t;
5558                   t->parent = s;
5559                   if (s)
5560                     {
5561                       if (s->left == p)
5562                         s->left = t;
5563                       else
5564                         s->right = t;
5565                     }
5566                   else
5567                     constructor_pending_elts = t;
5568                 }
5569               break;
5570             }
5571           else
5572             {
5573               /* p->balance == -1; growth of right side balances the node.  */
5574               p->balance = 0;
5575               break;
5576             }
5577         }
5578
5579       r = p;
5580       p = p->parent;
5581     }
5582 }
5583
5584 /* Build AVL tree from a sorted chain.  */
5585
5586 static void
5587 set_nonincremental_init (void)
5588 {
5589   tree chain;
5590
5591   if (TREE_CODE (constructor_type) != RECORD_TYPE
5592       && TREE_CODE (constructor_type) != ARRAY_TYPE)
5593     return;
5594
5595   for (chain = constructor_elements; chain; chain = TREE_CHAIN (chain))
5596     add_pending_init (TREE_PURPOSE (chain), TREE_VALUE (chain));
5597   constructor_elements = 0;
5598   if (TREE_CODE (constructor_type) == RECORD_TYPE)
5599     {
5600       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
5601       /* Skip any nameless bit fields at the beginning.  */
5602       while (constructor_unfilled_fields != 0
5603              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5604              && DECL_NAME (constructor_unfilled_fields) == 0)
5605         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
5606
5607     }
5608   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5609     {
5610       if (TYPE_DOMAIN (constructor_type))
5611         constructor_unfilled_index
5612             = convert (bitsizetype,
5613                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5614       else
5615         constructor_unfilled_index = bitsize_zero_node;
5616     }
5617   constructor_incremental = 0;
5618 }
5619
5620 /* Build AVL tree from a string constant.  */
5621
5622 static void
5623 set_nonincremental_init_from_string (tree str)
5624 {
5625   tree value, purpose, type;
5626   HOST_WIDE_INT val[2];
5627   const char *p, *end;
5628   int byte, wchar_bytes, charwidth, bitpos;
5629
5630   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
5631
5632   if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5633       == TYPE_PRECISION (char_type_node))
5634     wchar_bytes = 1;
5635   else
5636     {
5637       gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str)))
5638                   == TYPE_PRECISION (wchar_type_node));
5639       wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
5640     }
5641   charwidth = TYPE_PRECISION (char_type_node);
5642   type = TREE_TYPE (constructor_type);
5643   p = TREE_STRING_POINTER (str);
5644   end = p + TREE_STRING_LENGTH (str);
5645
5646   for (purpose = bitsize_zero_node;
5647        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
5648        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
5649     {
5650       if (wchar_bytes == 1)
5651         {
5652           val[1] = (unsigned char) *p++;
5653           val[0] = 0;
5654         }
5655       else
5656         {
5657           val[0] = 0;
5658           val[1] = 0;
5659           for (byte = 0; byte < wchar_bytes; byte++)
5660             {
5661               if (BYTES_BIG_ENDIAN)
5662                 bitpos = (wchar_bytes - byte - 1) * charwidth;
5663               else
5664                 bitpos = byte * charwidth;
5665               val[bitpos < HOST_BITS_PER_WIDE_INT]
5666                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
5667                    << (bitpos % HOST_BITS_PER_WIDE_INT);
5668             }
5669         }
5670
5671       if (!TYPE_UNSIGNED (type))
5672         {
5673           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
5674           if (bitpos < HOST_BITS_PER_WIDE_INT)
5675             {
5676               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
5677                 {
5678                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
5679                   val[0] = -1;
5680                 }
5681             }
5682           else if (bitpos == HOST_BITS_PER_WIDE_INT)
5683             {
5684               if (val[1] < 0)
5685                 val[0] = -1;
5686             }
5687           else if (val[0] & (((HOST_WIDE_INT) 1)
5688                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
5689             val[0] |= ((HOST_WIDE_INT) -1)
5690                       << (bitpos - HOST_BITS_PER_WIDE_INT);
5691         }
5692
5693       value = build_int_cst_wide (type, val[1], val[0]);
5694       add_pending_init (purpose, value);
5695     }
5696
5697   constructor_incremental = 0;
5698 }
5699
5700 /* Return value of FIELD in pending initializer or zero if the field was
5701    not initialized yet.  */
5702
5703 static tree
5704 find_init_member (tree field)
5705 {
5706   struct init_node *p;
5707
5708   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5709     {
5710       if (constructor_incremental
5711           && tree_int_cst_lt (field, constructor_unfilled_index))
5712         set_nonincremental_init ();
5713
5714       p = constructor_pending_elts;
5715       while (p)
5716         {
5717           if (tree_int_cst_lt (field, p->purpose))
5718             p = p->left;
5719           else if (tree_int_cst_lt (p->purpose, field))
5720             p = p->right;
5721           else
5722             return p->value;
5723         }
5724     }
5725   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5726     {
5727       tree bitpos = bit_position (field);
5728
5729       if (constructor_incremental
5730           && (!constructor_unfilled_fields
5731               || tree_int_cst_lt (bitpos,
5732                                   bit_position (constructor_unfilled_fields))))
5733         set_nonincremental_init ();
5734
5735       p = constructor_pending_elts;
5736       while (p)
5737         {
5738           if (field == p->purpose)
5739             return p->value;
5740           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
5741             p = p->left;
5742           else
5743             p = p->right;
5744         }
5745     }
5746   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5747     {
5748       if (constructor_elements
5749           && TREE_PURPOSE (constructor_elements) == field)
5750         return TREE_VALUE (constructor_elements);
5751     }
5752   return 0;
5753 }
5754
5755 /* "Output" the next constructor element.
5756    At top level, really output it to assembler code now.
5757    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
5758    TYPE is the data type that the containing data type wants here.
5759    FIELD is the field (a FIELD_DECL) or the index that this element fills.
5760    If VALUE is a string constant, STRICT_STRING is true if it is
5761    unparenthesized or we should not warn here for it being parenthesized.
5762    For other types of VALUE, STRICT_STRING is not used.
5763
5764    PENDING if non-nil means output pending elements that belong
5765    right after this element.  (PENDING is normally 1;
5766    it is 0 while outputting pending elements, to avoid recursion.)  */
5767
5768 static void
5769 output_init_element (tree value, bool strict_string, tree type, tree field,
5770                      int pending)
5771 {
5772   if (type == error_mark_node || value == error_mark_node)
5773     {
5774       constructor_erroneous = 1;
5775       return;
5776     }
5777   if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
5778       && (TREE_CODE (value) == STRING_CST
5779           || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
5780       && !(TREE_CODE (value) == STRING_CST
5781            && TREE_CODE (type) == ARRAY_TYPE
5782            && INTEGRAL_TYPE_P (TREE_TYPE (type)))
5783       && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
5784                      TYPE_MAIN_VARIANT (type)))
5785     value = default_function_array_conversion (value);
5786
5787   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
5788       && require_constant_value && !flag_isoc99 && pending)
5789     {
5790       /* As an extension, allow initializing objects with static storage
5791          duration with compound literals (which are then treated just as
5792          the brace enclosed list they contain).  */
5793       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
5794       value = DECL_INITIAL (decl);
5795     }
5796
5797   if (value == error_mark_node)
5798     constructor_erroneous = 1;
5799   else if (!TREE_CONSTANT (value))
5800     constructor_constant = 0;
5801   else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
5802            || ((TREE_CODE (constructor_type) == RECORD_TYPE
5803                 || TREE_CODE (constructor_type) == UNION_TYPE)
5804                && DECL_C_BIT_FIELD (field)
5805                && TREE_CODE (value) != INTEGER_CST))
5806     constructor_simple = 0;
5807
5808   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
5809     {
5810       if (require_constant_value)
5811         {
5812           error_init ("initializer element is not constant");
5813           value = error_mark_node;
5814         }
5815       else if (require_constant_elements)
5816         pedwarn ("initializer element is not computable at load time");
5817     }
5818
5819   /* If this field is empty (and not at the end of structure),
5820      don't do anything other than checking the initializer.  */
5821   if (field
5822       && (TREE_TYPE (field) == error_mark_node
5823           || (COMPLETE_TYPE_P (TREE_TYPE (field))
5824               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
5825               && (TREE_CODE (constructor_type) == ARRAY_TYPE
5826                   || TREE_CHAIN (field)))))
5827     return;
5828
5829   value = digest_init (type, value, strict_string, require_constant_value);
5830   if (value == error_mark_node)
5831     {
5832       constructor_erroneous = 1;
5833       return;
5834     }
5835
5836   /* If this element doesn't come next in sequence,
5837      put it on constructor_pending_elts.  */
5838   if (TREE_CODE (constructor_type) == ARRAY_TYPE
5839       && (!constructor_incremental
5840           || !tree_int_cst_equal (field, constructor_unfilled_index)))
5841     {
5842       if (constructor_incremental
5843           && tree_int_cst_lt (field, constructor_unfilled_index))
5844         set_nonincremental_init ();
5845
5846       add_pending_init (field, value);
5847       return;
5848     }
5849   else if (TREE_CODE (constructor_type) == RECORD_TYPE
5850            && (!constructor_incremental
5851                || field != constructor_unfilled_fields))
5852     {
5853       /* We do this for records but not for unions.  In a union,
5854          no matter which field is specified, it can be initialized
5855          right away since it starts at the beginning of the union.  */
5856       if (constructor_incremental)
5857         {
5858           if (!constructor_unfilled_fields)
5859             set_nonincremental_init ();
5860           else
5861             {
5862               tree bitpos, unfillpos;
5863
5864               bitpos = bit_position (field);
5865               unfillpos = bit_position (constructor_unfilled_fields);
5866
5867               if (tree_int_cst_lt (bitpos, unfillpos))
5868                 set_nonincremental_init ();
5869             }
5870         }
5871
5872       add_pending_init (field, value);
5873       return;
5874     }
5875   else if (TREE_CODE (constructor_type) == UNION_TYPE
5876            && constructor_elements)
5877     {
5878       if (TREE_SIDE_EFFECTS (TREE_VALUE (constructor_elements)))
5879         warning_init ("initialized field with side-effects overwritten");
5880
5881       /* We can have just one union field set.  */
5882       constructor_elements = 0;
5883     }
5884
5885   /* Otherwise, output this element either to
5886      constructor_elements or to the assembler file.  */
5887
5888   if (field && TREE_CODE (field) == INTEGER_CST)
5889     field = copy_node (field);
5890   constructor_elements
5891     = tree_cons (field, value, constructor_elements);
5892
5893   /* Advance the variable that indicates sequential elements output.  */
5894   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5895     constructor_unfilled_index
5896       = size_binop (PLUS_EXPR, constructor_unfilled_index,
5897                     bitsize_one_node);
5898   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
5899     {
5900       constructor_unfilled_fields
5901         = TREE_CHAIN (constructor_unfilled_fields);
5902
5903       /* Skip any nameless bit fields.  */
5904       while (constructor_unfilled_fields != 0
5905              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
5906              && DECL_NAME (constructor_unfilled_fields) == 0)
5907         constructor_unfilled_fields =
5908           TREE_CHAIN (constructor_unfilled_fields);
5909     }
5910   else if (TREE_CODE (constructor_type) == UNION_TYPE)
5911     constructor_unfilled_fields = 0;
5912
5913   /* Now output any pending elements which have become next.  */
5914   if (pending)
5915     output_pending_init_elements (0);
5916 }
5917
5918 /* Output any pending elements which have become next.
5919    As we output elements, constructor_unfilled_{fields,index}
5920    advances, which may cause other elements to become next;
5921    if so, they too are output.
5922
5923    If ALL is 0, we return when there are
5924    no more pending elements to output now.
5925
5926    If ALL is 1, we output space as necessary so that
5927    we can output all the pending elements.  */
5928
5929 static void
5930 output_pending_init_elements (int all)
5931 {
5932   struct init_node *elt = constructor_pending_elts;
5933   tree next;
5934
5935  retry:
5936
5937   /* Look through the whole pending tree.
5938      If we find an element that should be output now,
5939      output it.  Otherwise, set NEXT to the element
5940      that comes first among those still pending.  */
5941
5942   next = 0;
5943   while (elt)
5944     {
5945       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5946         {
5947           if (tree_int_cst_equal (elt->purpose,
5948                                   constructor_unfilled_index))
5949             output_init_element (elt->value, true,
5950                                  TREE_TYPE (constructor_type),
5951                                  constructor_unfilled_index, 0);
5952           else if (tree_int_cst_lt (constructor_unfilled_index,
5953                                     elt->purpose))
5954             {
5955               /* Advance to the next smaller node.  */
5956               if (elt->left)
5957                 elt = elt->left;
5958               else
5959                 {
5960                   /* We have reached the smallest node bigger than the
5961                      current unfilled index.  Fill the space first.  */
5962                   next = elt->purpose;
5963                   break;
5964                 }
5965             }
5966           else
5967             {
5968               /* Advance to the next bigger node.  */
5969               if (elt->right)
5970                 elt = elt->right;
5971               else
5972                 {
5973                   /* We have reached the biggest node in a subtree.  Find
5974                      the parent of it, which is the next bigger node.  */
5975                   while (elt->parent && elt->parent->right == elt)
5976                     elt = elt->parent;
5977                   elt = elt->parent;
5978                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
5979                                               elt->purpose))
5980                     {
5981                       next = elt->purpose;
5982                       break;
5983                     }
5984                 }
5985             }
5986         }
5987       else if (TREE_CODE (constructor_type) == RECORD_TYPE
5988                || TREE_CODE (constructor_type) == UNION_TYPE)
5989         {
5990           tree ctor_unfilled_bitpos, elt_bitpos;
5991
5992           /* If the current record is complete we are done.  */
5993           if (constructor_unfilled_fields == 0)
5994             break;
5995
5996           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
5997           elt_bitpos = bit_position (elt->purpose);
5998           /* We can't compare fields here because there might be empty
5999              fields in between.  */
6000           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
6001             {
6002               constructor_unfilled_fields = elt->purpose;
6003               output_init_element (elt->value, true, TREE_TYPE (elt->purpose),
6004                                    elt->purpose, 0);
6005             }
6006           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
6007             {
6008               /* Advance to the next smaller node.  */
6009               if (elt->left)
6010                 elt = elt->left;
6011               else
6012                 {
6013                   /* We have reached the smallest node bigger than the
6014                      current unfilled field.  Fill the space first.  */
6015                   next = elt->purpose;
6016                   break;
6017                 }
6018             }
6019           else
6020             {
6021               /* Advance to the next bigger node.  */
6022               if (elt->right)
6023                 elt = elt->right;
6024               else
6025                 {
6026                   /* We have reached the biggest node in a subtree.  Find
6027                      the parent of it, which is the next bigger node.  */
6028                   while (elt->parent && elt->parent->right == elt)
6029                     elt = elt->parent;
6030                   elt = elt->parent;
6031                   if (elt
6032                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
6033                                            bit_position (elt->purpose))))
6034                     {
6035                       next = elt->purpose;
6036                       break;
6037                     }
6038                 }
6039             }
6040         }
6041     }
6042
6043   /* Ordinarily return, but not if we want to output all
6044      and there are elements left.  */
6045   if (!(all && next != 0))
6046     return;
6047
6048   /* If it's not incremental, just skip over the gap, so that after
6049      jumping to retry we will output the next successive element.  */
6050   if (TREE_CODE (constructor_type) == RECORD_TYPE
6051       || TREE_CODE (constructor_type) == UNION_TYPE)
6052     constructor_unfilled_fields = next;
6053   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6054     constructor_unfilled_index = next;
6055
6056   /* ELT now points to the node in the pending tree with the next
6057      initializer to output.  */
6058   goto retry;
6059 }
6060 \f
6061 /* Add one non-braced element to the current constructor level.
6062    This adjusts the current position within the constructor's type.
6063    This may also start or terminate implicit levels
6064    to handle a partly-braced initializer.
6065
6066    Once this has found the correct level for the new element,
6067    it calls output_init_element.  */
6068
6069 void
6070 process_init_element (struct c_expr value)
6071 {
6072   tree orig_value = value.value;
6073   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
6074   bool strict_string = value.original_code == STRING_CST;
6075
6076   designator_depth = 0;
6077   designator_errorneous = 0;
6078
6079   /* Handle superfluous braces around string cst as in
6080      char x[] = {"foo"}; */
6081   if (string_flag
6082       && constructor_type
6083       && TREE_CODE (constructor_type) == ARRAY_TYPE
6084       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
6085       && integer_zerop (constructor_unfilled_index))
6086     {
6087       if (constructor_stack->replacement_value.value)
6088         error_init ("excess elements in char array initializer");
6089       constructor_stack->replacement_value = value;
6090       return;
6091     }
6092
6093   if (constructor_stack->replacement_value.value != 0)
6094     {
6095       error_init ("excess elements in struct initializer");
6096       return;
6097     }
6098
6099   /* Ignore elements of a brace group if it is entirely superfluous
6100      and has already been diagnosed.  */
6101   if (constructor_type == 0)
6102     return;
6103
6104   /* If we've exhausted any levels that didn't have braces,
6105      pop them now.  */
6106   while (constructor_stack->implicit)
6107     {
6108       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6109            || TREE_CODE (constructor_type) == UNION_TYPE)
6110           && constructor_fields == 0)
6111         process_init_element (pop_init_level (1));
6112       else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6113                && (constructor_max_index == 0
6114                    || tree_int_cst_lt (constructor_max_index,
6115                                        constructor_index)))
6116         process_init_element (pop_init_level (1));
6117       else
6118         break;
6119     }
6120
6121   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
6122   if (constructor_range_stack)
6123     {
6124       /* If value is a compound literal and we'll be just using its
6125          content, don't put it into a SAVE_EXPR.  */
6126       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
6127           || !require_constant_value
6128           || flag_isoc99)
6129         value.value = save_expr (value.value);
6130     }
6131
6132   while (1)
6133     {
6134       if (TREE_CODE (constructor_type) == RECORD_TYPE)
6135         {
6136           tree fieldtype;
6137           enum tree_code fieldcode;
6138
6139           if (constructor_fields == 0)
6140             {
6141               pedwarn_init ("excess elements in struct initializer");
6142               break;
6143             }
6144
6145           fieldtype = TREE_TYPE (constructor_fields);
6146           if (fieldtype != error_mark_node)
6147             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6148           fieldcode = TREE_CODE (fieldtype);
6149
6150           /* Error for non-static initialization of a flexible array member.  */
6151           if (fieldcode == ARRAY_TYPE
6152               && !require_constant_value
6153               && TYPE_SIZE (fieldtype) == NULL_TREE
6154               && TREE_CHAIN (constructor_fields) == NULL_TREE)
6155             {
6156               error_init ("non-static initialization of a flexible array member");
6157               break;
6158             }
6159
6160           /* Accept a string constant to initialize a subarray.  */
6161           if (value.value != 0
6162               && fieldcode == ARRAY_TYPE
6163               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6164               && string_flag)
6165             value.value = orig_value;
6166           /* Otherwise, if we have come to a subaggregate,
6167              and we don't have an element of its type, push into it.  */
6168           else if (value.value != 0
6169                    && value.value != error_mark_node
6170                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6171                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6172                        || fieldcode == UNION_TYPE))
6173             {
6174               push_init_level (1);
6175               continue;
6176             }
6177
6178           if (value.value)
6179             {
6180               push_member_name (constructor_fields);
6181               output_init_element (value.value, strict_string,
6182                                    fieldtype, constructor_fields, 1);
6183               RESTORE_SPELLING_DEPTH (constructor_depth);
6184             }
6185           else
6186             /* Do the bookkeeping for an element that was
6187                directly output as a constructor.  */
6188             {
6189               /* For a record, keep track of end position of last field.  */
6190               if (DECL_SIZE (constructor_fields))
6191                 constructor_bit_index
6192                   = size_binop (PLUS_EXPR,
6193                                 bit_position (constructor_fields),
6194                                 DECL_SIZE (constructor_fields));
6195
6196               /* If the current field was the first one not yet written out,
6197                  it isn't now, so update.  */
6198               if (constructor_unfilled_fields == constructor_fields)
6199                 {
6200                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6201                   /* Skip any nameless bit fields.  */
6202                   while (constructor_unfilled_fields != 0
6203                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6204                          && DECL_NAME (constructor_unfilled_fields) == 0)
6205                     constructor_unfilled_fields =
6206                       TREE_CHAIN (constructor_unfilled_fields);
6207                 }
6208             }
6209
6210           constructor_fields = TREE_CHAIN (constructor_fields);
6211           /* Skip any nameless bit fields at the beginning.  */
6212           while (constructor_fields != 0
6213                  && DECL_C_BIT_FIELD (constructor_fields)
6214                  && DECL_NAME (constructor_fields) == 0)
6215             constructor_fields = TREE_CHAIN (constructor_fields);
6216         }
6217       else if (TREE_CODE (constructor_type) == UNION_TYPE)
6218         {
6219           tree fieldtype;
6220           enum tree_code fieldcode;
6221
6222           if (constructor_fields == 0)
6223             {
6224               pedwarn_init ("excess elements in union initializer");
6225               break;
6226             }
6227
6228           fieldtype = TREE_TYPE (constructor_fields);
6229           if (fieldtype != error_mark_node)
6230             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
6231           fieldcode = TREE_CODE (fieldtype);
6232
6233           /* Warn that traditional C rejects initialization of unions.
6234              We skip the warning if the value is zero.  This is done
6235              under the assumption that the zero initializer in user
6236              code appears conditioned on e.g. __STDC__ to avoid
6237              "missing initializer" warnings and relies on default
6238              initialization to zero in the traditional C case.
6239              We also skip the warning if the initializer is designated,
6240              again on the assumption that this must be conditional on
6241              __STDC__ anyway (and we've already complained about the
6242              member-designator already).  */
6243           if (warn_traditional && !in_system_header && !constructor_designated
6244               && !(value.value && (integer_zerop (value.value)
6245                                    || real_zerop (value.value))))
6246             warning (0, "traditional C rejects initialization of unions");
6247
6248           /* Accept a string constant to initialize a subarray.  */
6249           if (value.value != 0
6250               && fieldcode == ARRAY_TYPE
6251               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
6252               && string_flag)
6253             value.value = orig_value;
6254           /* Otherwise, if we have come to a subaggregate,
6255              and we don't have an element of its type, push into it.  */
6256           else if (value.value != 0
6257                    && value.value != error_mark_node
6258                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
6259                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
6260                        || fieldcode == UNION_TYPE))
6261             {
6262               push_init_level (1);
6263               continue;
6264             }
6265
6266           if (value.value)
6267             {
6268               push_member_name (constructor_fields);
6269               output_init_element (value.value, strict_string,
6270                                    fieldtype, constructor_fields, 1);
6271               RESTORE_SPELLING_DEPTH (constructor_depth);
6272             }
6273           else
6274             /* Do the bookkeeping for an element that was
6275                directly output as a constructor.  */
6276             {
6277               constructor_bit_index = DECL_SIZE (constructor_fields);
6278               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
6279             }
6280
6281           constructor_fields = 0;
6282         }
6283       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6284         {
6285           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6286           enum tree_code eltcode = TREE_CODE (elttype);
6287
6288           /* Accept a string constant to initialize a subarray.  */
6289           if (value.value != 0
6290               && eltcode == ARRAY_TYPE
6291               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
6292               && string_flag)
6293             value.value = orig_value;
6294           /* Otherwise, if we have come to a subaggregate,
6295              and we don't have an element of its type, push into it.  */
6296           else if (value.value != 0
6297                    && value.value != error_mark_node
6298                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
6299                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
6300                        || eltcode == UNION_TYPE))
6301             {
6302               push_init_level (1);
6303               continue;
6304             }
6305
6306           if (constructor_max_index != 0
6307               && (tree_int_cst_lt (constructor_max_index, constructor_index)
6308                   || integer_all_onesp (constructor_max_index)))
6309             {
6310               pedwarn_init ("excess elements in array initializer");
6311               break;
6312             }
6313
6314           /* Now output the actual element.  */
6315           if (value.value)
6316             {
6317               push_array_bounds (tree_low_cst (constructor_index, 0));
6318               output_init_element (value.value, strict_string,
6319                                    elttype, constructor_index, 1);
6320               RESTORE_SPELLING_DEPTH (constructor_depth);
6321             }
6322
6323           constructor_index
6324             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6325
6326           if (!value.value)
6327             /* If we are doing the bookkeeping for an element that was
6328                directly output as a constructor, we must update
6329                constructor_unfilled_index.  */
6330             constructor_unfilled_index = constructor_index;
6331         }
6332       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6333         {
6334           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6335
6336          /* Do a basic check of initializer size.  Note that vectors
6337             always have a fixed size derived from their type.  */
6338           if (tree_int_cst_lt (constructor_max_index, constructor_index))
6339             {
6340               pedwarn_init ("excess elements in vector initializer");
6341               break;
6342             }
6343
6344           /* Now output the actual element.  */
6345           if (value.value)
6346             output_init_element (value.value, strict_string,
6347                                  elttype, constructor_index, 1);
6348
6349           constructor_index
6350             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
6351
6352           if (!value.value)
6353             /* If we are doing the bookkeeping for an element that was
6354                directly output as a constructor, we must update
6355                constructor_unfilled_index.  */
6356             constructor_unfilled_index = constructor_index;
6357         }
6358
6359       /* Handle the sole element allowed in a braced initializer
6360          for a scalar variable.  */
6361       else if (constructor_type != error_mark_node
6362                && constructor_fields == 0)
6363         {
6364           pedwarn_init ("excess elements in scalar initializer");
6365           break;
6366         }
6367       else
6368         {
6369           if (value.value)
6370             output_init_element (value.value, strict_string,
6371                                  constructor_type, NULL_TREE, 1);
6372           constructor_fields = 0;
6373         }
6374
6375       /* Handle range initializers either at this level or anywhere higher
6376          in the designator stack.  */
6377       if (constructor_range_stack)
6378         {
6379           struct constructor_range_stack *p, *range_stack;
6380           int finish = 0;
6381
6382           range_stack = constructor_range_stack;
6383           constructor_range_stack = 0;
6384           while (constructor_stack != range_stack->stack)
6385             {
6386               gcc_assert (constructor_stack->implicit);
6387               process_init_element (pop_init_level (1));
6388             }
6389           for (p = range_stack;
6390                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
6391                p = p->prev)
6392             {
6393               gcc_assert (constructor_stack->implicit);
6394               process_init_element (pop_init_level (1));
6395             }
6396
6397           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
6398           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
6399             finish = 1;
6400
6401           while (1)
6402             {
6403               constructor_index = p->index;
6404               constructor_fields = p->fields;
6405               if (finish && p->range_end && p->index == p->range_start)
6406                 {
6407                   finish = 0;
6408                   p->prev = 0;
6409                 }
6410               p = p->next;
6411               if (!p)
6412                 break;
6413               push_init_level (2);
6414               p->stack = constructor_stack;
6415               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
6416                 p->index = p->range_start;
6417             }
6418
6419           if (!finish)
6420             constructor_range_stack = range_stack;
6421           continue;
6422         }
6423
6424       break;
6425     }
6426
6427   constructor_range_stack = 0;
6428 }
6429 \f
6430 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
6431    (guaranteed to be 'volatile' or null) and ARGS (represented using
6432    an ASM_EXPR node).  */
6433 tree
6434 build_asm_stmt (tree cv_qualifier, tree args)
6435 {
6436   if (!ASM_VOLATILE_P (args) && cv_qualifier)
6437     ASM_VOLATILE_P (args) = 1;
6438   return add_stmt (args);
6439 }
6440
6441 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
6442    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
6443    SIMPLE indicates whether there was anything at all after the
6444    string in the asm expression -- asm("blah") and asm("blah" : )
6445    are subtly different.  We use a ASM_EXPR node to represent this.  */
6446 tree
6447 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
6448                 bool simple)
6449 {
6450   tree tail;
6451   tree args;
6452   int i;
6453   const char *constraint;
6454   const char **oconstraints;
6455   bool allows_mem, allows_reg, is_inout;
6456   int ninputs, noutputs;
6457
6458   ninputs = list_length (inputs);
6459   noutputs = list_length (outputs);
6460   oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
6461
6462   string = resolve_asm_operand_names (string, outputs, inputs);
6463
6464   /* Remove output conversions that change the type but not the mode.  */
6465   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
6466     {
6467       tree output = TREE_VALUE (tail);
6468
6469       /* ??? Really, this should not be here.  Users should be using a
6470          proper lvalue, dammit.  But there's a long history of using casts
6471          in the output operands.  In cases like longlong.h, this becomes a
6472          primitive form of typechecking -- if the cast can be removed, then
6473          the output operand had a type of the proper width; otherwise we'll
6474          get an error.  Gross, but ...  */
6475       STRIP_NOPS (output);
6476
6477       if (!lvalue_or_else (output, lv_asm))
6478         output = error_mark_node;
6479
6480       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6481       oconstraints[i] = constraint;
6482
6483       if (parse_output_constraint (&constraint, i, ninputs, noutputs,
6484                                    &allows_mem, &allows_reg, &is_inout))
6485         {
6486           /* If the operand is going to end up in memory,
6487              mark it addressable.  */
6488           if (!allows_reg && !c_mark_addressable (output))
6489             output = error_mark_node;
6490         }
6491       else
6492         output = error_mark_node;
6493
6494       TREE_VALUE (tail) = output;
6495     }
6496
6497   for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
6498     {
6499       tree input;
6500
6501       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
6502       input = TREE_VALUE (tail);
6503
6504       if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
6505                                   oconstraints, &allows_mem, &allows_reg))
6506         {
6507           /* If the operand is going to end up in memory,
6508              mark it addressable.  */
6509           if (!allows_reg && allows_mem)
6510             {
6511               /* Strip the nops as we allow this case.  FIXME, this really
6512                  should be rejected or made deprecated.  */
6513               STRIP_NOPS (input);
6514               if (!c_mark_addressable (input))
6515                 input = error_mark_node;
6516           }
6517         }
6518       else
6519         input = error_mark_node;
6520
6521       TREE_VALUE (tail) = input;
6522     }
6523
6524   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
6525
6526   /* Simple asm statements are treated as volatile.  */
6527   if (simple)
6528     {
6529       ASM_VOLATILE_P (args) = 1;
6530       ASM_INPUT_P (args) = 1;
6531     }
6532
6533   return args;
6534 }
6535 \f
6536 /* Generate a goto statement to LABEL.  */
6537
6538 tree
6539 c_finish_goto_label (tree label)
6540 {
6541   tree decl = lookup_label (label);
6542   if (!decl)
6543     return NULL_TREE;
6544
6545   if (C_DECL_UNJUMPABLE_STMT_EXPR (decl))
6546     {
6547       error ("jump into statement expression");
6548       return NULL_TREE;
6549     }
6550
6551   if (C_DECL_UNJUMPABLE_VM (decl))
6552     {
6553       error ("jump into scope of identifier with variably modified type");
6554       return NULL_TREE;
6555     }
6556
6557   if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl))
6558     {
6559       /* No jump from outside this statement expression context, so
6560          record that there is a jump from within this context.  */
6561       struct c_label_list *nlist;
6562       nlist = XOBNEW (&parser_obstack, struct c_label_list);
6563       nlist->next = label_context_stack_se->labels_used;
6564       nlist->label = decl;
6565       label_context_stack_se->labels_used = nlist;
6566     }
6567
6568   if (!C_DECL_UNDEFINABLE_VM (decl))
6569     {
6570       /* No jump from outside this context context of identifiers with
6571          variably modified type, so record that there is a jump from
6572          within this context.  */
6573       struct c_label_list *nlist;
6574       nlist = XOBNEW (&parser_obstack, struct c_label_list);
6575       nlist->next = label_context_stack_vm->labels_used;
6576       nlist->label = decl;
6577       label_context_stack_vm->labels_used = nlist;
6578     }
6579
6580   TREE_USED (decl) = 1;
6581   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
6582 }
6583
6584 /* Generate a computed goto statement to EXPR.  */
6585
6586 tree
6587 c_finish_goto_ptr (tree expr)
6588 {
6589   if (pedantic)
6590     pedwarn ("ISO C forbids %<goto *expr;%>");
6591   expr = convert (ptr_type_node, expr);
6592   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
6593 }
6594
6595 /* Generate a C `return' statement.  RETVAL is the expression for what
6596    to return, or a null pointer for `return;' with no value.  */
6597
6598 tree
6599 c_finish_return (tree retval)
6600 {
6601   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl));
6602
6603   if (TREE_THIS_VOLATILE (current_function_decl))
6604     warning (0, "function declared %<noreturn%> has a %<return%> statement");
6605
6606   if (!retval)
6607     {
6608       current_function_returns_null = 1;
6609       if ((warn_return_type || flag_isoc99)
6610           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
6611         pedwarn_c99 ("%<return%> with no value, in "
6612                      "function returning non-void");
6613     }
6614   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
6615     {
6616       current_function_returns_null = 1;
6617       if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
6618         pedwarn ("%<return%> with a value, in function returning void");
6619     }
6620   else
6621     {
6622       tree t = convert_for_assignment (valtype, retval, ic_return,
6623                                        NULL_TREE, NULL_TREE, 0);
6624       tree res = DECL_RESULT (current_function_decl);
6625       tree inner;
6626
6627       current_function_returns_value = 1;
6628       if (t == error_mark_node)
6629         return NULL_TREE;
6630
6631       inner = t = convert (TREE_TYPE (res), t);
6632
6633       /* Strip any conversions, additions, and subtractions, and see if
6634          we are returning the address of a local variable.  Warn if so.  */
6635       while (1)
6636         {
6637           switch (TREE_CODE (inner))
6638             {
6639             case NOP_EXPR:   case NON_LVALUE_EXPR:  case CONVERT_EXPR:
6640             case PLUS_EXPR:
6641               inner = TREE_OPERAND (inner, 0);
6642               continue;
6643
6644             case MINUS_EXPR:
6645               /* If the second operand of the MINUS_EXPR has a pointer
6646                  type (or is converted from it), this may be valid, so
6647                  don't give a warning.  */
6648               {
6649                 tree op1 = TREE_OPERAND (inner, 1);
6650
6651                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
6652                        && (TREE_CODE (op1) == NOP_EXPR
6653                            || TREE_CODE (op1) == NON_LVALUE_EXPR
6654                            || TREE_CODE (op1) == CONVERT_EXPR))
6655                   op1 = TREE_OPERAND (op1, 0);
6656
6657                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
6658                   break;
6659
6660                 inner = TREE_OPERAND (inner, 0);
6661                 continue;
6662               }
6663
6664             case ADDR_EXPR:
6665               inner = TREE_OPERAND (inner, 0);
6666
6667               while (REFERENCE_CLASS_P (inner)
6668                      && TREE_CODE (inner) != INDIRECT_REF)
6669                 inner = TREE_OPERAND (inner, 0);
6670
6671               if (DECL_P (inner)
6672                   && !DECL_EXTERNAL (inner)
6673                   && !TREE_STATIC (inner)
6674                   && DECL_CONTEXT (inner) == current_function_decl)
6675                 warning (0, "function returns address of local variable");
6676               break;
6677
6678             default:
6679               break;
6680             }
6681
6682           break;
6683         }
6684
6685       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
6686     }
6687
6688   return add_stmt (build_stmt (RETURN_EXPR, retval));
6689 }
6690 \f
6691 struct c_switch {
6692   /* The SWITCH_EXPR being built.  */
6693   tree switch_expr;
6694
6695   /* The original type of the testing expression, i.e. before the
6696      default conversion is applied.  */
6697   tree orig_type;
6698
6699   /* A splay-tree mapping the low element of a case range to the high
6700      element, or NULL_TREE if there is no high element.  Used to
6701      determine whether or not a new case label duplicates an old case
6702      label.  We need a tree, rather than simply a hash table, because
6703      of the GNU case range extension.  */
6704   splay_tree cases;
6705
6706   /* Number of nested statement expressions within this switch
6707      statement; if nonzero, case and default labels may not
6708      appear.  */
6709   unsigned int blocked_stmt_expr;
6710
6711   /* Scope of outermost declarations of identifiers with variably
6712      modified type within this switch statement; if nonzero, case and
6713      default labels may not appear.  */
6714   unsigned int blocked_vm;
6715
6716   /* The next node on the stack.  */
6717   struct c_switch *next;
6718 };
6719
6720 /* A stack of the currently active switch statements.  The innermost
6721    switch statement is on the top of the stack.  There is no need to
6722    mark the stack for garbage collection because it is only active
6723    during the processing of the body of a function, and we never
6724    collect at that point.  */
6725
6726 struct c_switch *c_switch_stack;
6727
6728 /* Start a C switch statement, testing expression EXP.  Return the new
6729    SWITCH_EXPR.  */
6730
6731 tree
6732 c_start_case (tree exp)
6733 {
6734   enum tree_code code;
6735   tree type, orig_type = error_mark_node;
6736   struct c_switch *cs;
6737
6738   if (exp != error_mark_node)
6739     {
6740       code = TREE_CODE (TREE_TYPE (exp));
6741       orig_type = TREE_TYPE (exp);
6742
6743       if (!INTEGRAL_TYPE_P (orig_type)
6744           && code != ERROR_MARK)
6745         {
6746           error ("switch quantity not an integer");
6747           exp = integer_zero_node;
6748           orig_type = error_mark_node;
6749         }
6750       else
6751         {
6752           type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
6753
6754           if (warn_traditional && !in_system_header
6755               && (type == long_integer_type_node
6756                   || type == long_unsigned_type_node))
6757             warning (0, "%<long%> switch expression not converted to "
6758                      "%<int%> in ISO C");
6759
6760           exp = default_conversion (exp);
6761           type = TREE_TYPE (exp);
6762         }
6763     }
6764
6765   /* Add this new SWITCH_EXPR to the stack.  */
6766   cs = XNEW (struct c_switch);
6767   cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
6768   cs->orig_type = orig_type;
6769   cs->cases = splay_tree_new (case_compare, NULL, NULL);
6770   cs->blocked_stmt_expr = 0;
6771   cs->blocked_vm = 0;
6772   cs->next = c_switch_stack;
6773   c_switch_stack = cs;
6774
6775   return add_stmt (cs->switch_expr);
6776 }
6777
6778 /* Process a case label.  */
6779
6780 tree
6781 do_case (tree low_value, tree high_value)
6782 {
6783   tree label = NULL_TREE;
6784
6785   if (c_switch_stack && !c_switch_stack->blocked_stmt_expr
6786       && !c_switch_stack->blocked_vm)
6787     {
6788       label = c_add_case_label (c_switch_stack->cases,
6789                                 SWITCH_COND (c_switch_stack->switch_expr),
6790                                 c_switch_stack->orig_type,
6791                                 low_value, high_value);
6792       if (label == error_mark_node)
6793         label = NULL_TREE;
6794     }
6795   else if (c_switch_stack && c_switch_stack->blocked_stmt_expr)
6796     {
6797       if (low_value)
6798         error ("case label in statement expression not containing "
6799                "enclosing switch statement");
6800       else
6801         error ("%<default%> label in statement expression not containing "
6802                "enclosing switch statement");
6803     }
6804   else if (c_switch_stack && c_switch_stack->blocked_vm)
6805     {
6806       if (low_value)
6807         error ("case label in scope of identifier with variably modified "
6808                "type not containing enclosing switch statement");
6809       else
6810         error ("%<default%> label in scope of identifier with variably "
6811                "modified type not containing enclosing switch statement");
6812     }
6813   else if (low_value)
6814     error ("case label not within a switch statement");
6815   else
6816     error ("%<default%> label not within a switch statement");
6817
6818   return label;
6819 }
6820
6821 /* Finish the switch statement.  */
6822
6823 void
6824 c_finish_case (tree body)
6825 {
6826   struct c_switch *cs = c_switch_stack;
6827   location_t switch_location;
6828
6829   SWITCH_BODY (cs->switch_expr) = body;
6830
6831   /* We must not be within a statement expression nested in the switch
6832      at this point; we might, however, be within the scope of an
6833      identifier with variably modified type nested in the switch.  */
6834   gcc_assert (!cs->blocked_stmt_expr);
6835
6836   /* Emit warnings as needed.  */
6837   if (EXPR_HAS_LOCATION (cs->switch_expr))
6838     switch_location = EXPR_LOCATION (cs->switch_expr);
6839   else
6840     switch_location = input_location;
6841   c_do_switch_warnings (cs->cases, switch_location,
6842                         TREE_TYPE (cs->switch_expr),
6843                         SWITCH_COND (cs->switch_expr));
6844
6845   /* Pop the stack.  */
6846   c_switch_stack = cs->next;
6847   splay_tree_delete (cs->cases);
6848   XDELETE (cs);
6849 }
6850 \f
6851 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
6852    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
6853    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
6854    statement, and was not surrounded with parenthesis.  */
6855
6856 void
6857 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
6858                   tree else_block, bool nested_if)
6859 {
6860   tree stmt;
6861
6862   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
6863   if (warn_parentheses && nested_if && else_block == NULL)
6864     {
6865       tree inner_if = then_block;
6866
6867       /* We know from the grammar productions that there is an IF nested
6868          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
6869          it might not be exactly THEN_BLOCK, but should be the last
6870          non-container statement within.  */
6871       while (1)
6872         switch (TREE_CODE (inner_if))
6873           {
6874           case COND_EXPR:
6875             goto found;
6876           case BIND_EXPR:
6877             inner_if = BIND_EXPR_BODY (inner_if);
6878             break;
6879           case STATEMENT_LIST:
6880             inner_if = expr_last (then_block);
6881             break;
6882           case TRY_FINALLY_EXPR:
6883           case TRY_CATCH_EXPR:
6884             inner_if = TREE_OPERAND (inner_if, 0);
6885             break;
6886           default:
6887             gcc_unreachable ();
6888           }
6889     found:
6890
6891       if (COND_EXPR_ELSE (inner_if))
6892          warning (0, "%Hsuggest explicit braces to avoid ambiguous %<else%>",
6893                   &if_locus);
6894     }
6895
6896   /* Diagnose ";" via the special empty statement node that we create.  */
6897   if (extra_warnings)
6898     {
6899       if (TREE_CODE (then_block) == NOP_EXPR && !TREE_TYPE (then_block))
6900         {
6901           if (!else_block)
6902             warning (0, "%Hempty body in an if-statement",
6903                      EXPR_LOCUS (then_block));
6904           then_block = alloc_stmt_list ();
6905         }
6906       if (else_block
6907           && TREE_CODE (else_block) == NOP_EXPR
6908           && !TREE_TYPE (else_block))
6909         {
6910           warning (0, "%Hempty body in an else-statement",
6911                    EXPR_LOCUS (else_block));
6912           else_block = alloc_stmt_list ();
6913         }
6914     }
6915
6916   stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
6917   SET_EXPR_LOCATION (stmt, if_locus);
6918   add_stmt (stmt);
6919 }
6920
6921 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
6922    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
6923    is false for DO loops.  INCR is the FOR increment expression.  BODY is
6924    the statement controlled by the loop.  BLAB is the break label.  CLAB is
6925    the continue label.  Everything is allowed to be NULL.  */
6926
6927 void
6928 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
6929                tree blab, tree clab, bool cond_is_first)
6930 {
6931   tree entry = NULL, exit = NULL, t;
6932
6933   /* If the condition is zero don't generate a loop construct.  */
6934   if (cond && integer_zerop (cond))
6935     {
6936       if (cond_is_first)
6937         {
6938           t = build_and_jump (&blab);
6939           SET_EXPR_LOCATION (t, start_locus);
6940           add_stmt (t);
6941         }
6942     }
6943   else
6944     {
6945       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6946
6947       /* If we have an exit condition, then we build an IF with gotos either
6948          out of the loop, or to the top of it.  If there's no exit condition,
6949          then we just build a jump back to the top.  */
6950       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
6951
6952       if (cond && !integer_nonzerop (cond))
6953         {
6954           /* Canonicalize the loop condition to the end.  This means
6955              generating a branch to the loop condition.  Reuse the
6956              continue label, if possible.  */
6957           if (cond_is_first)
6958             {
6959               if (incr || !clab)
6960                 {
6961                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
6962                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
6963                 }
6964               else
6965                 t = build1 (GOTO_EXPR, void_type_node, clab);
6966               SET_EXPR_LOCATION (t, start_locus);
6967               add_stmt (t);
6968             }
6969
6970           t = build_and_jump (&blab);
6971           exit = build3 (COND_EXPR, void_type_node, cond, exit, t);
6972           exit = fold (exit);
6973           if (cond_is_first)
6974             SET_EXPR_LOCATION (exit, start_locus);
6975           else
6976             SET_EXPR_LOCATION (exit, input_location);
6977         }
6978
6979       add_stmt (top);
6980     }
6981
6982   if (body)
6983     add_stmt (body);
6984   if (clab)
6985     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
6986   if (incr)
6987     add_stmt (incr);
6988   if (entry)
6989     add_stmt (entry);
6990   if (exit)
6991     add_stmt (exit);
6992   if (blab)
6993     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
6994 }
6995
6996 tree
6997 c_finish_bc_stmt (tree *label_p, bool is_break)
6998 {
6999   bool skip;
7000   tree label = *label_p;
7001
7002   /* In switch statements break is sometimes stylistically used after
7003      a return statement.  This can lead to spurious warnings about
7004      control reaching the end of a non-void function when it is
7005      inlined.  Note that we are calling block_may_fallthru with
7006      language specific tree nodes; this works because
7007      block_may_fallthru returns true when given something it does not
7008      understand.  */
7009   skip = !block_may_fallthru (cur_stmt_list);
7010
7011   if (!label)
7012     {
7013       if (!skip)
7014         *label_p = label = create_artificial_label ();
7015     }
7016   else if (TREE_CODE (label) != LABEL_DECL)
7017     {
7018       if (is_break)
7019         error ("break statement not within loop or switch");
7020       else
7021         error ("continue statement not within a loop");
7022       return NULL_TREE;
7023     }
7024
7025   if (skip)
7026     return NULL_TREE;
7027
7028   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
7029 }
7030
7031 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
7032
7033 static void
7034 emit_side_effect_warnings (tree expr)
7035 {
7036   if (expr == error_mark_node)
7037     ;
7038   else if (!TREE_SIDE_EFFECTS (expr))
7039     {
7040       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
7041         warning (0, "%Hstatement with no effect",
7042                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
7043     }
7044   else if (warn_unused_value)
7045     warn_if_unused_value (expr, input_location);
7046 }
7047
7048 /* Process an expression as if it were a complete statement.  Emit
7049    diagnostics, but do not call ADD_STMT.  */
7050
7051 tree
7052 c_process_expr_stmt (tree expr)
7053 {
7054   if (!expr)
7055     return NULL_TREE;
7056
7057   if (warn_sequence_point)
7058     verify_sequence_points (expr);
7059
7060   if (TREE_TYPE (expr) != error_mark_node
7061       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
7062       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
7063     error ("expression statement has incomplete type");
7064
7065   /* If we're not processing a statement expression, warn about unused values.
7066      Warnings for statement expressions will be emitted later, once we figure
7067      out which is the result.  */
7068   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
7069       && (extra_warnings || warn_unused_value))
7070     emit_side_effect_warnings (expr);
7071
7072   /* If the expression is not of a type to which we cannot assign a line
7073      number, wrap the thing in a no-op NOP_EXPR.  */
7074   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
7075     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
7076
7077   if (EXPR_P (expr))
7078     SET_EXPR_LOCATION (expr, input_location);
7079
7080   return expr;
7081 }
7082
7083 /* Emit an expression as a statement.  */
7084
7085 tree
7086 c_finish_expr_stmt (tree expr)
7087 {
7088   if (expr)
7089     return add_stmt (c_process_expr_stmt (expr));
7090   else
7091     return NULL;
7092 }
7093
7094 /* Do the opposite and emit a statement as an expression.  To begin,
7095    create a new binding level and return it.  */
7096
7097 tree
7098 c_begin_stmt_expr (void)
7099 {
7100   tree ret;
7101   struct c_label_context_se *nstack;
7102   struct c_label_list *glist;
7103
7104   /* We must force a BLOCK for this level so that, if it is not expanded
7105      later, there is a way to turn off the entire subtree of blocks that
7106      are contained in it.  */
7107   keep_next_level ();
7108   ret = c_begin_compound_stmt (true);
7109   if (c_switch_stack)
7110     {
7111       c_switch_stack->blocked_stmt_expr++;
7112       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
7113     }
7114   for (glist = label_context_stack_se->labels_used;
7115        glist != NULL;
7116        glist = glist->next)
7117     {
7118       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1;
7119     }
7120   nstack = XOBNEW (&parser_obstack, struct c_label_context_se);
7121   nstack->labels_def = NULL;
7122   nstack->labels_used = NULL;
7123   nstack->next = label_context_stack_se;
7124   label_context_stack_se = nstack;
7125
7126   /* Mark the current statement list as belonging to a statement list.  */
7127   STATEMENT_LIST_STMT_EXPR (ret) = 1;
7128
7129   return ret;
7130 }
7131
7132 tree
7133 c_finish_stmt_expr (tree body)
7134 {
7135   tree last, type, tmp, val;
7136   tree *last_p;
7137   struct c_label_list *dlist, *glist, *glist_prev = NULL;
7138
7139   body = c_end_compound_stmt (body, true);
7140   if (c_switch_stack)
7141     {
7142       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
7143       c_switch_stack->blocked_stmt_expr--;
7144     }
7145   /* It is no longer possible to jump to labels defined within this
7146      statement expression.  */
7147   for (dlist = label_context_stack_se->labels_def;
7148        dlist != NULL;
7149        dlist = dlist->next)
7150     {
7151       C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1;
7152     }
7153   /* It is again possible to define labels with a goto just outside
7154      this statement expression.  */
7155   for (glist = label_context_stack_se->next->labels_used;
7156        glist != NULL;
7157        glist = glist->next)
7158     {
7159       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0;
7160       glist_prev = glist;
7161     }
7162   if (glist_prev != NULL)
7163     glist_prev->next = label_context_stack_se->labels_used;
7164   else
7165     label_context_stack_se->next->labels_used
7166       = label_context_stack_se->labels_used;
7167   label_context_stack_se = label_context_stack_se->next;
7168
7169   /* Locate the last statement in BODY.  See c_end_compound_stmt
7170      about always returning a BIND_EXPR.  */
7171   last_p = &BIND_EXPR_BODY (body);
7172   last = BIND_EXPR_BODY (body);
7173
7174  continue_searching:
7175   if (TREE_CODE (last) == STATEMENT_LIST)
7176     {
7177       tree_stmt_iterator i;
7178
7179       /* This can happen with degenerate cases like ({ }).  No value.  */
7180       if (!TREE_SIDE_EFFECTS (last))
7181         return body;
7182
7183       /* If we're supposed to generate side effects warnings, process
7184          all of the statements except the last.  */
7185       if (extra_warnings || warn_unused_value)
7186         {
7187           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
7188             emit_side_effect_warnings (tsi_stmt (i));
7189         }
7190       else
7191         i = tsi_last (last);
7192       last_p = tsi_stmt_ptr (i);
7193       last = *last_p;
7194     }
7195
7196   /* If the end of the list is exception related, then the list was split
7197      by a call to push_cleanup.  Continue searching.  */
7198   if (TREE_CODE (last) == TRY_FINALLY_EXPR
7199       || TREE_CODE (last) == TRY_CATCH_EXPR)
7200     {
7201       last_p = &TREE_OPERAND (last, 0);
7202       last = *last_p;
7203       goto continue_searching;
7204     }
7205
7206   /* In the case that the BIND_EXPR is not necessary, return the
7207      expression out from inside it.  */
7208   if (last == error_mark_node
7209       || (last == BIND_EXPR_BODY (body)
7210           && BIND_EXPR_VARS (body) == NULL))
7211     return last;
7212
7213   /* Extract the type of said expression.  */
7214   type = TREE_TYPE (last);
7215
7216   /* If we're not returning a value at all, then the BIND_EXPR that
7217      we already have is a fine expression to return.  */
7218   if (!type || VOID_TYPE_P (type))
7219     return body;
7220
7221   /* Now that we've located the expression containing the value, it seems
7222      silly to make voidify_wrapper_expr repeat the process.  Create a
7223      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
7224   tmp = create_tmp_var_raw (type, NULL);
7225
7226   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
7227      tree_expr_nonnegative_p giving up immediately.  */
7228   val = last;
7229   if (TREE_CODE (val) == NOP_EXPR
7230       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
7231     val = TREE_OPERAND (val, 0);
7232
7233   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
7234   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
7235
7236   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
7237 }
7238
7239 /* Begin the scope of an identifier of variably modified type, scope
7240    number SCOPE.  Jumping from outside this scope to inside it is not
7241    permitted.  */
7242
7243 void
7244 c_begin_vm_scope (unsigned int scope)
7245 {
7246   struct c_label_context_vm *nstack;
7247   struct c_label_list *glist;
7248
7249   gcc_assert (scope > 0);
7250   if (c_switch_stack && !c_switch_stack->blocked_vm)
7251     c_switch_stack->blocked_vm = scope;
7252   for (glist = label_context_stack_vm->labels_used;
7253        glist != NULL;
7254        glist = glist->next)
7255     {
7256       C_DECL_UNDEFINABLE_VM (glist->label) = 1;
7257     }
7258   nstack = XOBNEW (&parser_obstack, struct c_label_context_vm);
7259   nstack->labels_def = NULL;
7260   nstack->labels_used = NULL;
7261   nstack->scope = scope;
7262   nstack->next = label_context_stack_vm;
7263   label_context_stack_vm = nstack;
7264 }
7265
7266 /* End a scope which may contain identifiers of variably modified
7267    type, scope number SCOPE.  */
7268
7269 void
7270 c_end_vm_scope (unsigned int scope)
7271 {
7272   if (label_context_stack_vm == NULL)
7273     return;
7274   if (c_switch_stack && c_switch_stack->blocked_vm == scope)
7275     c_switch_stack->blocked_vm = 0;
7276   /* We may have a number of nested scopes of identifiers with
7277      variably modified type, all at this depth.  Pop each in turn.  */
7278   while (label_context_stack_vm->scope == scope)
7279     {
7280       struct c_label_list *dlist, *glist, *glist_prev = NULL;
7281
7282       /* It is no longer possible to jump to labels defined within this
7283          scope.  */
7284       for (dlist = label_context_stack_vm->labels_def;
7285            dlist != NULL;
7286            dlist = dlist->next)
7287         {
7288           C_DECL_UNJUMPABLE_VM (dlist->label) = 1;
7289         }
7290       /* It is again possible to define labels with a goto just outside
7291          this scope.  */
7292       for (glist = label_context_stack_vm->next->labels_used;
7293            glist != NULL;
7294            glist = glist->next)
7295         {
7296           C_DECL_UNDEFINABLE_VM (glist->label) = 0;
7297           glist_prev = glist;
7298         }
7299       if (glist_prev != NULL)
7300         glist_prev->next = label_context_stack_vm->labels_used;
7301       else
7302         label_context_stack_vm->next->labels_used
7303           = label_context_stack_vm->labels_used;
7304       label_context_stack_vm = label_context_stack_vm->next;
7305     }
7306 }
7307 \f
7308 /* Begin and end compound statements.  This is as simple as pushing
7309    and popping new statement lists from the tree.  */
7310
7311 tree
7312 c_begin_compound_stmt (bool do_scope)
7313 {
7314   tree stmt = push_stmt_list ();
7315   if (do_scope)
7316     push_scope ();
7317   return stmt;
7318 }
7319
7320 tree
7321 c_end_compound_stmt (tree stmt, bool do_scope)
7322 {
7323   tree block = NULL;
7324
7325   if (do_scope)
7326     {
7327       if (c_dialect_objc ())
7328         objc_clear_super_receiver ();
7329       block = pop_scope ();
7330     }
7331
7332   stmt = pop_stmt_list (stmt);
7333   stmt = c_build_bind_expr (block, stmt);
7334
7335   /* If this compound statement is nested immediately inside a statement
7336      expression, then force a BIND_EXPR to be created.  Otherwise we'll
7337      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
7338      STATEMENT_LISTs merge, and thus we can lose track of what statement
7339      was really last.  */
7340   if (cur_stmt_list
7341       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
7342       && TREE_CODE (stmt) != BIND_EXPR)
7343     {
7344       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
7345       TREE_SIDE_EFFECTS (stmt) = 1;
7346     }
7347
7348   return stmt;
7349 }
7350
7351 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
7352    when the current scope is exited.  EH_ONLY is true when this is not
7353    meant to apply to normal control flow transfer.  */
7354
7355 void
7356 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
7357 {
7358   enum tree_code code;
7359   tree stmt, list;
7360   bool stmt_expr;
7361
7362   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
7363   stmt = build_stmt (code, NULL, cleanup);
7364   add_stmt (stmt);
7365   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
7366   list = push_stmt_list ();
7367   TREE_OPERAND (stmt, 0) = list;
7368   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
7369 }
7370 \f
7371 /* Build a binary-operation expression without default conversions.
7372    CODE is the kind of expression to build.
7373    This function differs from `build' in several ways:
7374    the data type of the result is computed and recorded in it,
7375    warnings are generated if arg data types are invalid,
7376    special handling for addition and subtraction of pointers is known,
7377    and some optimization is done (operations on narrow ints
7378    are done in the narrower type when that gives the same result).
7379    Constant folding is also done before the result is returned.
7380
7381    Note that the operands will never have enumeral types, or function
7382    or array types, because either they will have the default conversions
7383    performed or they have both just been converted to some other type in which
7384    the arithmetic is to be done.  */
7385
7386 tree
7387 build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
7388                  int convert_p)
7389 {
7390   tree type0, type1;
7391   enum tree_code code0, code1;
7392   tree op0, op1;
7393
7394   /* Expression code to give to the expression when it is built.
7395      Normally this is CODE, which is what the caller asked for,
7396      but in some special cases we change it.  */
7397   enum tree_code resultcode = code;
7398
7399   /* Data type in which the computation is to be performed.
7400      In the simplest cases this is the common type of the arguments.  */
7401   tree result_type = NULL;
7402
7403   /* Nonzero means operands have already been type-converted
7404      in whatever way is necessary.
7405      Zero means they need to be converted to RESULT_TYPE.  */
7406   int converted = 0;
7407
7408   /* Nonzero means create the expression with this type, rather than
7409      RESULT_TYPE.  */
7410   tree build_type = 0;
7411
7412   /* Nonzero means after finally constructing the expression
7413      convert it to this type.  */
7414   tree final_type = 0;
7415
7416   /* Nonzero if this is an operation like MIN or MAX which can
7417      safely be computed in short if both args are promoted shorts.
7418      Also implies COMMON.
7419      -1 indicates a bitwise operation; this makes a difference
7420      in the exact conditions for when it is safe to do the operation
7421      in a narrower mode.  */
7422   int shorten = 0;
7423
7424   /* Nonzero if this is a comparison operation;
7425      if both args are promoted shorts, compare the original shorts.
7426      Also implies COMMON.  */
7427   int short_compare = 0;
7428
7429   /* Nonzero if this is a right-shift operation, which can be computed on the
7430      original short and then promoted if the operand is a promoted short.  */
7431   int short_shift = 0;
7432
7433   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
7434   int common = 0;
7435
7436   /* True means types are compatible as far as ObjC is concerned.  */
7437   bool objc_ok;
7438
7439   if (convert_p)
7440     {
7441       op0 = default_conversion (orig_op0);
7442       op1 = default_conversion (orig_op1);
7443     }
7444   else
7445     {
7446       op0 = orig_op0;
7447       op1 = orig_op1;
7448     }
7449
7450   type0 = TREE_TYPE (op0);
7451   type1 = TREE_TYPE (op1);
7452
7453   /* The expression codes of the data types of the arguments tell us
7454      whether the arguments are integers, floating, pointers, etc.  */
7455   code0 = TREE_CODE (type0);
7456   code1 = TREE_CODE (type1);
7457
7458   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
7459   STRIP_TYPE_NOPS (op0);
7460   STRIP_TYPE_NOPS (op1);
7461
7462   /* If an error was already reported for one of the arguments,
7463      avoid reporting another error.  */
7464
7465   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7466     return error_mark_node;
7467
7468   objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
7469
7470   switch (code)
7471     {
7472     case PLUS_EXPR:
7473       /* Handle the pointer + int case.  */
7474       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7475         return pointer_int_sum (PLUS_EXPR, op0, op1);
7476       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
7477         return pointer_int_sum (PLUS_EXPR, op1, op0);
7478       else
7479         common = 1;
7480       break;
7481
7482     case MINUS_EXPR:
7483       /* Subtraction of two similar pointers.
7484          We must subtract them as integers, then divide by object size.  */
7485       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
7486           && comp_target_types (type0, type1))
7487         return pointer_diff (op0, op1);
7488       /* Handle pointer minus int.  Just like pointer plus int.  */
7489       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7490         return pointer_int_sum (MINUS_EXPR, op0, op1);
7491       else
7492         common = 1;
7493       break;
7494
7495     case MULT_EXPR:
7496       common = 1;
7497       break;
7498
7499     case TRUNC_DIV_EXPR:
7500     case CEIL_DIV_EXPR:
7501     case FLOOR_DIV_EXPR:
7502     case ROUND_DIV_EXPR:
7503     case EXACT_DIV_EXPR:
7504       /* Floating point division by zero is a legitimate way to obtain
7505          infinities and NaNs.  */
7506       if (skip_evaluation == 0 && integer_zerop (op1))
7507         warning (OPT_Wdiv_by_zero, "division by zero");
7508
7509       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7510            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7511           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7512               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
7513         {
7514           enum tree_code tcode0 = code0, tcode1 = code1;
7515
7516           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
7517             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
7518           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
7519             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
7520
7521           if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE))
7522             resultcode = RDIV_EXPR;
7523           else
7524             /* Although it would be tempting to shorten always here, that
7525                loses on some targets, since the modulo instruction is
7526                undefined if the quotient can't be represented in the
7527                computation mode.  We shorten only if unsigned or if
7528                dividing by something we know != -1.  */
7529             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7530                        || (TREE_CODE (op1) == INTEGER_CST
7531                            && !integer_all_onesp (op1)));
7532           common = 1;
7533         }
7534       break;
7535
7536     case BIT_AND_EXPR:
7537     case BIT_IOR_EXPR:
7538     case BIT_XOR_EXPR:
7539       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7540         shorten = -1;
7541       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
7542         common = 1;
7543       break;
7544
7545     case TRUNC_MOD_EXPR:
7546     case FLOOR_MOD_EXPR:
7547       if (skip_evaluation == 0 && integer_zerop (op1))
7548         warning (OPT_Wdiv_by_zero, "division by zero");
7549
7550       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7551         {
7552           /* Although it would be tempting to shorten always here, that loses
7553              on some targets, since the modulo instruction is undefined if the
7554              quotient can't be represented in the computation mode.  We shorten
7555              only if unsigned or if dividing by something we know != -1.  */
7556           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
7557                      || (TREE_CODE (op1) == INTEGER_CST
7558                          && !integer_all_onesp (op1)));
7559           common = 1;
7560         }
7561       break;
7562
7563     case TRUTH_ANDIF_EXPR:
7564     case TRUTH_ORIF_EXPR:
7565     case TRUTH_AND_EXPR:
7566     case TRUTH_OR_EXPR:
7567     case TRUTH_XOR_EXPR:
7568       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
7569            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE)
7570           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
7571               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE))
7572         {
7573           /* Result of these operations is always an int,
7574              but that does not mean the operands should be
7575              converted to ints!  */
7576           result_type = integer_type_node;
7577           op0 = c_common_truthvalue_conversion (op0);
7578           op1 = c_common_truthvalue_conversion (op1);
7579           converted = 1;
7580         }
7581       break;
7582
7583       /* Shift operations: result has same type as first operand;
7584          always convert second operand to int.
7585          Also set SHORT_SHIFT if shifting rightward.  */
7586
7587     case RSHIFT_EXPR:
7588       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7589         {
7590           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7591             {
7592               if (tree_int_cst_sgn (op1) < 0)
7593                 warning (0, "right shift count is negative");
7594               else
7595                 {
7596                   if (!integer_zerop (op1))
7597                     short_shift = 1;
7598
7599                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7600                     warning (0, "right shift count >= width of type");
7601                 }
7602             }
7603
7604           /* Use the type of the value to be shifted.  */
7605           result_type = type0;
7606           /* Convert the shift-count to an integer, regardless of size
7607              of value being shifted.  */
7608           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7609             op1 = convert (integer_type_node, op1);
7610           /* Avoid converting op1 to result_type later.  */
7611           converted = 1;
7612         }
7613       break;
7614
7615     case LSHIFT_EXPR:
7616       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
7617         {
7618           if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0)
7619             {
7620               if (tree_int_cst_sgn (op1) < 0)
7621                 warning (0, "left shift count is negative");
7622
7623               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
7624                 warning (0, "left shift count >= width of type");
7625             }
7626
7627           /* Use the type of the value to be shifted.  */
7628           result_type = type0;
7629           /* Convert the shift-count to an integer, regardless of size
7630              of value being shifted.  */
7631           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
7632             op1 = convert (integer_type_node, op1);
7633           /* Avoid converting op1 to result_type later.  */
7634           converted = 1;
7635         }
7636       break;
7637
7638     case EQ_EXPR:
7639     case NE_EXPR:
7640       if (code0 == REAL_TYPE || code1 == REAL_TYPE)
7641         warning (OPT_Wfloat_equal,
7642                  "comparing floating point with == or != is unsafe");
7643       /* Result of comparison is always int,
7644          but don't convert the args to int!  */
7645       build_type = integer_type_node;
7646       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
7647            || code0 == COMPLEX_TYPE)
7648           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
7649               || code1 == COMPLEX_TYPE))
7650         short_compare = 1;
7651       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7652         {
7653           tree tt0 = TREE_TYPE (type0);
7654           tree tt1 = TREE_TYPE (type1);
7655           /* Anything compares with void *.  void * compares with anything.
7656              Otherwise, the targets must be compatible
7657              and both must be object or both incomplete.  */
7658           if (comp_target_types (type0, type1))
7659             result_type = common_pointer_type (type0, type1);
7660           else if (VOID_TYPE_P (tt0))
7661             {
7662               /* op0 != orig_op0 detects the case of something
7663                  whose value is 0 but which isn't a valid null ptr const.  */
7664               if (pedantic && (!integer_zerop (op0) || op0 != orig_op0)
7665                   && TREE_CODE (tt1) == FUNCTION_TYPE)
7666                 pedwarn ("ISO C forbids comparison of %<void *%>"
7667                          " with function pointer");
7668             }
7669           else if (VOID_TYPE_P (tt1))
7670             {
7671               if (pedantic && (!integer_zerop (op1) || op1 != orig_op1)
7672                   && TREE_CODE (tt0) == FUNCTION_TYPE)
7673                 pedwarn ("ISO C forbids comparison of %<void *%>"
7674                          " with function pointer");
7675             }
7676           else
7677             /* Avoid warning about the volatile ObjC EH puts on decls.  */
7678             if (!objc_ok)
7679               pedwarn ("comparison of distinct pointer types lacks a cast");
7680
7681           if (result_type == NULL_TREE)
7682             result_type = ptr_type_node;
7683         }
7684       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7685                && integer_zerop (op1))
7686         result_type = type0;
7687       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7688                && integer_zerop (op0))
7689         result_type = type1;
7690       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7691         {
7692           result_type = type0;
7693           pedwarn ("comparison between pointer and integer");
7694         }
7695       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7696         {
7697           result_type = type1;
7698           pedwarn ("comparison between pointer and integer");
7699         }
7700       break;
7701
7702     case LE_EXPR:
7703     case GE_EXPR:
7704     case LT_EXPR:
7705     case GT_EXPR:
7706       build_type = integer_type_node;
7707       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
7708           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
7709         short_compare = 1;
7710       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
7711         {
7712           if (comp_target_types (type0, type1))
7713             {
7714               result_type = common_pointer_type (type0, type1);
7715               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
7716                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
7717                 pedwarn ("comparison of complete and incomplete pointers");
7718               else if (pedantic
7719                        && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
7720                 pedwarn ("ISO C forbids ordered comparisons of pointers to functions");
7721             }
7722           else
7723             {
7724               result_type = ptr_type_node;
7725               pedwarn ("comparison of distinct pointer types lacks a cast");
7726             }
7727         }
7728       else if (code0 == POINTER_TYPE && TREE_CODE (op1) == INTEGER_CST
7729                && integer_zerop (op1))
7730         {
7731           result_type = type0;
7732           if (pedantic || extra_warnings)
7733             pedwarn ("ordered comparison of pointer with integer zero");
7734         }
7735       else if (code1 == POINTER_TYPE && TREE_CODE (op0) == INTEGER_CST
7736                && integer_zerop (op0))
7737         {
7738           result_type = type1;
7739           if (pedantic)
7740             pedwarn ("ordered comparison of pointer with integer zero");
7741         }
7742       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
7743         {
7744           result_type = type0;
7745           pedwarn ("comparison between pointer and integer");
7746         }
7747       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
7748         {
7749           result_type = type1;
7750           pedwarn ("comparison between pointer and integer");
7751         }
7752       break;
7753
7754     default:
7755       gcc_unreachable ();
7756     }
7757
7758   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
7759     return error_mark_node;
7760
7761   if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
7762       && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
7763           || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
7764                                                     TREE_TYPE (type1))))
7765     {
7766       binary_op_error (code);
7767       return error_mark_node;
7768     }
7769
7770   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
7771        || code0 == VECTOR_TYPE)
7772       &&
7773       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
7774        || code1 == VECTOR_TYPE))
7775     {
7776       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
7777
7778       if (shorten || common || short_compare)
7779         result_type = c_common_type (type0, type1);
7780
7781       /* For certain operations (which identify themselves by shorten != 0)
7782          if both args were extended from the same smaller type,
7783          do the arithmetic in that type and then extend.
7784
7785          shorten !=0 and !=1 indicates a bitwise operation.
7786          For them, this optimization is safe only if
7787          both args are zero-extended or both are sign-extended.
7788          Otherwise, we might change the result.
7789          Eg, (short)-1 | (unsigned short)-1 is (int)-1
7790          but calculated in (unsigned short) it would be (unsigned short)-1.  */
7791
7792       if (shorten && none_complex)
7793         {
7794           int unsigned0, unsigned1;
7795           tree arg0 = get_narrower (op0, &unsigned0);
7796           tree arg1 = get_narrower (op1, &unsigned1);
7797           /* UNS is 1 if the operation to be done is an unsigned one.  */
7798           int uns = TYPE_UNSIGNED (result_type);
7799           tree type;
7800
7801           final_type = result_type;
7802
7803           /* Handle the case that OP0 (or OP1) does not *contain* a conversion
7804              but it *requires* conversion to FINAL_TYPE.  */
7805
7806           if ((TYPE_PRECISION (TREE_TYPE (op0))
7807                == TYPE_PRECISION (TREE_TYPE (arg0)))
7808               && TREE_TYPE (op0) != final_type)
7809             unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
7810           if ((TYPE_PRECISION (TREE_TYPE (op1))
7811                == TYPE_PRECISION (TREE_TYPE (arg1)))
7812               && TREE_TYPE (op1) != final_type)
7813             unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
7814
7815           /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
7816
7817           /* For bitwise operations, signedness of nominal type
7818              does not matter.  Consider only how operands were extended.  */
7819           if (shorten == -1)
7820             uns = unsigned0;
7821
7822           /* Note that in all three cases below we refrain from optimizing
7823              an unsigned operation on sign-extended args.
7824              That would not be valid.  */
7825
7826           /* Both args variable: if both extended in same way
7827              from same width, do it in that width.
7828              Do it unsigned if args were zero-extended.  */
7829           if ((TYPE_PRECISION (TREE_TYPE (arg0))
7830                < TYPE_PRECISION (result_type))
7831               && (TYPE_PRECISION (TREE_TYPE (arg1))
7832                   == TYPE_PRECISION (TREE_TYPE (arg0)))
7833               && unsigned0 == unsigned1
7834               && (unsigned0 || !uns))
7835             result_type
7836               = c_common_signed_or_unsigned_type
7837               (unsigned0, c_common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
7838           else if (TREE_CODE (arg0) == INTEGER_CST
7839                    && (unsigned1 || !uns)
7840                    && (TYPE_PRECISION (TREE_TYPE (arg1))
7841                        < TYPE_PRECISION (result_type))
7842                    && (type
7843                        = c_common_signed_or_unsigned_type (unsigned1,
7844                                                            TREE_TYPE (arg1)),
7845                        int_fits_type_p (arg0, type)))
7846             result_type = type;
7847           else if (TREE_CODE (arg1) == INTEGER_CST
7848                    && (unsigned0 || !uns)
7849                    && (TYPE_PRECISION (TREE_TYPE (arg0))
7850                        < TYPE_PRECISION (result_type))
7851                    && (type
7852                        = c_common_signed_or_unsigned_type (unsigned0,
7853                                                            TREE_TYPE (arg0)),
7854                        int_fits_type_p (arg1, type)))
7855             result_type = type;
7856         }
7857
7858       /* Shifts can be shortened if shifting right.  */
7859
7860       if (short_shift)
7861         {
7862           int unsigned_arg;
7863           tree arg0 = get_narrower (op0, &unsigned_arg);
7864
7865           final_type = result_type;
7866
7867           if (arg0 == op0 && final_type == TREE_TYPE (op0))
7868             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
7869
7870           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
7871               /* We can shorten only if the shift count is less than the
7872                  number of bits in the smaller type size.  */
7873               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
7874               /* We cannot drop an unsigned shift after sign-extension.  */
7875               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
7876             {
7877               /* Do an unsigned shift if the operand was zero-extended.  */
7878               result_type
7879                 = c_common_signed_or_unsigned_type (unsigned_arg,
7880                                                     TREE_TYPE (arg0));
7881               /* Convert value-to-be-shifted to that type.  */
7882               if (TREE_TYPE (op0) != result_type)
7883                 op0 = convert (result_type, op0);
7884               converted = 1;
7885             }
7886         }
7887
7888       /* Comparison operations are shortened too but differently.
7889          They identify themselves by setting short_compare = 1.  */
7890
7891       if (short_compare)
7892         {
7893           /* Don't write &op0, etc., because that would prevent op0
7894              from being kept in a register.
7895              Instead, make copies of the our local variables and
7896              pass the copies by reference, then copy them back afterward.  */
7897           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
7898           enum tree_code xresultcode = resultcode;
7899           tree val
7900             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
7901
7902           if (val != 0)
7903             return val;
7904
7905           op0 = xop0, op1 = xop1;
7906           converted = 1;
7907           resultcode = xresultcode;
7908
7909           if (warn_sign_compare && skip_evaluation == 0)
7910             {
7911               int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0));
7912               int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1));
7913               int unsignedp0, unsignedp1;
7914               tree primop0 = get_narrower (op0, &unsignedp0);
7915               tree primop1 = get_narrower (op1, &unsignedp1);
7916
7917               xop0 = orig_op0;
7918               xop1 = orig_op1;
7919               STRIP_TYPE_NOPS (xop0);
7920               STRIP_TYPE_NOPS (xop1);
7921
7922               /* Give warnings for comparisons between signed and unsigned
7923                  quantities that may fail.
7924
7925                  Do the checking based on the original operand trees, so that
7926                  casts will be considered, but default promotions won't be.
7927
7928                  Do not warn if the comparison is being done in a signed type,
7929                  since the signed type will only be chosen if it can represent
7930                  all the values of the unsigned type.  */
7931               if (!TYPE_UNSIGNED (result_type))
7932                 /* OK */;
7933               /* Do not warn if both operands are the same signedness.  */
7934               else if (op0_signed == op1_signed)
7935                 /* OK */;
7936               else
7937                 {
7938                   tree sop, uop;
7939
7940                   if (op0_signed)
7941                     sop = xop0, uop = xop1;
7942                   else
7943                     sop = xop1, uop = xop0;
7944
7945                   /* Do not warn if the signed quantity is an
7946                      unsuffixed integer literal (or some static
7947                      constant expression involving such literals or a
7948                      conditional expression involving such literals)
7949                      and it is non-negative.  */
7950                   if (tree_expr_nonnegative_p (sop))
7951                     /* OK */;
7952                   /* Do not warn if the comparison is an equality operation,
7953                      the unsigned quantity is an integral constant, and it
7954                      would fit in the result if the result were signed.  */
7955                   else if (TREE_CODE (uop) == INTEGER_CST
7956                            && (resultcode == EQ_EXPR || resultcode == NE_EXPR)
7957                            && int_fits_type_p
7958                            (uop, c_common_signed_type (result_type)))
7959                     /* OK */;
7960                   /* Do not warn if the unsigned quantity is an enumeration
7961                      constant and its maximum value would fit in the result
7962                      if the result were signed.  */
7963                   else if (TREE_CODE (uop) == INTEGER_CST
7964                            && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE
7965                            && int_fits_type_p
7966                            (TYPE_MAX_VALUE (TREE_TYPE (uop)),
7967                             c_common_signed_type (result_type)))
7968                     /* OK */;
7969                   else
7970                     warning (0, "comparison between signed and unsigned");
7971                 }
7972
7973               /* Warn if two unsigned values are being compared in a size
7974                  larger than their original size, and one (and only one) is the
7975                  result of a `~' operator.  This comparison will always fail.
7976
7977                  Also warn if one operand is a constant, and the constant
7978                  does not have all bits set that are set in the ~ operand
7979                  when it is extended.  */
7980
7981               if ((TREE_CODE (primop0) == BIT_NOT_EXPR)
7982                   != (TREE_CODE (primop1) == BIT_NOT_EXPR))
7983                 {
7984                   if (TREE_CODE (primop0) == BIT_NOT_EXPR)
7985                     primop0 = get_narrower (TREE_OPERAND (primop0, 0),
7986                                             &unsignedp0);
7987                   else
7988                     primop1 = get_narrower (TREE_OPERAND (primop1, 0),
7989                                             &unsignedp1);
7990
7991                   if (host_integerp (primop0, 0) || host_integerp (primop1, 0))
7992                     {
7993                       tree primop;
7994                       HOST_WIDE_INT constant, mask;
7995                       int unsignedp, bits;
7996
7997                       if (host_integerp (primop0, 0))
7998                         {
7999                           primop = primop1;
8000                           unsignedp = unsignedp1;
8001                           constant = tree_low_cst (primop0, 0);
8002                         }
8003                       else
8004                         {
8005                           primop = primop0;
8006                           unsignedp = unsignedp0;
8007                           constant = tree_low_cst (primop1, 0);
8008                         }
8009
8010                       bits = TYPE_PRECISION (TREE_TYPE (primop));
8011                       if (bits < TYPE_PRECISION (result_type)
8012                           && bits < HOST_BITS_PER_WIDE_INT && unsignedp)
8013                         {
8014                           mask = (~(HOST_WIDE_INT) 0) << bits;
8015                           if ((mask & constant) != mask)
8016                             warning (0, "comparison of promoted ~unsigned with constant");
8017                         }
8018                     }
8019                   else if (unsignedp0 && unsignedp1
8020                            && (TYPE_PRECISION (TREE_TYPE (primop0))
8021                                < TYPE_PRECISION (result_type))
8022                            && (TYPE_PRECISION (TREE_TYPE (primop1))
8023                                < TYPE_PRECISION (result_type)))
8024                     warning (0, "comparison of promoted ~unsigned with unsigned");
8025                 }
8026             }
8027         }
8028     }
8029
8030   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
8031      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
8032      Then the expression will be built.
8033      It will be given type FINAL_TYPE if that is nonzero;
8034      otherwise, it will be given type RESULT_TYPE.  */
8035
8036   if (!result_type)
8037     {
8038       binary_op_error (code);
8039       return error_mark_node;
8040     }
8041
8042   if (!converted)
8043     {
8044       if (TREE_TYPE (op0) != result_type)
8045         op0 = convert (result_type, op0);
8046       if (TREE_TYPE (op1) != result_type)
8047         op1 = convert (result_type, op1);
8048
8049       /* This can happen if one operand has a vector type, and the other
8050          has a different type.  */
8051       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
8052         return error_mark_node;
8053     }
8054
8055   if (build_type == NULL_TREE)
8056     build_type = result_type;
8057
8058   {
8059     tree result = build2 (resultcode, build_type, op0, op1);
8060
8061     /* Treat expressions in initializers specially as they can't trap.  */
8062     result = require_constant_value ? fold_initializer (result)
8063                                     : fold (result);
8064
8065     if (final_type != 0)
8066       result = convert (final_type, result);
8067     return result;
8068   }
8069 }
8070
8071
8072 /* Convert EXPR to be a truth-value, validating its type for this
8073    purpose.  */
8074
8075 tree
8076 c_objc_common_truthvalue_conversion (tree expr)
8077 {
8078   switch (TREE_CODE (TREE_TYPE (expr)))
8079     {
8080     case ARRAY_TYPE:
8081       error ("used array that cannot be converted to pointer where scalar is required");
8082       return error_mark_node;
8083
8084     case RECORD_TYPE:
8085       error ("used struct type value where scalar is required");
8086       return error_mark_node;
8087
8088     case UNION_TYPE:
8089       error ("used union type value where scalar is required");
8090       return error_mark_node;
8091
8092     case FUNCTION_TYPE:
8093       gcc_unreachable ();
8094
8095     default:
8096       break;
8097     }
8098
8099   /* ??? Should we also give an error for void and vectors rather than
8100      leaving those to give errors later?  */
8101   return c_common_truthvalue_conversion (expr);
8102 }