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