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