gcc/c-typeck.c

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