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