gcc/c-typeck.c

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