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