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