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