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