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 (target);
 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 C1X 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       fundecl = function;
2720     }
2721   if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE)
2722     function = function_to_pointer_conversion (loc, function);
2723
2724   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
2725      expressions, like those used for ObjC messenger dispatches.  */
2726   if (!VEC_empty (tree, params))
2727     function = objc_rewrite_function_call (function,
2728                                            VEC_index (tree, params, 0));
2729
2730   function = c_fully_fold (function, false, NULL);
2731
2732   fntype = TREE_TYPE (function);
2733
2734   if (TREE_CODE (fntype) == ERROR_MARK)
2735     return error_mark_node;
2736
2737   if (!(TREE_CODE (fntype) == POINTER_TYPE
2738         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
2739     {
2740       error_at (loc, "called object %qE is not a function", function);
2741       return error_mark_node;
2742     }
2743
2744   if (fundecl && TREE_THIS_VOLATILE (fundecl))
2745     current_function_returns_abnormally = 1;
2746
2747   /* fntype now gets the type of function pointed to.  */
2748   fntype = TREE_TYPE (fntype);
2749
2750   /* Convert the parameters to the types declared in the
2751      function prototype, or apply default promotions.  */
2752
2753   nargs = convert_arguments (TYPE_ARG_TYPES (fntype), params, origtypes,
2754                              function, fundecl);
2755   if (nargs < 0)
2756     return error_mark_node;
2757
2758   /* Check that the function is called through a compatible prototype.
2759      If it is not, replace the call by a trap, wrapped up in a compound
2760      expression if necessary.  This has the nice side-effect to prevent
2761      the tree-inliner from generating invalid assignment trees which may
2762      blow up in the RTL expander later.  */
2763   if (CONVERT_EXPR_P (function)
2764       && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR
2765       && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL
2766       && !comptypes (fntype, TREE_TYPE (tem)))
2767     {
2768       tree return_type = TREE_TYPE (fntype);
2769       tree trap = build_function_call (loc,
2770                                        builtin_decl_explicit (BUILT_IN_TRAP),
2771                                        NULL_TREE);
2772       int i;
2773
2774       /* This situation leads to run-time undefined behavior.  We can't,
2775          therefore, simply error unless we can prove that all possible
2776          executions of the program must execute the code.  */
2777       if (warning_at (loc, 0, "function called through a non-compatible type"))
2778         /* We can, however, treat "undefined" any way we please.
2779            Call abort to encourage the user to fix the program.  */
2780         inform (loc, "if this code is reached, the program will abort");
2781       /* Before the abort, allow the function arguments to exit or
2782          call longjmp.  */
2783       for (i = 0; i < nargs; i++)
2784         trap = build2 (COMPOUND_EXPR, void_type_node,
2785                        VEC_index (tree, params, i), trap);
2786
2787       if (VOID_TYPE_P (return_type))
2788         {
2789           if (TYPE_QUALS (return_type) != TYPE_UNQUALIFIED)
2790             pedwarn (loc, 0,
2791                      "function with qualified void return type called");
2792           return trap;
2793         }
2794       else
2795         {
2796           tree rhs;
2797
2798           if (AGGREGATE_TYPE_P (return_type))
2799             rhs = build_compound_literal (loc, return_type,
2800                                           build_constructor (return_type, 0),
2801                                           false);
2802           else
2803             rhs = build_zero_cst (return_type);
2804
2805           return require_complete_type (build2 (COMPOUND_EXPR, return_type,
2806                                                 trap, rhs));
2807         }
2808     }
2809
2810   argarray = VEC_address (tree, params);
2811
2812   /* Check that arguments to builtin functions match the expectations.  */
2813   if (fundecl
2814       && DECL_BUILT_IN (fundecl)
2815       && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL
2816       && !check_builtin_function_arguments (fundecl, nargs, argarray))
2817     return error_mark_node;
2818
2819   /* Check that the arguments to the function are valid.  */
2820   check_function_arguments (fntype, nargs, argarray);
2821
2822   if (name != NULL_TREE
2823       && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
2824     {
2825       if (require_constant_value)
2826         result =
2827           fold_build_call_array_initializer_loc (loc, TREE_TYPE (fntype),
2828                                                  function, nargs, argarray);
2829       else
2830         result = fold_build_call_array_loc (loc, TREE_TYPE (fntype),
2831                                             function, nargs, argarray);
2832       if (TREE_CODE (result) == NOP_EXPR
2833           && TREE_CODE (TREE_OPERAND (result, 0)) == INTEGER_CST)
2834         STRIP_TYPE_NOPS (result);
2835     }
2836   else
2837     result = build_call_array_loc (loc, TREE_TYPE (fntype),
2838                                    function, nargs, argarray);
2839
2840   if (VOID_TYPE_P (TREE_TYPE (result)))
2841     {
2842       if (TYPE_QUALS (TREE_TYPE (result)) != TYPE_UNQUALIFIED)
2843         pedwarn (loc, 0,
2844                  "function with qualified void return type called");
2845       return result;
2846     }
2847   return require_complete_type (result);
2848 }
2849
2850 /* Build a VEC_PERM_EXPR if V0, V1 and MASK are not error_mark_nodes
2851    and have vector types, V0 has the same type as V1, and the number of
2852    elements of V0, V1, MASK is the same.
2853
2854    In case V1 is a NULL_TREE it is assumed that __builtin_shuffle was
2855    called with two arguments.  In this case implementation passes the
2856    first argument twice in order to share the same tree code.  This fact
2857    could enable the mask-values being twice the vector length.  This is
2858    an implementation accident and this semantics is not guaranteed to
2859    the user.  */
2860 tree
2861 c_build_vec_perm_expr (location_t loc, tree v0, tree v1, tree mask)
2862 {
2863   tree ret;
2864   bool wrap = true;
2865   bool maybe_const = false;
2866   bool two_arguments = false;
2867
2868   if (v1 == NULL_TREE)
2869     {
2870       two_arguments = true;
2871       v1 = v0;
2872     }
2873
2874   if (v0 == error_mark_node || v1 == error_mark_node
2875       || mask == error_mark_node)
2876     return error_mark_node;
2877
2878   if (TREE_CODE (TREE_TYPE (mask)) != VECTOR_TYPE
2879       || TREE_CODE (TREE_TYPE (TREE_TYPE (mask))) != INTEGER_TYPE)
2880     {
2881       error_at (loc, "__builtin_shuffle last argument must "
2882                      "be an integer vector");
2883       return error_mark_node;
2884     }
2885
2886   if (TREE_CODE (TREE_TYPE (v0)) != VECTOR_TYPE
2887       || TREE_CODE (TREE_TYPE (v1)) != VECTOR_TYPE)
2888     {
2889       error_at (loc, "__builtin_shuffle arguments must be vectors");
2890       return error_mark_node;
2891     }
2892
2893   if (TYPE_MAIN_VARIANT (TREE_TYPE (v0)) != TYPE_MAIN_VARIANT (TREE_TYPE (v1)))
2894     {
2895       error_at (loc, "__builtin_shuffle argument vectors must be of "
2896                      "the same type");
2897       return error_mark_node;
2898     }
2899
2900   if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (v0))
2901       != TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask))
2902       && TYPE_VECTOR_SUBPARTS (TREE_TYPE (v1))
2903          != TYPE_VECTOR_SUBPARTS (TREE_TYPE (mask)))
2904     {
2905       error_at (loc, "__builtin_shuffle number of elements of the "
2906                      "argument vector(s) and the mask vector should "
2907                      "be the same");
2908       return error_mark_node;
2909     }
2910
2911   if (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (v0))))
2912       != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (TREE_TYPE (mask)))))
2913     {
2914       error_at (loc, "__builtin_shuffle argument vector(s) inner type "
2915                      "must have the same size as inner type of the mask");
2916       return error_mark_node;
2917     }
2918
2919   /* Avoid C_MAYBE_CONST_EXPRs inside VEC_PERM_EXPR.  */
2920   v0 = c_fully_fold (v0, false, &maybe_const);
2921   wrap &= maybe_const;
2922
2923   if (two_arguments)
2924     v1 = v0 = save_expr (v0);
2925   else
2926     {
2927       v1 = c_fully_fold (v1, false, &maybe_const);
2928       wrap &= maybe_const;
2929     }
2930
2931   mask = c_fully_fold (mask, false, &maybe_const);
2932   wrap &= maybe_const;
2933
2934   ret = build3_loc (loc, VEC_PERM_EXPR, TREE_TYPE (v0), v0, v1, mask);
2935
2936   if (!wrap)
2937     ret = c_wrap_maybe_const (ret, true);
2938
2939   return ret;
2940 }
2941 \f
2942 /* Convert the argument expressions in the vector VALUES
2943    to the types in the list TYPELIST.
2944
2945    If TYPELIST is exhausted, or when an element has NULL as its type,
2946    perform the default conversions.
2947
2948    ORIGTYPES is the original types of the expressions in VALUES.  This
2949    holds the type of enum values which have been converted to integral
2950    types.  It may be NULL.
2951
2952    FUNCTION is a tree for the called function.  It is used only for
2953    error messages, where it is formatted with %qE.
2954
2955    This is also where warnings about wrong number of args are generated.
2956
2957    Returns the actual number of arguments processed (which may be less
2958    than the length of VALUES in some error situations), or -1 on
2959    failure.  */
2960
2961 static int
2962 convert_arguments (tree typelist, VEC(tree,gc) *values,
2963                    VEC(tree,gc) *origtypes, tree function, tree fundecl)
2964 {
2965   tree typetail, val;
2966   unsigned int parmnum;
2967   bool error_args = false;
2968   const bool type_generic = fundecl
2969     && lookup_attribute ("type generic", TYPE_ATTRIBUTES(TREE_TYPE (fundecl)));
2970   bool type_generic_remove_excess_precision = false;
2971   tree selector;
2972
2973   /* Change pointer to function to the function itself for
2974      diagnostics.  */
2975   if (TREE_CODE (function) == ADDR_EXPR
2976       && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
2977     function = TREE_OPERAND (function, 0);
2978
2979   /* Handle an ObjC selector specially for diagnostics.  */
2980   selector = objc_message_selector ();
2981
2982   /* For type-generic built-in functions, determine whether excess
2983      precision should be removed (classification) or not
2984      (comparison).  */
2985   if (type_generic
2986       && DECL_BUILT_IN (fundecl)
2987       && DECL_BUILT_IN_CLASS (fundecl) == BUILT_IN_NORMAL)
2988     {
2989       switch (DECL_FUNCTION_CODE (fundecl))
2990         {
2991         case BUILT_IN_ISFINITE:
2992         case BUILT_IN_ISINF:
2993         case BUILT_IN_ISINF_SIGN:
2994         case BUILT_IN_ISNAN:
2995         case BUILT_IN_ISNORMAL:
2996         case BUILT_IN_FPCLASSIFY:
2997           type_generic_remove_excess_precision = true;
2998           break;
2999
3000         default:
3001           type_generic_remove_excess_precision = false;
3002           break;
3003         }
3004     }
3005
3006   /* Scan the given expressions and types, producing individual
3007      converted arguments.  */
3008
3009   for (typetail = typelist, parmnum = 0;
3010        VEC_iterate (tree, values, parmnum, val);
3011        ++parmnum)
3012     {
3013       tree type = typetail ? TREE_VALUE (typetail) : 0;
3014       tree valtype = TREE_TYPE (val);
3015       tree rname = function;
3016       int argnum = parmnum + 1;
3017       const char *invalid_func_diag;
3018       bool excess_precision = false;
3019       bool npc;
3020       tree parmval;
3021
3022       if (type == void_type_node)
3023         {
3024           if (selector)
3025             error_at (input_location,
3026                       "too many arguments to method %qE", selector);
3027           else
3028             error_at (input_location,
3029                       "too many arguments to function %qE", function);
3030
3031           if (fundecl && !DECL_BUILT_IN (fundecl))
3032             inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
3033           return parmnum;
3034         }
3035
3036       if (selector && argnum > 2)
3037         {
3038           rname = selector;
3039           argnum -= 2;
3040         }
3041
3042       npc = null_pointer_constant_p (val);
3043
3044       /* If there is excess precision and a prototype, convert once to
3045          the required type rather than converting via the semantic
3046          type.  Likewise without a prototype a float value represented
3047          as long double should be converted once to double.  But for
3048          type-generic classification functions excess precision must
3049          be removed here.  */
3050       if (TREE_CODE (val) == EXCESS_PRECISION_EXPR
3051           && (type || !type_generic || !type_generic_remove_excess_precision))
3052         {
3053           val = TREE_OPERAND (val, 0);
3054           excess_precision = true;
3055         }
3056       val = c_fully_fold (val, false, NULL);
3057       STRIP_TYPE_NOPS (val);
3058
3059       val = require_complete_type (val);
3060
3061       if (type != 0)
3062         {
3063           /* Formal parm type is specified by a function prototype.  */
3064
3065           if (type == error_mark_node || !COMPLETE_TYPE_P (type))
3066             {
3067               error ("type of formal parameter %d is incomplete", parmnum + 1);
3068               parmval = val;
3069             }
3070           else
3071             {
3072               tree origtype;
3073
3074               /* Optionally warn about conversions that
3075                  differ from the default conversions.  */
3076               if (warn_traditional_conversion || warn_traditional)
3077                 {
3078                   unsigned int formal_prec = TYPE_PRECISION (type);
3079
3080                   if (INTEGRAL_TYPE_P (type)
3081                       && TREE_CODE (valtype) == REAL_TYPE)
3082                     warning (0, "passing argument %d of %qE as integer "
3083                              "rather than floating due to prototype",
3084                              argnum, rname);
3085                   if (INTEGRAL_TYPE_P (type)
3086                       && TREE_CODE (valtype) == COMPLEX_TYPE)
3087                     warning (0, "passing argument %d of %qE as integer "
3088                              "rather than complex due to prototype",
3089                              argnum, rname);
3090                   else if (TREE_CODE (type) == COMPLEX_TYPE
3091                            && TREE_CODE (valtype) == REAL_TYPE)
3092                     warning (0, "passing argument %d of %qE as complex "
3093                              "rather than floating due to prototype",
3094                              argnum, rname);
3095                   else if (TREE_CODE (type) == REAL_TYPE
3096                            && INTEGRAL_TYPE_P (valtype))
3097                     warning (0, "passing argument %d of %qE as floating "
3098                              "rather than integer due to prototype",
3099                              argnum, rname);
3100                   else if (TREE_CODE (type) == COMPLEX_TYPE
3101                            && INTEGRAL_TYPE_P (valtype))
3102                     warning (0, "passing argument %d of %qE as complex "
3103                              "rather than integer due to prototype",
3104                              argnum, rname);
3105                   else if (TREE_CODE (type) == REAL_TYPE
3106                            && TREE_CODE (valtype) == COMPLEX_TYPE)
3107                     warning (0, "passing argument %d of %qE as floating "
3108                              "rather than complex due to prototype",
3109                              argnum, rname);
3110                   /* ??? At some point, messages should be written about
3111                      conversions between complex types, but that's too messy
3112                      to do now.  */
3113                   else if (TREE_CODE (type) == REAL_TYPE
3114                            && TREE_CODE (valtype) == REAL_TYPE)
3115                     {
3116                       /* Warn if any argument is passed as `float',
3117                          since without a prototype it would be `double'.  */
3118                       if (formal_prec == TYPE_PRECISION (float_type_node)
3119                           && type != dfloat32_type_node)
3120                         warning (0, "passing argument %d of %qE as %<float%> "
3121                                  "rather than %<double%> due to prototype",
3122                                  argnum, rname);
3123
3124                       /* Warn if mismatch between argument and prototype
3125                          for decimal float types.  Warn of conversions with
3126                          binary float types and of precision narrowing due to
3127                          prototype. */
3128                       else if (type != valtype
3129                                && (type == dfloat32_type_node
3130                                    || type == dfloat64_type_node
3131                                    || type == dfloat128_type_node
3132                                    || valtype == dfloat32_type_node
3133                                    || valtype == dfloat64_type_node
3134                                    || valtype == dfloat128_type_node)
3135                                && (formal_prec
3136                                    <= TYPE_PRECISION (valtype)
3137                                    || (type == dfloat128_type_node
3138                                        && (valtype
3139                                            != dfloat64_type_node
3140                                            && (valtype
3141                                                != dfloat32_type_node)))
3142                                    || (type == dfloat64_type_node
3143                                        && (valtype
3144                                            != dfloat32_type_node))))
3145                         warning (0, "passing argument %d of %qE as %qT "
3146                                  "rather than %qT due to prototype",
3147                                  argnum, rname, type, valtype);
3148
3149                     }
3150                   /* Detect integer changing in width or signedness.
3151                      These warnings are only activated with
3152                      -Wtraditional-conversion, not with -Wtraditional.  */
3153                   else if (warn_traditional_conversion && INTEGRAL_TYPE_P (type)
3154                            && INTEGRAL_TYPE_P (valtype))
3155                     {
3156                       tree would_have_been = default_conversion (val);
3157                       tree type1 = TREE_TYPE (would_have_been);
3158
3159                       if (TREE_CODE (type) == ENUMERAL_TYPE
3160                           && (TYPE_MAIN_VARIANT (type)
3161                               == TYPE_MAIN_VARIANT (valtype)))
3162                         /* No warning if function asks for enum
3163                            and the actual arg is that enum type.  */
3164                         ;
3165                       else if (formal_prec != TYPE_PRECISION (type1))
3166                         warning (OPT_Wtraditional_conversion,
3167                                  "passing argument %d of %qE "
3168                                  "with different width due to prototype",
3169                                  argnum, rname);
3170                       else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1))
3171                         ;
3172                       /* Don't complain if the formal parameter type
3173                          is an enum, because we can't tell now whether
3174                          the value was an enum--even the same enum.  */
3175                       else if (TREE_CODE (type) == ENUMERAL_TYPE)
3176                         ;
3177                       else if (TREE_CODE (val) == INTEGER_CST
3178                                && int_fits_type_p (val, type))
3179                         /* Change in signedness doesn't matter
3180                            if a constant value is unaffected.  */
3181                         ;
3182                       /* If the value is extended from a narrower
3183                          unsigned type, it doesn't matter whether we
3184                          pass it as signed or unsigned; the value
3185                          certainly is the same either way.  */
3186                       else if (TYPE_PRECISION (valtype) < TYPE_PRECISION (type)
3187                                && TYPE_UNSIGNED (valtype))
3188                         ;
3189                       else if (TYPE_UNSIGNED (type))
3190                         warning (OPT_Wtraditional_conversion,
3191                                  "passing argument %d of %qE "
3192                                  "as unsigned due to prototype",
3193                                  argnum, rname);
3194                       else
3195                         warning (OPT_Wtraditional_conversion,
3196                                  "passing argument %d of %qE "
3197                                  "as signed due to prototype", argnum, rname);
3198                     }
3199                 }
3200
3201               /* Possibly restore an EXCESS_PRECISION_EXPR for the
3202                  sake of better warnings from convert_and_check.  */
3203               if (excess_precision)
3204                 val = build1 (EXCESS_PRECISION_EXPR, valtype, val);
3205               origtype = (origtypes == NULL
3206                           ? NULL_TREE
3207                           : VEC_index (tree, origtypes, parmnum));
3208               parmval = convert_for_assignment (input_location, type, val,
3209                                                 origtype, ic_argpass, npc,
3210                                                 fundecl, function,
3211                                                 parmnum + 1);
3212
3213               if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0)
3214                   && INTEGRAL_TYPE_P (type)
3215                   && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
3216                 parmval = default_conversion (parmval);
3217             }
3218         }
3219       else if (TREE_CODE (valtype) == REAL_TYPE
3220                && (TYPE_PRECISION (valtype)
3221                    < TYPE_PRECISION (double_type_node))
3222                && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (valtype)))
3223         {
3224           if (type_generic)
3225             parmval = val;
3226           else
3227             {
3228               /* Convert `float' to `double'.  */
3229               if (warn_double_promotion && !c_inhibit_evaluation_warnings)
3230                 warning (OPT_Wdouble_promotion,
3231                          "implicit conversion from %qT to %qT when passing "
3232                          "argument to function",
3233                          valtype, double_type_node);
3234               parmval = convert (double_type_node, val);
3235             }
3236         }
3237       else if (excess_precision && !type_generic)
3238         /* A "double" argument with excess precision being passed
3239            without a prototype or in variable arguments.  */
3240         parmval = convert (valtype, val);
3241       else if ((invalid_func_diag =
3242                 targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val)))
3243         {
3244           error (invalid_func_diag);
3245           return -1;
3246         }
3247       else
3248         /* Convert `short' and `char' to full-size `int'.  */
3249         parmval = default_conversion (val);
3250
3251       VEC_replace (tree, values, parmnum, parmval);
3252       if (parmval == error_mark_node)
3253         error_args = true;
3254
3255       if (typetail)
3256         typetail = TREE_CHAIN (typetail);
3257     }
3258
3259   gcc_assert (parmnum == VEC_length (tree, values));
3260
3261   if (typetail != 0 && TREE_VALUE (typetail) != void_type_node)
3262     {
3263       error_at (input_location,
3264                 "too few arguments to function %qE", function);
3265       if (fundecl && !DECL_BUILT_IN (fundecl))
3266         inform (DECL_SOURCE_LOCATION (fundecl), "declared here");
3267       return -1;
3268     }
3269
3270   return error_args ? -1 : (int) parmnum;
3271 }
3272 \f
3273 /* This is the entry point used by the parser to build unary operators
3274    in the input.  CODE, a tree_code, specifies the unary operator, and
3275    ARG is the operand.  For unary plus, the C parser currently uses
3276    CONVERT_EXPR for code.
3277
3278    LOC is the location to use for the tree generated.
3279 */
3280
3281 struct c_expr
3282 parser_build_unary_op (location_t loc, enum tree_code code, struct c_expr arg)
3283 {
3284   struct c_expr result;
3285
3286   result.value = build_unary_op (loc, code, arg.value, 0);
3287   result.original_code = code;
3288   result.original_type = NULL;
3289
3290   if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value))
3291     overflow_warning (loc, result.value);
3292
3293   return result;
3294 }
3295
3296 /* This is the entry point used by the parser to build binary operators
3297    in the input.  CODE, a tree_code, specifies the binary operator, and
3298    ARG1 and ARG2 are the operands.  In addition to constructing the
3299    expression, we check for operands that were written with other binary
3300    operators in a way that is likely to confuse the user.
3301
3302    LOCATION is the location of the binary operator.  */
3303
3304 struct c_expr
3305 parser_build_binary_op (location_t location, enum tree_code code,
3306                         struct c_expr arg1, struct c_expr arg2)
3307 {
3308   struct c_expr result;
3309
3310   enum tree_code code1 = arg1.original_code;
3311   enum tree_code code2 = arg2.original_code;
3312   tree type1 = (arg1.original_type
3313                 ? arg1.original_type
3314                 : TREE_TYPE (arg1.value));
3315   tree type2 = (arg2.original_type
3316                 ? arg2.original_type
3317                 : TREE_TYPE (arg2.value));
3318
3319   result.value = build_binary_op (location, code,
3320                                   arg1.value, arg2.value, 1);
3321   result.original_code = code;
3322   result.original_type = NULL;
3323
3324   if (TREE_CODE (result.value) == ERROR_MARK)
3325     return result;
3326
3327   if (location != UNKNOWN_LOCATION)
3328     protected_set_expr_location (result.value, location);
3329
3330   /* Check for cases such as x+y<<z which users are likely
3331      to misinterpret.  */
3332   if (warn_parentheses)
3333     warn_about_parentheses (code, code1, arg1.value, code2, arg2.value);
3334
3335   if (warn_logical_op)
3336     warn_logical_operator (input_location, code, TREE_TYPE (result.value),
3337                            code1, arg1.value, code2, arg2.value);
3338
3339   /* Warn about comparisons against string literals, with the exception
3340      of testing for equality or inequality of a string literal with NULL.  */
3341   if (code == EQ_EXPR || code == NE_EXPR)
3342     {
3343       if ((code1 == STRING_CST && !integer_zerop (arg2.value))
3344           || (code2 == STRING_CST && !integer_zerop (arg1.value)))
3345         warning_at (location, OPT_Waddress,
3346                     "comparison with string literal results in unspecified behavior");
3347     }
3348   else if (TREE_CODE_CLASS (code) == tcc_comparison
3349            && (code1 == STRING_CST || code2 == STRING_CST))
3350     warning_at (location, OPT_Waddress,
3351                 "comparison with string literal results in unspecified behavior");
3352
3353   if (TREE_OVERFLOW_P (result.value)
3354       && !TREE_OVERFLOW_P (arg1.value)
3355       && !TREE_OVERFLOW_P (arg2.value))
3356     overflow_warning (location, result.value);
3357
3358   /* Warn about comparisons of different enum types.  */
3359   if (warn_enum_compare
3360       && TREE_CODE_CLASS (code) == tcc_comparison
3361       && TREE_CODE (type1) == ENUMERAL_TYPE
3362       && TREE_CODE (type2) == ENUMERAL_TYPE
3363       && TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
3364     warning_at (location, OPT_Wenum_compare,
3365                 "comparison between %qT and %qT",
3366                 type1, type2);
3367
3368   return result;
3369 }
3370 \f
3371 /* Return a tree for the difference of pointers OP0 and OP1.
3372    The resulting tree has type int.  */
3373
3374 static tree
3375 pointer_diff (location_t loc, tree op0, tree op1)
3376 {
3377   tree restype = ptrdiff_type_node;
3378   tree result, inttype;
3379
3380   addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op0)));
3381   addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (TREE_TYPE (op1)));
3382   tree target_type = TREE_TYPE (TREE_TYPE (op0));
3383   tree con0, con1, lit0, lit1;
3384   tree orig_op1 = op1;
3385
3386   /* If the operands point into different address spaces, we need to
3387      explicitly convert them to pointers into the common address space
3388      before we can subtract the numerical address values.  */
3389   if (as0 != as1)
3390     {
3391       addr_space_t as_common;
3392       tree common_type;
3393
3394       /* Determine the common superset address space.  This is guaranteed
3395          to exist because the caller verified that comp_target_types
3396          returned non-zero.  */
3397       if (!addr_space_superset (as0, as1, &as_common))
3398         gcc_unreachable ();
3399
3400       common_type = common_pointer_type (TREE_TYPE (op0), TREE_TYPE (op1));
3401       op0 = convert (common_type, op0);
3402       op1 = convert (common_type, op1);
3403     }
3404
3405   /* Determine integer type to perform computations in.  This will usually
3406      be the same as the result type (ptrdiff_t), but may need to be a wider
3407      type if pointers for the address space are wider than ptrdiff_t.  */
3408   if (TYPE_PRECISION (restype) < TYPE_PRECISION (TREE_TYPE (op0)))
3409     inttype = lang_hooks.types.type_for_size
3410                 (TYPE_PRECISION (TREE_TYPE (op0)), 0);
3411   else
3412     inttype = restype;
3413
3414
3415   if (TREE_CODE (target_type) == VOID_TYPE)
3416     pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3417              "pointer of type %<void *%> used in subtraction");
3418   if (TREE_CODE (target_type) == FUNCTION_TYPE)
3419     pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3420              "pointer to a function used in subtraction");
3421
3422   /* If the conversion to ptrdiff_type does anything like widening or
3423      converting a partial to an integral mode, we get a convert_expression
3424      that is in the way to do any simplifications.
3425      (fold-const.c doesn't know that the extra bits won't be needed.
3426      split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a
3427      different mode in place.)
3428      So first try to find a common term here 'by hand'; we want to cover
3429      at least the cases that occur in legal static initializers.  */
3430   if (CONVERT_EXPR_P (op0)
3431       && (TYPE_PRECISION (TREE_TYPE (op0))
3432           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))))
3433     con0 = TREE_OPERAND (op0, 0);
3434   else
3435     con0 = op0;
3436   if (CONVERT_EXPR_P (op1)
3437       && (TYPE_PRECISION (TREE_TYPE (op1))
3438           == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))))
3439     con1 = TREE_OPERAND (op1, 0);
3440   else
3441     con1 = op1;
3442
3443   if (TREE_CODE (con0) == PLUS_EXPR)
3444     {
3445       lit0 = TREE_OPERAND (con0, 1);
3446       con0 = TREE_OPERAND (con0, 0);
3447     }
3448   else
3449     lit0 = integer_zero_node;
3450
3451   if (TREE_CODE (con1) == PLUS_EXPR)
3452     {
3453       lit1 = TREE_OPERAND (con1, 1);
3454       con1 = TREE_OPERAND (con1, 0);
3455     }
3456   else
3457     lit1 = integer_zero_node;
3458
3459   if (operand_equal_p (con0, con1, 0))
3460     {
3461       op0 = lit0;
3462       op1 = lit1;
3463     }
3464
3465
3466   /* First do the subtraction as integers;
3467      then drop through to build the divide operator.
3468      Do not do default conversions on the minus operator
3469      in case restype is a short type.  */
3470
3471   op0 = build_binary_op (loc,
3472                          MINUS_EXPR, convert (inttype, op0),
3473                          convert (inttype, op1), 0);
3474   /* This generates an error if op1 is pointer to incomplete type.  */
3475   if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1))))
3476     error_at (loc, "arithmetic on pointer to an incomplete type");
3477
3478   /* This generates an error if op0 is pointer to incomplete type.  */
3479   op1 = c_size_in_bytes (target_type);
3480
3481   /* Divide by the size, in easiest possible way.  */
3482   result = fold_build2_loc (loc, EXACT_DIV_EXPR, inttype,
3483                             op0, convert (inttype, op1));
3484
3485   /* Convert to final result type if necessary.  */
3486   return convert (restype, result);
3487 }
3488 \f
3489 /* Construct and perhaps optimize a tree representation
3490    for a unary operation.  CODE, a tree_code, specifies the operation
3491    and XARG is the operand.
3492    For any CODE other than ADDR_EXPR, FLAG nonzero suppresses
3493    the default promotions (such as from short to int).
3494    For ADDR_EXPR, the default promotions are not applied; FLAG nonzero
3495    allows non-lvalues; this is only used to handle conversion of non-lvalue
3496    arrays to pointers in C99.
3497
3498    LOCATION is the location of the operator.  */
3499
3500 tree
3501 build_unary_op (location_t location,
3502                 enum tree_code code, tree xarg, int flag)
3503 {
3504   /* No default_conversion here.  It causes trouble for ADDR_EXPR.  */
3505   tree arg = xarg;
3506   tree argtype = 0;
3507   enum tree_code typecode;
3508   tree val;
3509   tree ret = error_mark_node;
3510   tree eptype = NULL_TREE;
3511   int noconvert = flag;
3512   const char *invalid_op_diag;
3513   bool int_operands;
3514
3515   int_operands = EXPR_INT_CONST_OPERANDS (xarg);
3516   if (int_operands)
3517     arg = remove_c_maybe_const_expr (arg);
3518
3519   if (code != ADDR_EXPR)
3520     arg = require_complete_type (arg);
3521
3522   typecode = TREE_CODE (TREE_TYPE (arg));
3523   if (typecode == ERROR_MARK)
3524     return error_mark_node;
3525   if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE)
3526     typecode = INTEGER_TYPE;
3527
3528   if ((invalid_op_diag
3529        = targetm.invalid_unary_op (code, TREE_TYPE (xarg))))
3530     {
3531       error_at (location, invalid_op_diag);
3532       return error_mark_node;
3533     }
3534
3535   if (TREE_CODE (arg) == EXCESS_PRECISION_EXPR)
3536     {
3537       eptype = TREE_TYPE (arg);
3538       arg = TREE_OPERAND (arg, 0);
3539     }
3540
3541   switch (code)
3542     {
3543     case CONVERT_EXPR:
3544       /* This is used for unary plus, because a CONVERT_EXPR
3545          is enough to prevent anybody from looking inside for
3546          associativity, but won't generate any code.  */
3547       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3548             || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3549             || typecode == VECTOR_TYPE))
3550         {
3551           error_at (location, "wrong type argument to unary plus");
3552           return error_mark_node;
3553         }
3554       else if (!noconvert)
3555         arg = default_conversion (arg);
3556       arg = non_lvalue_loc (location, arg);
3557       break;
3558
3559     case NEGATE_EXPR:
3560       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3561             || typecode == FIXED_POINT_TYPE || typecode == COMPLEX_TYPE
3562             || typecode == VECTOR_TYPE))
3563         {
3564           error_at (location, "wrong type argument to unary minus");
3565           return error_mark_node;
3566         }
3567       else if (!noconvert)
3568         arg = default_conversion (arg);
3569       break;
3570
3571     case BIT_NOT_EXPR:
3572       /* ~ works on integer types and non float vectors. */
3573       if (typecode == INTEGER_TYPE
3574           || (typecode == VECTOR_TYPE
3575               && !VECTOR_FLOAT_TYPE_P (TREE_TYPE (arg))))
3576         {
3577           if (!noconvert)
3578             arg = default_conversion (arg);
3579         }
3580       else if (typecode == COMPLEX_TYPE)
3581         {
3582           code = CONJ_EXPR;
3583           pedwarn (location, OPT_pedantic,
3584                    "ISO C does not support %<~%> for complex conjugation");
3585           if (!noconvert)
3586             arg = default_conversion (arg);
3587         }
3588       else
3589         {
3590           error_at (location, "wrong type argument to bit-complement");
3591           return error_mark_node;
3592         }
3593       break;
3594
3595     case ABS_EXPR:
3596       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE))
3597         {
3598           error_at (location, "wrong type argument to abs");
3599           return error_mark_node;
3600         }
3601       else if (!noconvert)
3602         arg = default_conversion (arg);
3603       break;
3604
3605     case CONJ_EXPR:
3606       /* Conjugating a real value is a no-op, but allow it anyway.  */
3607       if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE
3608             || typecode == COMPLEX_TYPE))
3609         {
3610           error_at (location, "wrong type argument to conjugation");
3611           return error_mark_node;
3612         }
3613       else if (!noconvert)
3614         arg = default_conversion (arg);
3615       break;
3616
3617     case TRUTH_NOT_EXPR:
3618       if (typecode != INTEGER_TYPE && typecode != FIXED_POINT_TYPE
3619           && typecode != REAL_TYPE && typecode != POINTER_TYPE
3620           && typecode != COMPLEX_TYPE)
3621         {
3622           error_at (location,
3623                     "wrong type argument to unary exclamation mark");
3624           return error_mark_node;
3625         }
3626       arg = c_objc_common_truthvalue_conversion (location, arg);
3627       ret = invert_truthvalue_loc (location, arg);
3628       /* If the TRUTH_NOT_EXPR has been folded, reset the location.  */
3629       if (EXPR_P (ret) && EXPR_HAS_LOCATION (ret))
3630         location = EXPR_LOCATION (ret);
3631       goto return_build_unary_op;
3632
3633     case REALPART_EXPR:
3634     case IMAGPART_EXPR:
3635       ret = build_real_imag_expr (location, code, arg);
3636       if (ret == error_mark_node)
3637         return error_mark_node;
3638       if (eptype && TREE_CODE (eptype) == COMPLEX_TYPE)
3639         eptype = TREE_TYPE (eptype);
3640       goto return_build_unary_op;
3641
3642     case PREINCREMENT_EXPR:
3643     case POSTINCREMENT_EXPR:
3644     case PREDECREMENT_EXPR:
3645     case POSTDECREMENT_EXPR:
3646
3647       if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
3648         {
3649           tree inner = build_unary_op (location, code,
3650                                        C_MAYBE_CONST_EXPR_EXPR (arg), flag);
3651           if (inner == error_mark_node)
3652             return error_mark_node;
3653           ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
3654                         C_MAYBE_CONST_EXPR_PRE (arg), inner);
3655           gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
3656           C_MAYBE_CONST_EXPR_NON_CONST (ret) = 1;
3657           goto return_build_unary_op;
3658         }
3659
3660       /* Complain about anything that is not a true lvalue.  In
3661          Objective-C, skip this check for property_refs.  */
3662       if (!objc_is_property_ref (arg)
3663           && !lvalue_or_else (location,
3664                               arg, ((code == PREINCREMENT_EXPR
3665                                      || code == POSTINCREMENT_EXPR)
3666                                     ? lv_increment
3667                                     : lv_decrement)))
3668         return error_mark_node;
3669
3670       if (warn_cxx_compat && TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE)
3671         {
3672           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3673             warning_at (location, OPT_Wc___compat,
3674                         "increment of enumeration value is invalid in C++");
3675           else
3676             warning_at (location, OPT_Wc___compat,
3677                         "decrement of enumeration value is invalid in C++");
3678         }
3679
3680       /* Ensure the argument is fully folded inside any SAVE_EXPR.  */
3681       arg = c_fully_fold (arg, false, NULL);
3682
3683       /* Increment or decrement the real part of the value,
3684          and don't change the imaginary part.  */
3685       if (typecode == COMPLEX_TYPE)
3686         {
3687           tree real, imag;
3688
3689           pedwarn (location, OPT_pedantic,
3690                    "ISO C does not support %<++%> and %<--%> on complex types");
3691
3692           arg = stabilize_reference (arg);
3693           real = build_unary_op (EXPR_LOCATION (arg), REALPART_EXPR, arg, 1);
3694           imag = build_unary_op (EXPR_LOCATION (arg), IMAGPART_EXPR, arg, 1);
3695           real = build_unary_op (EXPR_LOCATION (arg), code, real, 1);
3696           if (real == error_mark_node || imag == error_mark_node)
3697             return error_mark_node;
3698           ret = build2 (COMPLEX_EXPR, TREE_TYPE (arg),
3699                         real, imag);
3700           goto return_build_unary_op;
3701         }
3702
3703       /* Report invalid types.  */
3704
3705       if (typecode != POINTER_TYPE && typecode != FIXED_POINT_TYPE
3706           && typecode != INTEGER_TYPE && typecode != REAL_TYPE)
3707         {
3708           if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3709             error_at (location, "wrong type argument to increment");
3710           else
3711             error_at (location, "wrong type argument to decrement");
3712
3713           return error_mark_node;
3714         }
3715
3716       {
3717         tree inc;
3718
3719         argtype = TREE_TYPE (arg);
3720
3721         /* Compute the increment.  */
3722
3723         if (typecode == POINTER_TYPE)
3724           {
3725             /* If pointer target is an undefined struct,
3726                we just cannot know how to do the arithmetic.  */
3727             if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (argtype)))
3728               {
3729                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3730                   error_at (location,
3731                             "increment of pointer to unknown structure");
3732                 else
3733                   error_at (location,
3734                             "decrement of pointer to unknown structure");
3735               }
3736             else if (TREE_CODE (TREE_TYPE (argtype)) == FUNCTION_TYPE
3737                      || TREE_CODE (TREE_TYPE (argtype)) == VOID_TYPE)
3738               {
3739                 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
3740                   pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3741                            "wrong type argument to increment");
3742                 else
3743                   pedwarn (location, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3744                            "wrong type argument to decrement");
3745               }
3746
3747             inc = c_size_in_bytes (TREE_TYPE (argtype));
3748             inc = convert_to_ptrofftype_loc (location, inc);
3749           }
3750         else if (FRACT_MODE_P (TYPE_MODE (argtype)))
3751           {
3752             /* For signed fract types, we invert ++ to -- or
3753                -- to ++, and change inc from 1 to -1, because
3754                it is not possible to represent 1 in signed fract constants.
3755                For unsigned fract types, the result always overflows and
3756                we get an undefined (original) or the maximum value.  */
3757             if (code == PREINCREMENT_EXPR)
3758               code = PREDECREMENT_EXPR;
3759             else if (code == PREDECREMENT_EXPR)
3760               code = PREINCREMENT_EXPR;
3761             else if (code == POSTINCREMENT_EXPR)
3762               code = POSTDECREMENT_EXPR;
3763             else /* code == POSTDECREMENT_EXPR  */
3764               code = POSTINCREMENT_EXPR;
3765
3766             inc = integer_minus_one_node;
3767             inc = convert (argtype, inc);
3768           }
3769         else
3770           {
3771             inc = integer_one_node;
3772             inc = convert (argtype, inc);
3773           }
3774
3775         /* If 'arg' is an Objective-C PROPERTY_REF expression, then we
3776            need to ask Objective-C to build the increment or decrement
3777            expression for it.  */
3778         if (objc_is_property_ref (arg))
3779           return objc_build_incr_expr_for_property_ref (location, code,
3780                                                         arg, inc);
3781
3782         /* Report a read-only lvalue.  */
3783         if (TYPE_READONLY (argtype))
3784           {
3785             readonly_error (arg,
3786                             ((code == PREINCREMENT_EXPR
3787                               || code == POSTINCREMENT_EXPR)
3788                              ? lv_increment : lv_decrement));
3789             return error_mark_node;
3790           }
3791         else if (TREE_READONLY (arg))
3792           readonly_warning (arg,
3793                             ((code == PREINCREMENT_EXPR
3794                               || code == POSTINCREMENT_EXPR)
3795                              ? lv_increment : lv_decrement));
3796
3797         if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE)
3798           val = boolean_increment (code, arg);
3799         else
3800           val = build2 (code, TREE_TYPE (arg), arg, inc);
3801         TREE_SIDE_EFFECTS (val) = 1;
3802         if (TREE_CODE (val) != code)
3803           TREE_NO_WARNING (val) = 1;
3804         ret = val;
3805         goto return_build_unary_op;
3806       }
3807
3808     case ADDR_EXPR:
3809       /* Note that this operation never does default_conversion.  */
3810
3811       /* The operand of unary '&' must be an lvalue (which excludes
3812          expressions of type void), or, in C99, the result of a [] or
3813          unary '*' operator.  */
3814       if (VOID_TYPE_P (TREE_TYPE (arg))
3815           && TYPE_QUALS (TREE_TYPE (arg)) == TYPE_UNQUALIFIED
3816           && (TREE_CODE (arg) != INDIRECT_REF
3817               || !flag_isoc99))
3818         pedwarn (location, 0, "taking address of expression of type %<void%>");
3819
3820       /* Let &* cancel out to simplify resulting code.  */
3821       if (TREE_CODE (arg) == INDIRECT_REF)
3822         {
3823           /* Don't let this be an lvalue.  */
3824           if (lvalue_p (TREE_OPERAND (arg, 0)))
3825             return non_lvalue_loc (location, TREE_OPERAND (arg, 0));
3826           ret = TREE_OPERAND (arg, 0);
3827           goto return_build_unary_op;
3828         }
3829
3830       /* For &x[y], return x+y */
3831       if (TREE_CODE (arg) == ARRAY_REF)
3832         {
3833           tree op0 = TREE_OPERAND (arg, 0);
3834           if (!c_mark_addressable (op0))
3835             return error_mark_node;
3836         }
3837
3838       /* Anything not already handled and not a true memory reference
3839          or a non-lvalue array is an error.  */
3840       else if (typecode != FUNCTION_TYPE && !flag
3841                && !lvalue_or_else (location, arg, lv_addressof))
3842         return error_mark_node;
3843
3844       /* Move address operations inside C_MAYBE_CONST_EXPR to simplify
3845          folding later.  */
3846       if (TREE_CODE (arg) == C_MAYBE_CONST_EXPR)
3847         {
3848           tree inner = build_unary_op (location, code,
3849                                        C_MAYBE_CONST_EXPR_EXPR (arg), flag);
3850           ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
3851                         C_MAYBE_CONST_EXPR_PRE (arg), inner);
3852           gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (arg));
3853           C_MAYBE_CONST_EXPR_NON_CONST (ret)
3854             = C_MAYBE_CONST_EXPR_NON_CONST (arg);
3855           goto return_build_unary_op;
3856         }
3857
3858       /* Ordinary case; arg is a COMPONENT_REF or a decl.  */
3859       argtype = TREE_TYPE (arg);
3860
3861       /* If the lvalue is const or volatile, merge that into the type
3862          to which the address will point.  This is only needed
3863          for function types.  */
3864       if ((DECL_P (arg) || REFERENCE_CLASS_P (arg))
3865           && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))
3866           && TREE_CODE (argtype) == FUNCTION_TYPE)
3867         {
3868           int orig_quals = TYPE_QUALS (strip_array_types (argtype));
3869           int quals = orig_quals;
3870
3871           if (TREE_READONLY (arg))
3872             quals |= TYPE_QUAL_CONST;
3873           if (TREE_THIS_VOLATILE (arg))
3874             quals |= TYPE_QUAL_VOLATILE;
3875
3876           argtype = c_build_qualified_type (argtype, quals);
3877         }
3878
3879       if (!c_mark_addressable (arg))
3880         return error_mark_node;
3881
3882       gcc_assert (TREE_CODE (arg) != COMPONENT_REF
3883                   || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)));
3884
3885       argtype = build_pointer_type (argtype);
3886
3887       /* ??? Cope with user tricks that amount to offsetof.  Delete this
3888          when we have proper support for integer constant expressions.  */
3889       val = get_base_address (arg);
3890       if (val && TREE_CODE (val) == INDIRECT_REF
3891           && TREE_CONSTANT (TREE_OPERAND (val, 0)))
3892         {
3893           tree op0 = fold_offsetof (arg, val), op1;
3894
3895           op1 = fold_convert_loc (location, argtype, TREE_OPERAND (val, 0));
3896           ret = fold_build_pointer_plus_loc (location, op1, op0);
3897           goto return_build_unary_op;
3898         }
3899
3900       val = build1 (ADDR_EXPR, argtype, arg);
3901
3902       ret = val;
3903       goto return_build_unary_op;
3904
3905     default:
3906       gcc_unreachable ();
3907     }
3908
3909   if (argtype == 0)
3910     argtype = TREE_TYPE (arg);
3911   if (TREE_CODE (arg) == INTEGER_CST)
3912     ret = (require_constant_value
3913            ? fold_build1_initializer_loc (location, code, argtype, arg)
3914            : fold_build1_loc (location, code, argtype, arg));
3915   else
3916     ret = build1 (code, argtype, arg);
3917  return_build_unary_op:
3918   gcc_assert (ret != error_mark_node);
3919   if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret)
3920       && !(TREE_CODE (xarg) == INTEGER_CST && !TREE_OVERFLOW (xarg)))
3921     ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
3922   else if (TREE_CODE (ret) != INTEGER_CST && int_operands)
3923     ret = note_integer_operands (ret);
3924   if (eptype)
3925     ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
3926   protected_set_expr_location (ret, location);
3927   return ret;
3928 }
3929
3930 /* Return nonzero if REF is an lvalue valid for this language.
3931    Lvalues can be assigned, unless their type has TYPE_READONLY.
3932    Lvalues can have their address taken, unless they have C_DECL_REGISTER.  */
3933
3934 bool
3935 lvalue_p (const_tree ref)
3936 {
3937   const enum tree_code code = TREE_CODE (ref);
3938
3939   switch (code)
3940     {
3941     case REALPART_EXPR:
3942     case IMAGPART_EXPR:
3943     case COMPONENT_REF:
3944       return lvalue_p (TREE_OPERAND (ref, 0));
3945
3946     case C_MAYBE_CONST_EXPR:
3947       return lvalue_p (TREE_OPERAND (ref, 1));
3948
3949     case COMPOUND_LITERAL_EXPR:
3950     case STRING_CST:
3951       return 1;
3952
3953     case INDIRECT_REF:
3954     case ARRAY_REF:
3955     case VAR_DECL:
3956     case PARM_DECL:
3957     case RESULT_DECL:
3958     case ERROR_MARK:
3959       return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE
3960               && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE);
3961
3962     case BIND_EXPR:
3963       return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE;
3964
3965     default:
3966       return 0;
3967     }
3968 }
3969 \f
3970 /* Give a warning for storing in something that is read-only in GCC
3971    terms but not const in ISO C terms.  */
3972
3973 static void
3974 readonly_warning (tree arg, enum lvalue_use use)
3975 {
3976   switch (use)
3977     {
3978     case lv_assign:
3979       warning (0, "assignment of read-only location %qE", arg);
3980       break;
3981     case lv_increment:
3982       warning (0, "increment of read-only location %qE", arg);
3983       break;
3984     case lv_decrement:
3985       warning (0, "decrement of read-only location %qE", arg);
3986       break;
3987     default:
3988       gcc_unreachable ();
3989     }
3990   return;
3991 }
3992
3993
3994 /* Return nonzero if REF is an lvalue valid for this language;
3995    otherwise, print an error message and return zero.  USE says
3996    how the lvalue is being used and so selects the error message.
3997    LOCATION is the location at which any error should be reported.  */
3998
3999 static int
4000 lvalue_or_else (location_t loc, const_tree ref, enum lvalue_use use)
4001 {
4002   int win = lvalue_p (ref);
4003
4004   if (!win)
4005     lvalue_error (loc, use);
4006
4007   return win;
4008 }
4009 \f
4010 /* Mark EXP saying that we need to be able to take the
4011    address of it; it should not be allocated in a register.
4012    Returns true if successful.  */
4013
4014 bool
4015 c_mark_addressable (tree exp)
4016 {
4017   tree x = exp;
4018
4019   while (1)
4020     switch (TREE_CODE (x))
4021       {
4022       case COMPONENT_REF:
4023         if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1)))
4024           {
4025             error
4026               ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1));
4027             return false;
4028           }
4029
4030         /* ... fall through ...  */
4031
4032       case ADDR_EXPR:
4033       case ARRAY_REF:
4034       case REALPART_EXPR:
4035       case IMAGPART_EXPR:
4036         x = TREE_OPERAND (x, 0);
4037         break;
4038
4039       case COMPOUND_LITERAL_EXPR:
4040       case CONSTRUCTOR:
4041         TREE_ADDRESSABLE (x) = 1;
4042         return true;
4043
4044       case VAR_DECL:
4045       case CONST_DECL:
4046       case PARM_DECL:
4047       case RESULT_DECL:
4048         if (C_DECL_REGISTER (x)
4049             && DECL_NONLOCAL (x))
4050           {
4051             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
4052               {
4053                 error
4054                   ("global register variable %qD used in nested function", x);
4055                 return false;
4056               }
4057             pedwarn (input_location, 0, "register variable %qD used in nested function", x);
4058           }
4059         else if (C_DECL_REGISTER (x))
4060           {
4061             if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x))
4062               error ("address of global register variable %qD requested", x);
4063             else
4064               error ("address of register variable %qD requested", x);
4065             return false;
4066           }
4067
4068         /* drops in */
4069       case FUNCTION_DECL:
4070         TREE_ADDRESSABLE (x) = 1;
4071         /* drops out */
4072       default:
4073         return true;
4074     }
4075 }
4076 \f
4077 /* Convert EXPR to TYPE, warning about conversion problems with
4078    constants.  SEMANTIC_TYPE is the type this conversion would use
4079    without excess precision. If SEMANTIC_TYPE is NULL, this function
4080    is equivalent to convert_and_check. This function is a wrapper that
4081    handles conversions that may be different than
4082    the usual ones because of excess precision.  */
4083
4084 static tree
4085 ep_convert_and_check (tree type, tree expr, tree semantic_type)
4086 {
4087   if (TREE_TYPE (expr) == type)
4088     return expr;
4089
4090   if (!semantic_type)
4091     return convert_and_check (type, expr);
4092
4093   if (TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
4094       && TREE_TYPE (expr) != semantic_type)
4095     {
4096       /* For integers, we need to check the real conversion, not
4097          the conversion to the excess precision type.  */
4098       expr = convert_and_check (semantic_type, expr);
4099     }
4100   /* Result type is the excess precision type, which should be
4101      large enough, so do not check.  */
4102   return convert (type, expr);
4103 }
4104
4105 /* Build and return a conditional expression IFEXP ? OP1 : OP2.  If
4106    IFEXP_BCP then the condition is a call to __builtin_constant_p, and
4107    if folded to an integer constant then the unselected half may
4108    contain arbitrary operations not normally permitted in constant
4109    expressions.  Set the location of the expression to LOC.  */
4110
4111 tree
4112 build_conditional_expr (location_t colon_loc, tree ifexp, bool ifexp_bcp,
4113                         tree op1, tree op1_original_type, tree op2,
4114                         tree op2_original_type)
4115 {
4116   tree type1;
4117   tree type2;
4118   enum tree_code code1;
4119   enum tree_code code2;
4120   tree result_type = NULL;
4121   tree semantic_result_type = NULL;
4122   tree orig_op1 = op1, orig_op2 = op2;
4123   bool int_const, op1_int_operands, op2_int_operands, int_operands;
4124   bool ifexp_int_operands;
4125   tree ret;
4126
4127   op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
4128   if (op1_int_operands)
4129     op1 = remove_c_maybe_const_expr (op1);
4130   op2_int_operands = EXPR_INT_CONST_OPERANDS (orig_op2);
4131   if (op2_int_operands)
4132     op2 = remove_c_maybe_const_expr (op2);
4133   ifexp_int_operands = EXPR_INT_CONST_OPERANDS (ifexp);
4134   if (ifexp_int_operands)
4135     ifexp = remove_c_maybe_const_expr (ifexp);
4136
4137   /* Promote both alternatives.  */
4138
4139   if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE)
4140     op1 = default_conversion (op1);
4141   if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE)
4142     op2 = default_conversion (op2);
4143
4144   if (TREE_CODE (ifexp) == ERROR_MARK
4145       || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK
4146       || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK)
4147     return error_mark_node;
4148
4149   type1 = TREE_TYPE (op1);
4150   code1 = TREE_CODE (type1);
4151   type2 = TREE_TYPE (op2);
4152   code2 = TREE_CODE (type2);
4153
4154   /* C90 does not permit non-lvalue arrays in conditional expressions.
4155      In C99 they will be pointers by now.  */
4156   if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE)
4157     {
4158       error_at (colon_loc, "non-lvalue array in conditional expression");
4159       return error_mark_node;
4160     }
4161
4162   if ((TREE_CODE (op1) == EXCESS_PRECISION_EXPR
4163        || TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4164       && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
4165           || code1 == COMPLEX_TYPE)
4166       && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4167           || code2 == COMPLEX_TYPE))
4168     {
4169       semantic_result_type = c_common_type (type1, type2);
4170       if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
4171         {
4172           op1 = TREE_OPERAND (op1, 0);
4173           type1 = TREE_TYPE (op1);
4174           gcc_assert (TREE_CODE (type1) == code1);
4175         }
4176       if (TREE_CODE (op2) == EXCESS_PRECISION_EXPR)
4177         {
4178           op2 = TREE_OPERAND (op2, 0);
4179           type2 = TREE_TYPE (op2);
4180           gcc_assert (TREE_CODE (type2) == code2);
4181         }
4182     }
4183
4184   if (warn_cxx_compat)
4185     {
4186       tree t1 = op1_original_type ? op1_original_type : TREE_TYPE (orig_op1);
4187       tree t2 = op2_original_type ? op2_original_type : TREE_TYPE (orig_op2);
4188
4189       if (TREE_CODE (t1) == ENUMERAL_TYPE
4190           && TREE_CODE (t2) == ENUMERAL_TYPE
4191           && TYPE_MAIN_VARIANT (t1) != TYPE_MAIN_VARIANT (t2))
4192         warning_at (colon_loc, OPT_Wc___compat,
4193                     ("different enum types in conditional is "
4194                      "invalid in C++: %qT vs %qT"),
4195                     t1, t2);
4196     }
4197
4198   /* Quickly detect the usual case where op1 and op2 have the same type
4199      after promotion.  */
4200   if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2))
4201     {
4202       if (type1 == type2)
4203         result_type = type1;
4204       else
4205         result_type = TYPE_MAIN_VARIANT (type1);
4206     }
4207   else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE
4208             || code1 == COMPLEX_TYPE)
4209            && (code2 == INTEGER_TYPE || code2 == REAL_TYPE
4210                || code2 == COMPLEX_TYPE))
4211     {
4212       result_type = c_common_type (type1, type2);
4213       do_warn_double_promotion (result_type, type1, type2,
4214                                 "implicit conversion from %qT to %qT to "
4215                                 "match other result of conditional",
4216                                 colon_loc);
4217
4218       /* If -Wsign-compare, warn here if type1 and type2 have
4219          different signedness.  We'll promote the signed to unsigned
4220          and later code won't know it used to be different.
4221          Do this check on the original types, so that explicit casts
4222          will be considered, but default promotions won't.  */
4223       if (c_inhibit_evaluation_warnings == 0)
4224         {
4225           int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1));
4226           int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2));
4227
4228           if (unsigned_op1 ^ unsigned_op2)
4229             {
4230               bool ovf;
4231
4232               /* Do not warn if the result type is signed, since the
4233                  signed type will only be chosen if it can represent
4234                  all the values of the unsigned type.  */
4235               if (!TYPE_UNSIGNED (result_type))
4236                 /* OK */;
4237               else
4238                 {
4239                   bool op1_maybe_const = true;
4240                   bool op2_maybe_const = true;
4241
4242                   /* Do not warn if the signed quantity is an
4243                      unsuffixed integer literal (or some static
4244                      constant expression involving such literals) and
4245                      it is non-negative.  This warning requires the
4246                      operands to be folded for best results, so do
4247                      that folding in this case even without
4248                      warn_sign_compare to avoid warning options
4249                      possibly affecting code generation.  */
4250                   c_inhibit_evaluation_warnings
4251                     += (ifexp == truthvalue_false_node);
4252                   op1 = c_fully_fold (op1, require_constant_value,
4253                                       &op1_maybe_const);
4254                   c_inhibit_evaluation_warnings
4255                     -= (ifexp == truthvalue_false_node);
4256
4257                   c_inhibit_evaluation_warnings
4258                     += (ifexp == truthvalue_true_node);
4259                   op2 = c_fully_fold (op2, require_constant_value,
4260                                       &op2_maybe_const);
4261                   c_inhibit_evaluation_warnings
4262                     -= (ifexp == truthvalue_true_node);
4263
4264                   if (warn_sign_compare)
4265                     {
4266                       if ((unsigned_op2
4267                            && tree_expr_nonnegative_warnv_p (op1, &ovf))
4268                           || (unsigned_op1
4269                               && tree_expr_nonnegative_warnv_p (op2, &ovf)))
4270                         /* OK */;
4271                       else
4272                         warning_at (colon_loc, OPT_Wsign_compare,
4273                                     ("signed and unsigned type in "
4274                                      "conditional expression"));
4275                     }
4276                   if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
4277                     op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
4278                   if (!op2_maybe_const || TREE_CODE (op2) != INTEGER_CST)
4279                     op2 = c_wrap_maybe_const (op2, !op2_maybe_const);
4280                 }
4281             }
4282         }
4283     }
4284   else if (code1 == VOID_TYPE || code2 == VOID_TYPE)
4285     {
4286       if (code1 != VOID_TYPE || code2 != VOID_TYPE)
4287         pedwarn (colon_loc, OPT_pedantic,
4288                  "ISO C forbids conditional expr with only one void side");
4289       result_type = void_type_node;
4290     }
4291   else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE)
4292     {
4293       addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
4294       addr_space_t as2 = TYPE_ADDR_SPACE (TREE_TYPE (type2));
4295       addr_space_t as_common;
4296
4297       if (comp_target_types (colon_loc, type1, type2))
4298         result_type = common_pointer_type (type1, type2);
4299       else if (null_pointer_constant_p (orig_op1))
4300         result_type = type2;
4301       else if (null_pointer_constant_p (orig_op2))
4302         result_type = type1;
4303       else if (!addr_space_superset (as1, as2, &as_common))
4304         {
4305           error_at (colon_loc, "pointers to disjoint address spaces "
4306                     "used in conditional expression");
4307           return error_mark_node;
4308         }
4309       else if (VOID_TYPE_P (TREE_TYPE (type1)))
4310         {
4311           if (TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE)
4312             pedwarn (colon_loc, OPT_pedantic,
4313                      "ISO C forbids conditional expr between "
4314                      "%<void *%> and function pointer");
4315           result_type = build_pointer_type (qualify_type (TREE_TYPE (type1),
4316                                                           TREE_TYPE (type2)));
4317         }
4318       else if (VOID_TYPE_P (TREE_TYPE (type2)))
4319         {
4320           if (TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE)
4321             pedwarn (colon_loc, OPT_pedantic,
4322                      "ISO C forbids conditional expr between "
4323                      "%<void *%> and function pointer");
4324           result_type = build_pointer_type (qualify_type (TREE_TYPE (type2),
4325                                                           TREE_TYPE (type1)));
4326         }
4327       /* Objective-C pointer comparisons are a bit more lenient.  */
4328       else if (objc_have_common_type (type1, type2, -3, NULL_TREE))
4329         result_type = objc_common_type (type1, type2);
4330       else
4331         {
4332           int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
4333
4334           pedwarn (colon_loc, 0,
4335                    "pointer type mismatch in conditional expression");
4336           result_type = build_pointer_type
4337                           (build_qualified_type (void_type_node, qual));
4338         }
4339     }
4340   else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE)
4341     {
4342       if (!null_pointer_constant_p (orig_op2))
4343         pedwarn (colon_loc, 0,
4344                  "pointer/integer type mismatch in conditional expression");
4345       else
4346         {
4347           op2 = null_pointer_node;
4348         }
4349       result_type = type1;
4350     }
4351   else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE)
4352     {
4353       if (!null_pointer_constant_p (orig_op1))
4354         pedwarn (colon_loc, 0,
4355                  "pointer/integer type mismatch in conditional expression");
4356       else
4357         {
4358           op1 = null_pointer_node;
4359         }
4360       result_type = type2;
4361     }
4362
4363   if (!result_type)
4364     {
4365       if (flag_cond_mismatch)
4366         result_type = void_type_node;
4367       else
4368         {
4369           error_at (colon_loc, "type mismatch in conditional expression");
4370           return error_mark_node;
4371         }
4372     }
4373
4374   /* Merge const and volatile flags of the incoming types.  */
4375   result_type
4376     = build_type_variant (result_type,
4377                           TYPE_READONLY (type1) || TYPE_READONLY (type2),
4378                           TYPE_VOLATILE (type1) || TYPE_VOLATILE (type2));
4379
4380   op1 = ep_convert_and_check (result_type, op1, semantic_result_type);
4381   op2 = ep_convert_and_check (result_type, op2, semantic_result_type);
4382
4383   if (ifexp_bcp && ifexp == truthvalue_true_node)
4384     {
4385       op2_int_operands = true;
4386       op1 = c_fully_fold (op1, require_constant_value, NULL);
4387     }
4388   if (ifexp_bcp && ifexp == truthvalue_false_node)
4389     {
4390       op1_int_operands = true;
4391       op2 = c_fully_fold (op2, require_constant_value, NULL);
4392     }
4393   int_const = int_operands = (ifexp_int_operands
4394                               && op1_int_operands
4395                               && op2_int_operands);
4396   if (int_operands)
4397     {
4398       int_const = ((ifexp == truthvalue_true_node
4399                     && TREE_CODE (orig_op1) == INTEGER_CST
4400                     && !TREE_OVERFLOW (orig_op1))
4401                    || (ifexp == truthvalue_false_node
4402                        && TREE_CODE (orig_op2) == INTEGER_CST
4403                        && !TREE_OVERFLOW (orig_op2)));
4404     }
4405   if (int_const || (ifexp_bcp && TREE_CODE (ifexp) == INTEGER_CST))
4406     ret = fold_build3_loc (colon_loc, COND_EXPR, result_type, ifexp, op1, op2);
4407   else
4408     {
4409       ret = build3 (COND_EXPR, result_type, ifexp, op1, op2);
4410       if (int_operands)
4411         ret = note_integer_operands (ret);
4412     }
4413   if (semantic_result_type)
4414     ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
4415
4416   protected_set_expr_location (ret, colon_loc);
4417   return ret;
4418 }
4419 \f
4420 /* Return a compound expression that performs two expressions and
4421    returns the value of the second of them.
4422
4423    LOC is the location of the COMPOUND_EXPR.  */
4424
4425 tree
4426 build_compound_expr (location_t loc, tree expr1, tree expr2)
4427 {
4428   bool expr1_int_operands, expr2_int_operands;
4429   tree eptype = NULL_TREE;
4430   tree ret;
4431
4432   expr1_int_operands = EXPR_INT_CONST_OPERANDS (expr1);
4433   if (expr1_int_operands)
4434     expr1 = remove_c_maybe_const_expr (expr1);
4435   expr2_int_operands = EXPR_INT_CONST_OPERANDS (expr2);
4436   if (expr2_int_operands)
4437     expr2 = remove_c_maybe_const_expr (expr2);
4438
4439   if (TREE_CODE (expr1) == EXCESS_PRECISION_EXPR)
4440     expr1 = TREE_OPERAND (expr1, 0);
4441   if (TREE_CODE (expr2) == EXCESS_PRECISION_EXPR)
4442     {
4443       eptype = TREE_TYPE (expr2);
4444       expr2 = TREE_OPERAND (expr2, 0);
4445     }
4446
4447   if (!TREE_SIDE_EFFECTS (expr1))
4448     {
4449       /* The left-hand operand of a comma expression is like an expression
4450          statement: with -Wunused, we should warn if it doesn't have
4451          any side-effects, unless it was explicitly cast to (void).  */
4452       if (warn_unused_value)
4453         {
4454           if (VOID_TYPE_P (TREE_TYPE (expr1))
4455               && CONVERT_EXPR_P (expr1))
4456             ; /* (void) a, b */
4457           else if (VOID_TYPE_P (TREE_TYPE (expr1))
4458                    && TREE_CODE (expr1) == COMPOUND_EXPR
4459                    && CONVERT_EXPR_P (TREE_OPERAND (expr1, 1)))
4460             ; /* (void) a, (void) b, c */
4461           else
4462             warning_at (loc, OPT_Wunused_value,
4463                         "left-hand operand of comma expression has no effect");
4464         }
4465     }
4466
4467   /* With -Wunused, we should also warn if the left-hand operand does have
4468      side-effects, but computes a value which is not used.  For example, in
4469      `foo() + bar(), baz()' the result of the `+' operator is not used,
4470      so we should issue a warning.  */
4471   else if (warn_unused_value)
4472     warn_if_unused_value (expr1, loc);
4473
4474   if (expr2 == error_mark_node)
4475     return error_mark_node;
4476
4477   ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2);
4478
4479   if (flag_isoc99
4480       && expr1_int_operands
4481       && expr2_int_operands)
4482     ret = note_integer_operands (ret);
4483
4484   if (eptype)
4485     ret = build1 (EXCESS_PRECISION_EXPR, eptype, ret);
4486
4487   protected_set_expr_location (ret, loc);
4488   return ret;
4489 }
4490
4491 /* Issue -Wcast-qual warnings when appropriate.  TYPE is the type to
4492    which we are casting.  OTYPE is the type of the expression being
4493    cast.  Both TYPE and OTYPE are pointer types.  LOC is the location
4494    of the cast.  -Wcast-qual appeared on the command line.  Named
4495    address space qualifiers are not handled here, because they result
4496    in different warnings.  */
4497
4498 static void
4499 handle_warn_cast_qual (location_t loc, tree type, tree otype)
4500 {
4501   tree in_type = type;
4502   tree in_otype = otype;
4503   int added = 0;
4504   int discarded = 0;
4505   bool is_const;
4506
4507   /* Check that the qualifiers on IN_TYPE are a superset of the
4508      qualifiers of IN_OTYPE.  The outermost level of POINTER_TYPE
4509      nodes is uninteresting and we stop as soon as we hit a
4510      non-POINTER_TYPE node on either type.  */
4511   do
4512     {
4513       in_otype = TREE_TYPE (in_otype);
4514       in_type = TREE_TYPE (in_type);
4515
4516       /* GNU C allows cv-qualified function types.  'const' means the
4517          function is very pure, 'volatile' means it can't return.  We
4518          need to warn when such qualifiers are added, not when they're
4519          taken away.  */
4520       if (TREE_CODE (in_otype) == FUNCTION_TYPE
4521           && TREE_CODE (in_type) == FUNCTION_TYPE)
4522         added |= (TYPE_QUALS_NO_ADDR_SPACE (in_type)
4523                   & ~TYPE_QUALS_NO_ADDR_SPACE (in_otype));
4524       else
4525         discarded |= (TYPE_QUALS_NO_ADDR_SPACE (in_otype)
4526                       & ~TYPE_QUALS_NO_ADDR_SPACE (in_type));
4527     }
4528   while (TREE_CODE (in_type) == POINTER_TYPE
4529          && TREE_CODE (in_otype) == POINTER_TYPE);
4530
4531   if (added)
4532     warning_at (loc, OPT_Wcast_qual,
4533                 "cast adds %q#v qualifier to function type", added);
4534
4535   if (discarded)
4536     /* There are qualifiers present in IN_OTYPE that are not present
4537        in IN_TYPE.  */
4538     warning_at (loc, OPT_Wcast_qual,
4539                 "cast discards %q#v qualifier from pointer target type",
4540                 discarded);
4541
4542   if (added || discarded)
4543     return;
4544
4545   /* A cast from **T to const **T is unsafe, because it can cause a
4546      const value to be changed with no additional warning.  We only
4547      issue this warning if T is the same on both sides, and we only
4548      issue the warning if there are the same number of pointers on
4549      both sides, as otherwise the cast is clearly unsafe anyhow.  A
4550      cast is unsafe when a qualifier is added at one level and const
4551      is not present at all outer levels.
4552
4553      To issue this warning, we check at each level whether the cast
4554      adds new qualifiers not already seen.  We don't need to special
4555      case function types, as they won't have the same
4556      TYPE_MAIN_VARIANT.  */
4557
4558   if (TYPE_MAIN_VARIANT (in_type) != TYPE_MAIN_VARIANT (in_otype))
4559     return;
4560   if (TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE)
4561     return;
4562
4563   in_type = type;
4564   in_otype = otype;
4565   is_const = TYPE_READONLY (TREE_TYPE (in_type));
4566   do
4567     {
4568       in_type = TREE_TYPE (in_type);
4569       in_otype = TREE_TYPE (in_otype);
4570       if ((TYPE_QUALS (in_type) &~ TYPE_QUALS (in_otype)) != 0
4571           && !is_const)
4572         {
4573           warning_at (loc, OPT_Wcast_qual,
4574                       "to be safe all intermediate pointers in cast from "
4575                       "%qT to %qT must be %<const%> qualified",
4576                       otype, type);
4577           break;
4578         }
4579       if (is_const)
4580         is_const = TYPE_READONLY (in_type);
4581     }
4582   while (TREE_CODE (in_type) == POINTER_TYPE);
4583 }
4584
4585 /* Build an expression representing a cast to type TYPE of expression EXPR.
4586    LOC is the location of the cast-- typically the open paren of the cast.  */
4587
4588 tree
4589 build_c_cast (location_t loc, tree type, tree expr)
4590 {
4591   tree value;
4592
4593   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
4594     expr = TREE_OPERAND (expr, 0);
4595
4596   value = expr;
4597
4598   if (type == error_mark_node || expr == error_mark_node)
4599     return error_mark_node;
4600
4601   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
4602      only in <protocol> qualifications.  But when constructing cast expressions,
4603      the protocols do matter and must be kept around.  */
4604   if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
4605     return build1 (NOP_EXPR, type, expr);
4606
4607   type = TYPE_MAIN_VARIANT (type);
4608
4609   if (TREE_CODE (type) == ARRAY_TYPE)
4610     {
4611       error_at (loc, "cast specifies array type");
4612       return error_mark_node;
4613     }
4614
4615   if (TREE_CODE (type) == FUNCTION_TYPE)
4616     {
4617       error_at (loc, "cast specifies function type");
4618       return error_mark_node;
4619     }
4620
4621   if (!VOID_TYPE_P (type))
4622     {
4623       value = require_complete_type (value);
4624       if (value == error_mark_node)
4625         return error_mark_node;
4626     }
4627
4628   if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value)))
4629     {
4630       if (TREE_CODE (type) == RECORD_TYPE
4631           || TREE_CODE (type) == UNION_TYPE)
4632         pedwarn (loc, OPT_pedantic,
4633                  "ISO C forbids casting nonscalar to the same type");
4634     }
4635   else if (TREE_CODE (type) == UNION_TYPE)
4636     {
4637       tree field;
4638
4639       for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
4640         if (TREE_TYPE (field) != error_mark_node
4641             && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)),
4642                           TYPE_MAIN_VARIANT (TREE_TYPE (value))))
4643           break;
4644
4645       if (field)
4646         {
4647           tree t;
4648           bool maybe_const = true;
4649
4650           pedwarn (loc, OPT_pedantic, "ISO C forbids casts to union type");
4651           t = c_fully_fold (value, false, &maybe_const);
4652           t = build_constructor_single (type, field, t);
4653           if (!maybe_const)
4654             t = c_wrap_maybe_const (t, true);
4655           t = digest_init (loc, type, t,
4656                            NULL_TREE, false, true, 0);
4657           TREE_CONSTANT (t) = TREE_CONSTANT (value);
4658           return t;
4659         }
4660       error_at (loc, "cast to union type from type not present in union");
4661       return error_mark_node;
4662     }
4663   else
4664     {
4665       tree otype, ovalue;
4666
4667       if (type == void_type_node)
4668         {
4669           tree t = build1 (CONVERT_EXPR, type, value);
4670           SET_EXPR_LOCATION (t, loc);
4671           return t;
4672         }
4673
4674       otype = TREE_TYPE (value);
4675
4676       /* Optionally warn about potentially worrisome casts.  */
4677       if (warn_cast_qual
4678           && TREE_CODE (type) == POINTER_TYPE
4679           && TREE_CODE (otype) == POINTER_TYPE)
4680         handle_warn_cast_qual (loc, type, otype);
4681
4682       /* Warn about conversions between pointers to disjoint
4683          address spaces.  */
4684       if (TREE_CODE (type) == POINTER_TYPE
4685           && TREE_CODE (otype) == POINTER_TYPE
4686           && !null_pointer_constant_p (value))
4687         {
4688           addr_space_t as_to = TYPE_ADDR_SPACE (TREE_TYPE (type));
4689           addr_space_t as_from = TYPE_ADDR_SPACE (TREE_TYPE (otype));
4690           addr_space_t as_common;
4691
4692           if (!addr_space_superset (as_to, as_from, &as_common))
4693             {
4694               if (ADDR_SPACE_GENERIC_P (as_from))
4695                 warning_at (loc, 0, "cast to %s address space pointer "
4696                             "from disjoint generic address space pointer",
4697                             c_addr_space_name (as_to));
4698
4699               else if (ADDR_SPACE_GENERIC_P (as_to))
4700                 warning_at (loc, 0, "cast to generic address space pointer "
4701                             "from disjoint %s address space pointer",
4702                             c_addr_space_name (as_from));
4703
4704               else
4705                 warning_at (loc, 0, "cast to %s address space pointer "
4706                             "from disjoint %s address space pointer",
4707                             c_addr_space_name (as_to),
4708                             c_addr_space_name (as_from));
4709             }
4710         }
4711
4712       /* Warn about possible alignment problems.  */
4713       if (STRICT_ALIGNMENT
4714           && TREE_CODE (type) == POINTER_TYPE
4715           && TREE_CODE (otype) == POINTER_TYPE
4716           && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE
4717           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4718           /* Don't warn about opaque types, where the actual alignment
4719              restriction is unknown.  */
4720           && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE
4721                 || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE)
4722                && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode)
4723           && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype)))
4724         warning_at (loc, OPT_Wcast_align,
4725                     "cast increases required alignment of target type");
4726
4727       if (TREE_CODE (type) == INTEGER_TYPE
4728           && TREE_CODE (otype) == POINTER_TYPE
4729           && TYPE_PRECISION (type) != TYPE_PRECISION (otype))
4730       /* Unlike conversion of integers to pointers, where the
4731          warning is disabled for converting constants because
4732          of cases such as SIG_*, warn about converting constant
4733          pointers to integers. In some cases it may cause unwanted
4734          sign extension, and a warning is appropriate.  */
4735         warning_at (loc, OPT_Wpointer_to_int_cast,
4736                     "cast from pointer to integer of different size");
4737
4738       if (TREE_CODE (value) == CALL_EXPR
4739           && TREE_CODE (type) != TREE_CODE (otype))
4740         warning_at (loc, OPT_Wbad_function_cast,
4741                     "cast from function call of type %qT "
4742                     "to non-matching type %qT", otype, type);
4743
4744       if (TREE_CODE (type) == POINTER_TYPE
4745           && TREE_CODE (otype) == INTEGER_TYPE
4746           && TYPE_PRECISION (type) != TYPE_PRECISION (otype)
4747           /* Don't warn about converting any constant.  */
4748           && !TREE_CONSTANT (value))
4749         warning_at (loc,
4750                     OPT_Wint_to_pointer_cast, "cast to pointer from integer "
4751                     "of different size");
4752
4753       if (warn_strict_aliasing <= 2)
4754         strict_aliasing_warning (otype, type, expr);
4755
4756       /* If pedantic, warn for conversions between function and object
4757          pointer types, except for converting a null pointer constant
4758          to function pointer type.  */
4759       if (pedantic
4760           && TREE_CODE (type) == POINTER_TYPE
4761           && TREE_CODE (otype) == POINTER_TYPE
4762           && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE
4763           && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE)
4764         pedwarn (loc, OPT_pedantic, "ISO C forbids "
4765                  "conversion of function pointer to object pointer type");
4766
4767       if (pedantic
4768           && TREE_CODE (type) == POINTER_TYPE
4769           && TREE_CODE (otype) == POINTER_TYPE
4770           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE
4771           && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE
4772           && !null_pointer_constant_p (value))
4773         pedwarn (loc, OPT_pedantic, "ISO C forbids "
4774                  "conversion of object pointer to function pointer type");
4775
4776       ovalue = value;
4777       value = convert (type, value);
4778
4779       /* Ignore any integer overflow caused by the cast.  */
4780       if (TREE_CODE (value) == INTEGER_CST && !FLOAT_TYPE_P (otype))
4781         {
4782           if (CONSTANT_CLASS_P (ovalue) && TREE_OVERFLOW (ovalue))
4783             {
4784               if (!TREE_OVERFLOW (value))
4785                 {
4786                   /* Avoid clobbering a shared constant.  */
4787                   value = copy_node (value);
4788                   TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue);
4789                 }
4790             }
4791           else if (TREE_OVERFLOW (value))
4792             /* Reset VALUE's overflow flags, ensuring constant sharing.  */
4793             value = build_int_cst_wide (TREE_TYPE (value),
4794                                         TREE_INT_CST_LOW (value),
4795                                         TREE_INT_CST_HIGH (value));
4796         }
4797     }
4798
4799   /* Don't let a cast be an lvalue.  */
4800   if (value == expr)
4801     value = non_lvalue_loc (loc, value);
4802
4803   /* Don't allow the results of casting to floating-point or complex
4804      types be confused with actual constants, or casts involving
4805      integer and pointer types other than direct integer-to-integer
4806      and integer-to-pointer be confused with integer constant
4807      expressions and null pointer constants.  */
4808   if (TREE_CODE (value) == REAL_CST
4809       || TREE_CODE (value) == COMPLEX_CST
4810       || (TREE_CODE (value) == INTEGER_CST
4811           && !((TREE_CODE (expr) == INTEGER_CST
4812                 && INTEGRAL_TYPE_P (TREE_TYPE (expr)))
4813                || TREE_CODE (expr) == REAL_CST
4814                || TREE_CODE (expr) == COMPLEX_CST)))
4815       value = build1 (NOP_EXPR, type, value);
4816
4817   if (CAN_HAVE_LOCATION_P (value))
4818     SET_EXPR_LOCATION (value, loc);
4819   return value;
4820 }
4821
4822 /* Interpret a cast of expression EXPR to type TYPE.  LOC is the
4823    location of the open paren of the cast, or the position of the cast
4824    expr.  */
4825 tree
4826 c_cast_expr (location_t loc, struct c_type_name *type_name, tree expr)
4827 {
4828   tree type;
4829   tree type_expr = NULL_TREE;
4830   bool type_expr_const = true;
4831   tree ret;
4832   int saved_wsp = warn_strict_prototypes;
4833
4834   /* This avoids warnings about unprototyped casts on
4835      integers.  E.g. "#define SIG_DFL (void(*)())0".  */
4836   if (TREE_CODE (expr) == INTEGER_CST)
4837     warn_strict_prototypes = 0;
4838   type = groktypename (type_name, &type_expr, &type_expr_const);
4839   warn_strict_prototypes = saved_wsp;
4840
4841   ret = build_c_cast (loc, type, expr);
4842   if (type_expr)
4843     {
4844       ret = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (ret), type_expr, ret);
4845       C_MAYBE_CONST_EXPR_NON_CONST (ret) = !type_expr_const;
4846       SET_EXPR_LOCATION (ret, loc);
4847     }
4848
4849   if (CAN_HAVE_LOCATION_P (ret) && !EXPR_HAS_LOCATION (ret))
4850     SET_EXPR_LOCATION (ret, loc);
4851
4852   /* C++ does not permits types to be defined in a cast, but it
4853      allows references to incomplete types.  */
4854   if (warn_cxx_compat && type_name->specs->typespec_kind == ctsk_tagdef)
4855     warning_at (loc, OPT_Wc___compat,
4856                 "defining a type in a cast is invalid in C++");
4857
4858   return ret;
4859 }
4860 \f
4861 /* Build an assignment expression of lvalue LHS from value RHS.
4862    If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
4863    may differ from TREE_TYPE (LHS) for an enum bitfield.
4864    MODIFYCODE is the code for a binary operator that we use
4865    to combine the old value of LHS with RHS to get the new value.
4866    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4867    If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
4868    which may differ from TREE_TYPE (RHS) for an enum value.
4869
4870    LOCATION is the location of the MODIFYCODE operator.
4871    RHS_LOC is the location of the RHS.  */
4872
4873 tree
4874 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
4875                    enum tree_code modifycode,
4876                    location_t rhs_loc, tree rhs, tree rhs_origtype)
4877 {
4878   tree result;
4879   tree newrhs;
4880   tree rhs_semantic_type = NULL_TREE;
4881   tree lhstype = TREE_TYPE (lhs);
4882   tree olhstype = lhstype;
4883   bool npc;
4884
4885   /* Types that aren't fully specified cannot be used in assignments.  */
4886   lhs = require_complete_type (lhs);
4887
4888   /* Avoid duplicate error messages from operands that had errors.  */
4889   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
4890     return error_mark_node;
4891
4892   /* For ObjC properties, defer this check.  */
4893   if (!objc_is_property_ref (lhs) && !lvalue_or_else (location, lhs, lv_assign))
4894     return error_mark_node;
4895
4896   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4897     {
4898       rhs_semantic_type = TREE_TYPE (rhs);
4899       rhs = TREE_OPERAND (rhs, 0);
4900     }
4901
4902   newrhs = rhs;
4903
4904   if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
4905     {
4906       tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
4907                                       lhs_origtype, modifycode, rhs_loc, rhs,
4908                                       rhs_origtype);
4909       if (inner == error_mark_node)
4910         return error_mark_node;
4911       result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4912                        C_MAYBE_CONST_EXPR_PRE (lhs), inner);
4913       gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
4914       C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
4915       protected_set_expr_location (result, location);
4916       return result;
4917     }
4918
4919   /* If a binary op has been requested, combine the old LHS value with the RHS
4920      producing the value we should actually store into the LHS.  */
4921
4922   if (modifycode != NOP_EXPR)
4923     {
4924       lhs = c_fully_fold (lhs, false, NULL);
4925       lhs = stabilize_reference (lhs);
4926       newrhs = build_binary_op (location,
4927                                 modifycode, lhs, rhs, 1);
4928
4929       /* The original type of the right hand side is no longer
4930          meaningful.  */
4931       rhs_origtype = NULL_TREE;
4932     }
4933
4934   if (c_dialect_objc ())
4935     {
4936       /* Check if we are modifying an Objective-C property reference;
4937          if so, we need to generate setter calls.  */
4938       result = objc_maybe_build_modify_expr (lhs, newrhs);
4939       if (result)
4940         return result;
4941
4942       /* Else, do the check that we postponed for Objective-C.  */
4943       if (!lvalue_or_else (location, lhs, lv_assign))
4944         return error_mark_node;
4945     }
4946
4947   /* Give an error for storing in something that is 'const'.  */
4948
4949   if (TYPE_READONLY (lhstype)
4950       || ((TREE_CODE (lhstype) == RECORD_TYPE
4951            || TREE_CODE (lhstype) == UNION_TYPE)
4952           && C_TYPE_FIELDS_READONLY (lhstype)))
4953     {
4954       readonly_error (lhs, lv_assign);
4955       return error_mark_node;
4956     }
4957   else if (TREE_READONLY (lhs))
4958     readonly_warning (lhs, lv_assign);
4959
4960   /* If storing into a structure or union member,
4961      it has probably been given type `int'.
4962      Compute the type that would go with
4963      the actual amount of storage the member occupies.  */
4964
4965   if (TREE_CODE (lhs) == COMPONENT_REF
4966       && (TREE_CODE (lhstype) == INTEGER_TYPE
4967           || TREE_CODE (lhstype) == BOOLEAN_TYPE
4968           || TREE_CODE (lhstype) == REAL_TYPE
4969           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4970     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4971
4972   /* If storing in a field that is in actuality a short or narrower than one,
4973      we must store in the field in its actual type.  */
4974
4975   if (lhstype != TREE_TYPE (lhs))
4976     {
4977       lhs = copy_node (lhs);
4978       TREE_TYPE (lhs) = lhstype;
4979     }
4980
4981   /* Issue -Wc++-compat warnings about an assignment to an enum type
4982      when LHS does not have its original type.  This happens for,
4983      e.g., an enum bitfield in a struct.  */
4984   if (warn_cxx_compat
4985       && lhs_origtype != NULL_TREE
4986       && lhs_origtype != lhstype
4987       && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
4988     {
4989       tree checktype = (rhs_origtype != NULL_TREE
4990                         ? rhs_origtype
4991                         : TREE_TYPE (rhs));
4992       if (checktype != error_mark_node
4993           && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype))
4994         warning_at (location, OPT_Wc___compat,
4995                     "enum conversion in assignment is invalid in C++");
4996     }
4997
4998   /* Convert new value to destination type.  Fold it first, then
4999      restore any excess precision information, for the sake of
5000      conversion warnings.  */
5001
5002   npc = null_pointer_constant_p (newrhs);
5003   newrhs = c_fully_fold (newrhs, false, NULL);
5004   if (rhs_semantic_type)
5005     newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
5006   newrhs = convert_for_assignment (location, lhstype, newrhs, rhs_origtype,
5007                                    ic_assign, npc, NULL_TREE, NULL_TREE, 0);
5008   if (TREE_CODE (newrhs) == ERROR_MARK)
5009     return error_mark_node;
5010
5011   /* Emit ObjC write barrier, if necessary.  */
5012   if (c_dialect_objc () && flag_objc_gc)
5013     {
5014       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
5015       if (result)
5016         {
5017           protected_set_expr_location (result, location);
5018           return result;
5019         }
5020     }
5021
5022   /* Scan operands.  */
5023
5024   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
5025   TREE_SIDE_EFFECTS (result) = 1;
5026   protected_set_expr_location (result, location);
5027
5028   /* If we got the LHS in a different type for storing in,
5029      convert the result back to the nominal type of LHS
5030      so that the value we return always has the same type
5031      as the LHS argument.  */
5032
5033   if (olhstype == TREE_TYPE (result))
5034     return result;
5035
5036   result = convert_for_assignment (location, olhstype, result, rhs_origtype,
5037                                    ic_assign, false, NULL_TREE, NULL_TREE, 0);
5038   protected_set_expr_location (result, location);
5039   return result;
5040 }
5041 \f
5042 /* Return whether STRUCT_TYPE has an anonymous field with type TYPE.
5043    This is used to implement -fplan9-extensions.  */
5044
5045 static bool
5046 find_anonymous_field_with_type (tree struct_type, tree type)
5047 {
5048   tree field;
5049   bool found;
5050
5051   gcc_assert (TREE_CODE (struct_type) == RECORD_TYPE
5052               || TREE_CODE (struct_type) == UNION_TYPE);
5053   found = false;
5054   for (field = TYPE_FIELDS (struct_type);
5055        field != NULL_TREE;
5056        field = TREE_CHAIN (field))
5057     {
5058       if (DECL_NAME (field) == NULL
5059           && comptypes (type, TYPE_MAIN_VARIANT (TREE_TYPE (field))))
5060         {
5061           if (found)
5062             return false;
5063           found = true;
5064         }
5065       else if (DECL_NAME (field) == NULL
5066                && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE
5067                    || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)
5068                && find_anonymous_field_with_type (TREE_TYPE (field), type))
5069         {
5070           if (found)
5071             return false;
5072           found = true;
5073         }
5074     }
5075   return found;
5076 }
5077
5078 /* RHS is an expression whose type is pointer to struct.  If there is
5079    an anonymous field in RHS with type TYPE, then return a pointer to
5080    that field in RHS.  This is used with -fplan9-extensions.  This
5081    returns NULL if no conversion could be found.  */
5082
5083 static tree
5084 convert_to_anonymous_field (location_t location, tree type, tree rhs)
5085 {
5086   tree rhs_struct_type, lhs_main_type;
5087   tree field, found_field;
5088   bool found_sub_field;
5089   tree ret;
5090
5091   gcc_assert (POINTER_TYPE_P (TREE_TYPE (rhs)));
5092   rhs_struct_type = TREE_TYPE (TREE_TYPE (rhs));
5093   gcc_assert (TREE_CODE (rhs_struct_type) == RECORD_TYPE
5094               || TREE_CODE (rhs_struct_type) == UNION_TYPE);
5095
5096   gcc_assert (POINTER_TYPE_P (type));
5097   lhs_main_type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
5098
5099   found_field = NULL_TREE;
5100   found_sub_field = false;
5101   for (field = TYPE_FIELDS (rhs_struct_type);
5102        field != NULL_TREE;
5103        field = TREE_CHAIN (field))
5104     {
5105       if (DECL_NAME (field) != NULL_TREE
5106           || (TREE_CODE (TREE_TYPE (field)) != RECORD_TYPE
5107               && TREE_CODE (TREE_TYPE (field)) != UNION_TYPE))
5108         continue;
5109       if (comptypes (lhs_main_type, TYPE_MAIN_VARIANT (TREE_TYPE (field))))
5110         {
5111           if (found_field != NULL_TREE)
5112             return NULL_TREE;
5113           found_field = field;
5114         }
5115       else if (find_anonymous_field_with_type (TREE_TYPE (field),
5116                                                lhs_main_type))
5117         {
5118           if (found_field != NULL_TREE)
5119             return NULL_TREE;
5120           found_field = field;
5121           found_sub_field = true;
5122         }
5123     }
5124
5125   if (found_field == NULL_TREE)
5126     return NULL_TREE;
5127
5128   ret = fold_build3_loc (location, COMPONENT_REF, TREE_TYPE (found_field),
5129                          build_fold_indirect_ref (rhs), found_field,
5130                          NULL_TREE);
5131   ret = build_fold_addr_expr_loc (location, ret);
5132
5133   if (found_sub_field)
5134     {
5135       ret = convert_to_anonymous_field (location, type, ret);
5136       gcc_assert (ret != NULL_TREE);
5137     }
5138
5139   return ret;
5140 }
5141
5142 /* Convert value RHS to type TYPE as preparation for an assignment to
5143    an lvalue of type TYPE.  If ORIGTYPE is not NULL_TREE, it is the
5144    original type of RHS; this differs from TREE_TYPE (RHS) for enum
5145    types.  NULL_POINTER_CONSTANT says whether RHS was a null pointer
5146    constant before any folding.
5147    The real work of conversion is done by `convert'.
5148    The purpose of this function is to generate error messages
5149    for assignments that are not allowed in C.
5150    ERRTYPE says whether it is argument passing, assignment,
5151    initialization or return.
5152
5153    LOCATION is the location of the RHS.
5154    FUNCTION is a tree for the function being called.
5155    PARMNUM is the number of the argument, for printing in error messages.  */
5156
5157 static tree
5158 convert_for_assignment (location_t location, tree type, tree rhs,
5159                         tree origtype, enum impl_conv errtype,
5160                         bool null_pointer_constant, tree fundecl,
5161                         tree function, int parmnum)
5162 {
5163   enum tree_code codel = TREE_CODE (type);
5164   tree orig_rhs = rhs;
5165   tree rhstype;
5166   enum tree_code coder;
5167   tree rname = NULL_TREE;
5168   bool objc_ok = false;
5169
5170   if (errtype == ic_argpass)
5171     {
5172       tree selector;
5173       /* Change pointer to function to the function itself for
5174          diagnostics.  */
5175       if (TREE_CODE (function) == ADDR_EXPR
5176           && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
5177         function = TREE_OPERAND (function, 0);
5178
5179       /* Handle an ObjC selector specially for diagnostics.  */
5180       selector = objc_message_selector ();
5181       rname = function;
5182       if (selector && parmnum > 2)
5183         {
5184           rname = selector;
5185           parmnum -= 2;
5186         }
5187     }
5188
5189   /* This macro is used to emit diagnostics to ensure that all format
5190      strings are complete sentences, visible to gettext and checked at
5191      compile time.  */
5192 #define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE)               \
5193   do {                                                                   \
5194     switch (errtype)                                                     \
5195       {                                                                  \
5196       case ic_argpass:                                                   \
5197         if (pedwarn (LOCATION, OPT, AR, parmnum, rname))                 \
5198           inform ((fundecl && !DECL_IS_BUILTIN (fundecl))                \
5199                   ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,           \
5200                   "expected %qT but argument is of type %qT",            \
5201                   type, rhstype);                                        \
5202         break;                                                           \
5203       case ic_assign:                                                    \
5204         pedwarn (LOCATION, OPT, AS);                                     \
5205         break;                                                           \
5206       case ic_init:                                                      \
5207         pedwarn_init (LOCATION, OPT, IN);                                \
5208         break;                                                           \
5209       case ic_return:                                                    \
5210         pedwarn (LOCATION, OPT, RE);                                     \
5211         break;                                                           \
5212       default:                                                           \
5213         gcc_unreachable ();                                              \
5214       }                                                                  \
5215   } while (0)
5216
5217   /* This macro is used to emit diagnostics to ensure that all format
5218      strings are complete sentences, visible to gettext and checked at
5219      compile time.  It is the same as WARN_FOR_ASSIGNMENT but with an
5220      extra parameter to enumerate qualifiers.  */
5221
5222 #define WARN_FOR_QUALIFIERS(LOCATION, OPT, AR, AS, IN, RE, QUALS)        \
5223   do {                                                                   \
5224     switch (errtype)                                                     \
5225       {                                                                  \
5226       case ic_argpass:                                                   \
5227         if (pedwarn (LOCATION, OPT, AR, parmnum, rname, QUALS))          \
5228           inform ((fundecl && !DECL_IS_BUILTIN (fundecl))                \
5229                   ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,           \
5230                   "expected %qT but argument is of type %qT",            \
5231                   type, rhstype);                                        \
5232         break;                                                           \
5233       case ic_assign:                                                    \
5234         pedwarn (LOCATION, OPT, AS, QUALS);                          \
5235         break;                                                           \
5236       case ic_init:                                                      \
5237         pedwarn (LOCATION, OPT, IN, QUALS);                          \
5238         break;                                                           \
5239       case ic_return:                                                    \
5240         pedwarn (LOCATION, OPT, RE, QUALS);                              \
5241         break;                                                           \
5242       default:                                                           \
5243         gcc_unreachable ();                                              \
5244       }                                                                  \
5245   } while (0)
5246
5247   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
5248     rhs = TREE_OPERAND (rhs, 0);
5249
5250   rhstype = TREE_TYPE (rhs);
5251   coder = TREE_CODE (rhstype);
5252
5253   if (coder == ERROR_MARK)
5254     return error_mark_node;
5255
5256   if (c_dialect_objc ())
5257     {
5258       int parmno;
5259
5260       switch (errtype)
5261         {
5262         case ic_return:
5263           parmno = 0;
5264           break;
5265
5266         case ic_assign:
5267           parmno = -1;
5268           break;
5269
5270         case ic_init:
5271           parmno = -2;
5272           break;
5273
5274         default:
5275           parmno = parmnum;
5276           break;
5277         }
5278
5279       objc_ok = objc_compare_types (type, rhstype, parmno, rname);
5280     }
5281
5282   if (warn_cxx_compat)
5283     {
5284       tree checktype = origtype != NULL_TREE ? origtype : rhstype;
5285       if (checktype != error_mark_node
5286           && TREE_CODE (type) == ENUMERAL_TYPE
5287           && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
5288         {
5289           WARN_FOR_ASSIGNMENT (input_location, OPT_Wc___compat,
5290                                G_("enum conversion when passing argument "
5291                                   "%d of %qE is invalid in C++"),
5292                                G_("enum conversion in assignment is "
5293                                   "invalid in C++"),
5294                                G_("enum conversion in initialization is "
5295                                   "invalid in C++"),
5296                                G_("enum conversion in return is "
5297                                   "invalid in C++"));
5298         }
5299     }
5300
5301   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
5302     return rhs;
5303
5304   if (coder == VOID_TYPE)
5305     {
5306       /* Except for passing an argument to an unprototyped function,
5307          this is a constraint violation.  When passing an argument to
5308          an unprototyped function, it is compile-time undefined;
5309          making it a constraint in that case was rejected in
5310          DR#252.  */
5311       error_at (location, "void value not ignored as it ought to be");
5312       return error_mark_node;
5313     }
5314   rhs = require_complete_type (rhs);
5315   if (rhs == error_mark_node)
5316     return error_mark_node;
5317   /* A type converts to a reference to it.
5318      This code doesn't fully support references, it's just for the
5319      special case of va_start and va_copy.  */
5320   if (codel == REFERENCE_TYPE
5321       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
5322     {
5323       if (!lvalue_p (rhs))
5324         {
5325           error_at (location, "cannot pass rvalue to reference parameter");
5326           return error_mark_node;
5327         }
5328       if (!c_mark_addressable (rhs))
5329         return error_mark_node;
5330       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
5331       SET_EXPR_LOCATION (rhs, location);
5332
5333       /* We already know that these two types are compatible, but they
5334          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
5335          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
5336          likely to be va_list, a typedef to __builtin_va_list, which
5337          is different enough that it will cause problems later.  */
5338       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
5339         {
5340           rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
5341           SET_EXPR_LOCATION (rhs, location);
5342         }
5343
5344       rhs = build1 (NOP_EXPR, type, rhs);
5345       SET_EXPR_LOCATION (rhs, location);
5346       return rhs;
5347     }
5348   /* Some types can interconvert without explicit casts.  */
5349   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
5350            && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
5351     return convert (type, rhs);
5352   /* Arithmetic types all interconvert, and enum is treated like int.  */
5353   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
5354             || codel == FIXED_POINT_TYPE
5355             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
5356             || codel == BOOLEAN_TYPE)
5357            && (coder == INTEGER_TYPE || coder == REAL_TYPE
5358                || coder == FIXED_POINT_TYPE
5359                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
5360                || coder == BOOLEAN_TYPE))
5361     {
5362       tree ret;
5363       bool save = in_late_binary_op;
5364       if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE)
5365         in_late_binary_op = true;
5366       ret = convert_and_check (type, orig_rhs);
5367       if (codel == BOOLEAN_TYPE || codel == COMPLEX_TYPE)
5368         in_late_binary_op = save;
5369       return ret;
5370     }
5371
5372   /* Aggregates in different TUs might need conversion.  */
5373   if ((codel == RECORD_TYPE || codel == UNION_TYPE)
5374       && codel == coder
5375       && comptypes (type, rhstype))
5376     return convert_and_check (type, rhs);
5377
5378   /* Conversion to a transparent union or record from its member types.
5379      This applies only to function arguments.  */
5380   if (((codel == UNION_TYPE || codel == RECORD_TYPE)
5381       && TYPE_TRANSPARENT_AGGR (type))
5382       && errtype == ic_argpass)
5383     {
5384       tree memb, marginal_memb = NULL_TREE;
5385
5386       for (memb = TYPE_FIELDS (type); memb ; memb = DECL_CHAIN (memb))
5387         {
5388           tree memb_type = TREE_TYPE (memb);
5389
5390           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
5391                          TYPE_MAIN_VARIANT (rhstype)))
5392             break;
5393
5394           if (TREE_CODE (memb_type) != POINTER_TYPE)
5395             continue;
5396
5397           if (coder == POINTER_TYPE)
5398             {
5399               tree ttl = TREE_TYPE (memb_type);
5400               tree ttr = TREE_TYPE (rhstype);
5401
5402               /* Any non-function converts to a [const][volatile] void *
5403                  and vice versa; otherwise, targets must be the same.
5404                  Meanwhile, the lhs target must have all the qualifiers of
5405                  the rhs.  */
5406               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5407                   || comp_target_types (location, memb_type, rhstype))
5408                 {
5409                   /* If this type won't generate any warnings, use it.  */
5410                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
5411                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
5412                            && TREE_CODE (ttl) == FUNCTION_TYPE)
5413                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
5414                              == TYPE_QUALS (ttr))
5415                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
5416                              == TYPE_QUALS (ttl))))
5417                     break;
5418
5419                   /* Keep looking for a better type, but remember this one.  */
5420                   if (!marginal_memb)
5421                     marginal_memb = memb;
5422                 }
5423             }
5424
5425           /* Can convert integer zero to any pointer type.  */
5426           if (null_pointer_constant)
5427             {
5428               rhs = null_pointer_node;
5429               break;
5430             }
5431         }
5432
5433       if (memb || marginal_memb)
5434         {
5435           if (!memb)
5436             {
5437               /* We have only a marginally acceptable member type;
5438                  it needs a warning.  */
5439               tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
5440               tree ttr = TREE_TYPE (rhstype);
5441
5442               /* Const and volatile mean something different for function
5443                  types, so the usual warnings are not appropriate.  */
5444               if (TREE_CODE (ttr) == FUNCTION_TYPE
5445                   && TREE_CODE (ttl) == FUNCTION_TYPE)
5446                 {
5447                   /* Because const and volatile on functions are
5448                      restrictions that say the function will not do
5449                      certain things, it is okay to use a const or volatile
5450                      function where an ordinary one is wanted, but not
5451                      vice-versa.  */
5452                   if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
5453                       & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
5454                     WARN_FOR_QUALIFIERS (location, 0,
5455                                          G_("passing argument %d of %qE "
5456                                             "makes %q#v qualified function "
5457                                             "pointer from unqualified"),
5458                                          G_("assignment makes %q#v qualified "
5459                                             "function pointer from "
5460                                             "unqualified"),
5461                                          G_("initialization makes %q#v qualified "
5462                                             "function pointer from "
5463                                             "unqualified"),
5464                                          G_("return makes %q#v qualified function "
5465                                             "pointer from unqualified"),
5466                                          TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
5467                 }
5468               else if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
5469                        & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
5470                 WARN_FOR_QUALIFIERS (location, 0,
5471                                      G_("passing argument %d of %qE discards "
5472                                         "%qv qualifier from pointer target type"),
5473                                      G_("assignment discards %qv qualifier "
5474                                         "from pointer target type"),
5475                                      G_("initialization discards %qv qualifier "
5476                                         "from pointer target type"),
5477                                      G_("return discards %qv qualifier from "
5478                                         "pointer target type"),
5479                                      TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
5480
5481               memb = marginal_memb;
5482             }
5483
5484           if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
5485             pedwarn (location, OPT_pedantic,
5486                      "ISO C prohibits argument conversion to union type");
5487
5488           rhs = fold_convert_loc (location, TREE_TYPE (memb), rhs);
5489           return build_constructor_single (type, memb, rhs);
5490         }
5491     }
5492
5493   /* Conversions among pointers */
5494   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
5495            && (coder == codel))
5496     {
5497       tree ttl = TREE_TYPE (type);
5498       tree ttr = TREE_TYPE (rhstype);
5499       tree mvl = ttl;
5500       tree mvr = ttr;
5501       bool is_opaque_pointer;
5502       int target_cmp = 0;   /* Cache comp_target_types () result.  */
5503       addr_space_t asl;
5504       addr_space_t asr;
5505
5506       if (TREE_CODE (mvl) != ARRAY_TYPE)
5507         mvl = TYPE_MAIN_VARIANT (mvl);
5508       if (TREE_CODE (mvr) != ARRAY_TYPE)
5509         mvr = TYPE_MAIN_VARIANT (mvr);
5510       /* Opaque pointers are treated like void pointers.  */
5511       is_opaque_pointer = vector_targets_convertible_p (ttl, ttr);
5512
5513       /* The Plan 9 compiler permits a pointer to a struct to be
5514          automatically converted into a pointer to an anonymous field
5515          within the struct.  */
5516       if (flag_plan9_extensions
5517           && (TREE_CODE (mvl) == RECORD_TYPE || TREE_CODE(mvl) == UNION_TYPE)
5518           && (TREE_CODE (mvr) == RECORD_TYPE || TREE_CODE(mvr) == UNION_TYPE)
5519           && mvl != mvr)
5520         {
5521           tree new_rhs = convert_to_anonymous_field (location, type, rhs);
5522           if (new_rhs != NULL_TREE)
5523             {
5524               rhs = new_rhs;
5525               rhstype = TREE_TYPE (rhs);
5526               coder = TREE_CODE (rhstype);
5527               ttr = TREE_TYPE (rhstype);
5528               mvr = TYPE_MAIN_VARIANT (ttr);
5529             }
5530         }
5531
5532       /* C++ does not allow the implicit conversion void* -> T*.  However,
5533          for the purpose of reducing the number of false positives, we
5534          tolerate the special case of
5535
5536                 int *p = NULL;
5537
5538          where NULL is typically defined in C to be '(void *) 0'.  */
5539       if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
5540         warning_at (location, OPT_Wc___compat,
5541                     "request for implicit conversion "
5542                     "from %qT to %qT not permitted in C++", rhstype, type);
5543
5544       /* See if the pointers point to incompatible address spaces.  */
5545       asl = TYPE_ADDR_SPACE (ttl);
5546       asr = TYPE_ADDR_SPACE (ttr);
5547       if (!null_pointer_constant_p (rhs)
5548           && asr != asl && !targetm.addr_space.subset_p (asr, asl))
5549         {
5550           switch (errtype)
5551             {
5552             case ic_argpass:
5553               error_at (location, "passing argument %d of %qE from pointer to "
5554                         "non-enclosed address space", parmnum, rname);
5555               break;
5556             case ic_assign:
5557               error_at (location, "assignment from pointer to "
5558                         "non-enclosed address space");
5559               break;
5560             case ic_init:
5561               error_at (location, "initialization from pointer to "
5562                         "non-enclosed address space");
5563               break;
5564             case ic_return:
5565               error_at (location, "return from pointer to "
5566                         "non-enclosed address space");
5567               break;
5568             default:
5569               gcc_unreachable ();
5570             }
5571           return error_mark_node;
5572         }
5573
5574       /* Check if the right-hand side has a format attribute but the
5575          left-hand side doesn't.  */
5576       if (warn_missing_format_attribute
5577           && check_missing_format_attribute (type, rhstype))
5578         {
5579           switch (errtype)
5580           {
5581           case ic_argpass:
5582             warning_at (location, OPT_Wmissing_format_attribute,
5583                         "argument %d of %qE might be "
5584                         "a candidate for a format attribute",
5585                         parmnum, rname);
5586             break;
5587           case ic_assign:
5588             warning_at (location, OPT_Wmissing_format_attribute,
5589                         "assignment left-hand side might be "
5590                         "a candidate for a format attribute");
5591             break;
5592           case ic_init:
5593             warning_at (location, OPT_Wmissing_format_attribute,
5594                         "initialization left-hand side might be "
5595                         "a candidate for a format attribute");
5596             break;
5597           case ic_return:
5598             warning_at (location, OPT_Wmissing_format_attribute,
5599                         "return type might be "
5600                         "a candidate for a format attribute");
5601             break;
5602           default:
5603             gcc_unreachable ();
5604           }
5605         }
5606
5607       /* Any non-function converts to a [const][volatile] void *
5608          and vice versa; otherwise, targets must be the same.
5609          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
5610       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5611           || (target_cmp = comp_target_types (location, type, rhstype))
5612           || is_opaque_pointer
5613           || (c_common_unsigned_type (mvl)
5614               == c_common_unsigned_type (mvr)))
5615         {
5616           if (pedantic
5617               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
5618                   ||
5619                   (VOID_TYPE_P (ttr)
5620                    && !null_pointer_constant
5621                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
5622             WARN_FOR_ASSIGNMENT (location, OPT_pedantic,
5623                                  G_("ISO C forbids passing argument %d of "
5624                                     "%qE between function pointer "
5625                                     "and %<void *%>"),
5626                                  G_("ISO C forbids assignment between "
5627                                     "function pointer and %<void *%>"),
5628                                  G_("ISO C forbids initialization between "
5629                                     "function pointer and %<void *%>"),
5630                                  G_("ISO C forbids return between function "
5631                                     "pointer and %<void *%>"));
5632           /* Const and volatile mean something different for function types,
5633              so the usual warnings are not appropriate.  */
5634           else if (TREE_CODE (ttr) != FUNCTION_TYPE
5635                    && TREE_CODE (ttl) != FUNCTION_TYPE)
5636             {
5637               if (TYPE_QUALS_NO_ADDR_SPACE (ttr)
5638                   & ~TYPE_QUALS_NO_ADDR_SPACE (ttl))
5639                 {
5640                   WARN_FOR_QUALIFIERS (location, 0,
5641                                        G_("passing argument %d of %qE discards "
5642                                           "%qv qualifier from pointer target type"),
5643                                        G_("assignment discards %qv qualifier "
5644                                           "from pointer target type"),
5645                                        G_("initialization discards %qv qualifier "
5646                                           "from pointer target type"),
5647                                        G_("return discards %qv qualifier from "
5648                                           "pointer target type"),
5649                                        TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl));
5650                 }
5651               /* If this is not a case of ignoring a mismatch in signedness,
5652                  no warning.  */
5653               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
5654                        || target_cmp)
5655                 ;
5656               /* If there is a mismatch, do warn.  */
5657               else if (warn_pointer_sign)
5658                 WARN_FOR_ASSIGNMENT (location, OPT_Wpointer_sign,
5659                                      G_("pointer targets in passing argument "
5660                                         "%d of %qE differ in signedness"),
5661                                      G_("pointer targets in assignment "
5662                                         "differ in signedness"),
5663                                      G_("pointer targets in initialization "
5664                                         "differ in signedness"),
5665                                      G_("pointer targets in return differ "
5666                                         "in signedness"));
5667             }
5668           else if (TREE_CODE (ttl) == FUNCTION_TYPE
5669                    && TREE_CODE (ttr) == FUNCTION_TYPE)
5670             {
5671               /* Because const and volatile on functions are restrictions
5672                  that say the function will not do certain things,
5673                  it is okay to use a const or volatile function
5674                  where an ordinary one is wanted, but not vice-versa.  */
5675               if (TYPE_QUALS_NO_ADDR_SPACE (ttl)
5676                   & ~TYPE_QUALS_NO_ADDR_SPACE (ttr))
5677                 WARN_FOR_QUALIFIERS (location, 0,
5678                                      G_("passing argument %d of %qE makes "
5679                                         "%q#v qualified function pointer "
5680                                         "from unqualified"),
5681                                      G_("assignment makes %q#v qualified function "
5682                                         "pointer from unqualified"),
5683                                      G_("initialization makes %q#v qualified "
5684                                         "function pointer from unqualified"),
5685                                      G_("return makes %q#v qualified function "
5686                                         "pointer from unqualified"),
5687                                      TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr));
5688             }
5689         }
5690       else
5691         /* Avoid warning about the volatile ObjC EH puts on decls.  */
5692         if (!objc_ok)
5693           WARN_FOR_ASSIGNMENT (location, 0,
5694                                G_("passing argument %d of %qE from "
5695                                   "incompatible pointer type"),
5696                                G_("assignment from incompatible pointer type"),
5697                                G_("initialization from incompatible "
5698                                   "pointer type"),
5699                                G_("return from incompatible pointer type"));
5700
5701       return convert (type, rhs);
5702     }
5703   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
5704     {
5705       /* ??? This should not be an error when inlining calls to
5706          unprototyped functions.  */
5707       error_at (location, "invalid use of non-lvalue array");
5708       return error_mark_node;
5709     }
5710   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
5711     {
5712       /* An explicit constant 0 can convert to a pointer,
5713          or one that results from arithmetic, even including
5714          a cast to integer type.  */
5715       if (!null_pointer_constant)
5716         WARN_FOR_ASSIGNMENT (location, 0,
5717                              G_("passing argument %d of %qE makes "
5718                                 "pointer from integer without a cast"),
5719                              G_("assignment makes pointer from integer "
5720                                 "without a cast"),
5721                              G_("initialization makes pointer from "
5722                                 "integer without a cast"),
5723                              G_("return makes pointer from integer "
5724                                 "without a cast"));
5725
5726       return convert (type, rhs);
5727     }
5728   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
5729     {
5730       WARN_FOR_ASSIGNMENT (location, 0,
5731                            G_("passing argument %d of %qE makes integer "
5732                               "from pointer without a cast"),
5733                            G_("assignment makes integer from pointer "
5734                               "without a cast"),
5735                            G_("initialization makes integer from pointer "
5736                               "without a cast"),
5737                            G_("return makes integer from pointer "
5738                               "without a cast"));
5739       return convert (type, rhs);
5740     }
5741   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
5742     {
5743       tree ret;
5744       bool save = in_late_binary_op;
5745       in_late_binary_op = true;
5746       ret = convert (type, rhs);
5747       in_late_binary_op = save;
5748       return ret;
5749     }
5750
5751   switch (errtype)
5752     {
5753     case ic_argpass:
5754       error_at (location, "incompatible type for argument %d of %qE", parmnum, rname);
5755       inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
5756               ? DECL_SOURCE_LOCATION (fundecl) : input_location,
5757               "expected %qT but argument is of type %qT", type, rhstype);
5758       break;
5759     case ic_assign:
5760       error_at (location, "incompatible types when assigning to type %qT from "
5761                 "type %qT", type, rhstype);
5762       break;
5763     case ic_init:
5764       error_at (location,
5765                 "incompatible types when initializing type %qT using type %qT",
5766                 type, rhstype);
5767       break;
5768     case ic_return:
5769       error_at (location,
5770                 "incompatible types when returning type %qT but %qT was "
5771                 "expected", rhstype, type);
5772       break;
5773     default:
5774       gcc_unreachable ();
5775     }
5776
5777   return error_mark_node;
5778 }
5779 \f
5780 /* If VALUE is a compound expr all of whose expressions are constant, then
5781    return its value.  Otherwise, return error_mark_node.
5782
5783    This is for handling COMPOUND_EXPRs as initializer elements
5784    which is allowed with a warning when -pedantic is specified.  */
5785
5786 static tree
5787 valid_compound_expr_initializer (tree value, tree endtype)
5788 {
5789   if (TREE_CODE (value) == COMPOUND_EXPR)
5790     {
5791       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
5792           == error_mark_node)
5793         return error_mark_node;
5794       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
5795                                               endtype);
5796     }
5797   else if (!initializer_constant_valid_p (value, endtype))
5798     return error_mark_node;
5799   else
5800     return value;
5801 }
5802 \f
5803 /* Perform appropriate conversions on the initial value of a variable,
5804    store it in the declaration DECL,
5805    and print any error messages that are appropriate.
5806    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5807    If the init is invalid, store an ERROR_MARK.
5808
5809    INIT_LOC is the location of the initial value.  */
5810
5811 void
5812 store_init_value (location_t init_loc, tree decl, tree init, tree origtype)
5813 {
5814   tree value, type;
5815   bool npc = false;
5816
5817   /* If variable's type was invalidly declared, just ignore it.  */
5818
5819   type = TREE_TYPE (decl);
5820   if (TREE_CODE (type) == ERROR_MARK)
5821     return;
5822
5823   /* Digest the specified initializer into an expression.  */
5824
5825   if (init)
5826     npc = null_pointer_constant_p (init);
5827   value = digest_init (init_loc, type, init, origtype, npc,
5828                        true, TREE_STATIC (decl));
5829
5830   /* Store the expression if valid; else report error.  */
5831
5832   if (!in_system_header
5833       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
5834     warning (OPT_Wtraditional, "traditional C rejects automatic "
5835              "aggregate initialization");
5836
5837   DECL_INITIAL (decl) = value;
5838
5839   /* ANSI wants warnings about out-of-range constant initializers.  */
5840   STRIP_TYPE_NOPS (value);
5841   if (TREE_STATIC (decl))
5842     constant_expression_warning (value);
5843
5844   /* Check if we need to set array size from compound literal size.  */
5845   if (TREE_CODE (type) == ARRAY_TYPE
5846       && TYPE_DOMAIN (type) == 0
5847       && value != error_mark_node)
5848     {
5849       tree inside_init = init;
5850
5851       STRIP_TYPE_NOPS (inside_init);
5852       inside_init = fold (inside_init);
5853
5854       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
5855         {
5856           tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
5857
5858           if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
5859             {
5860               /* For int foo[] = (int [3]){1}; we need to set array size
5861                  now since later on array initializer will be just the
5862                  brace enclosed list of the compound literal.  */
5863               tree etype = strip_array_types (TREE_TYPE (decl));
5864               type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5865               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
5866               layout_type (type);
5867               layout_decl (cldecl, 0);
5868               TREE_TYPE (decl)
5869                 = c_build_qualified_type (type, TYPE_QUALS (etype));
5870             }
5871         }
5872     }
5873 }
5874 \f
5875 /* Methods for storing and printing names for error messages.  */
5876
5877 /* Implement a spelling stack that allows components of a name to be pushed
5878    and popped.  Each element on the stack is this structure.  */
5879
5880 struct spelling
5881 {
5882   int kind;
5883   union
5884     {
5885       unsigned HOST_WIDE_INT i;
5886       const char *s;
5887     } u;
5888 };
5889
5890 #define SPELLING_STRING 1
5891 #define SPELLING_MEMBER 2
5892 #define SPELLING_BOUNDS 3
5893
5894 static struct spelling *spelling;       /* Next stack element (unused).  */
5895 static struct spelling *spelling_base;  /* Spelling stack base.  */
5896 static int spelling_size;               /* Size of the spelling stack.  */
5897
5898 /* Macros to save and restore the spelling stack around push_... functions.
5899    Alternative to SAVE_SPELLING_STACK.  */
5900
5901 #define SPELLING_DEPTH() (spelling - spelling_base)
5902 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
5903
5904 /* Push an element on the spelling stack with type KIND and assign VALUE
5905    to MEMBER.  */
5906
5907 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
5908 {                                                                       \
5909   int depth = SPELLING_DEPTH ();                                        \
5910                                                                         \
5911   if (depth >= spelling_size)                                           \
5912     {                                                                   \
5913       spelling_size += 10;                                              \
5914       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
5915                                   spelling_size);                       \
5916       RESTORE_SPELLING_DEPTH (depth);                                   \
5917     }                                                                   \
5918                                                                         \
5919   spelling->kind = (KIND);                                              \
5920   spelling->MEMBER = (VALUE);                                           \
5921   spelling++;                                                           \
5922 }
5923
5924 /* Push STRING on the stack.  Printed literally.  */
5925
5926 static void
5927 push_string (const char *string)
5928 {
5929   PUSH_SPELLING (SPELLING_STRING, string, u.s);
5930 }
5931
5932 /* Push a member name on the stack.  Printed as '.' STRING.  */
5933
5934 static void
5935 push_member_name (tree decl)
5936 {
5937   const char *const string
5938     = (DECL_NAME (decl)
5939        ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)))
5940        : _("<anonymous>"));
5941   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
5942 }
5943
5944 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
5945
5946 static void
5947 push_array_bounds (unsigned HOST_WIDE_INT bounds)
5948 {
5949   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
5950 }
5951
5952 /* Compute the maximum size in bytes of the printed spelling.  */
5953
5954 static int
5955 spelling_length (void)
5956 {
5957   int size = 0;
5958   struct spelling *p;
5959
5960   for (p = spelling_base; p < spelling; p++)
5961     {
5962       if (p->kind == SPELLING_BOUNDS)
5963         size += 25;
5964       else
5965         size += strlen (p->u.s) + 1;
5966     }
5967
5968   return size;
5969 }
5970
5971 /* Print the spelling to BUFFER and return it.  */
5972
5973 static char *
5974 print_spelling (char *buffer)
5975 {
5976   char *d = buffer;
5977   struct spelling *p;
5978
5979   for (p = spelling_base; p < spelling; p++)
5980     if (p->kind == SPELLING_BOUNDS)
5981       {
5982         sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
5983         d += strlen (d);
5984       }
5985     else
5986       {
5987         const char *s;
5988         if (p->kind == SPELLING_MEMBER)
5989           *d++ = '.';
5990         for (s = p->u.s; (*d = *s++); d++)
5991           ;
5992       }
5993   *d++ = '\0';
5994   return buffer;
5995 }
5996
5997 /* Issue an error message for a bad initializer component.
5998    GMSGID identifies the message.
5999    The component name is taken from the spelling stack.  */
6000
6001 void
6002 error_init (const char *gmsgid)
6003 {
6004   char *ofwhat;
6005
6006   /* The gmsgid may be a format string with %< and %>. */
6007   error (gmsgid);
6008   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6009   if (*ofwhat)
6010     error ("(near initialization for %qs)", ofwhat);
6011 }
6012
6013 /* Issue a pedantic warning for a bad initializer component.  OPT is
6014    the option OPT_* (from options.h) controlling this warning or 0 if
6015    it is unconditionally given.  GMSGID identifies the message.  The
6016    component name is taken from the spelling stack.  */
6017
6018 void
6019 pedwarn_init (location_t location, int opt, const char *gmsgid)
6020 {
6021   char *ofwhat;
6022
6023   /* The gmsgid may be a format string with %< and %>. */
6024   pedwarn (location, opt, gmsgid);
6025   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6026   if (*ofwhat)
6027     pedwarn (location, opt, "(near initialization for %qs)", ofwhat);
6028 }
6029
6030 /* Issue a warning for a bad initializer component.
6031
6032    OPT is the OPT_W* value corresponding to the warning option that
6033    controls this warning.  GMSGID identifies the message.  The
6034    component name is taken from the spelling stack.  */
6035
6036 static void
6037 warning_init (int opt, const char *gmsgid)
6038 {
6039   char *ofwhat;
6040
6041   /* The gmsgid may be a format string with %< and %>. */
6042   warning (opt, gmsgid);
6043   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
6044   if (*ofwhat)
6045     warning (opt, "(near initialization for %qs)", ofwhat);
6046 }
6047 \f
6048 /* If TYPE is an array type and EXPR is a parenthesized string
6049    constant, warn if pedantic that EXPR is being used to initialize an
6050    object of type TYPE.  */
6051
6052 void
6053 maybe_warn_string_init (tree type, struct c_expr expr)
6054 {
6055   if (pedantic
6056       && TREE_CODE (type) == ARRAY_TYPE
6057       && TREE_CODE (expr.value) == STRING_CST
6058       && expr.original_code != STRING_CST)
6059     pedwarn_init (input_location, OPT_pedantic,
6060                   "array initialized from parenthesized string constant");
6061 }
6062
6063 /* Digest the parser output INIT as an initializer for type TYPE.
6064    Return a C expression of type TYPE to represent the initial value.
6065
6066    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
6067
6068    NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
6069
6070    If INIT is a string constant, STRICT_STRING is true if it is
6071    unparenthesized or we should not warn here for it being parenthesized.
6072    For other types of INIT, STRICT_STRING is not used.
6073
6074    INIT_LOC is the location of the INIT.
6075
6076    REQUIRE_CONSTANT requests an error if non-constant initializers or
6077    elements are seen.  */
6078
6079 static tree
6080 digest_init (location_t init_loc, tree type, tree init, tree origtype,
6081              bool null_pointer_constant, bool strict_string,
6082              int require_constant)
6083 {
6084   enum tree_code code = TREE_CODE (type);
6085   tree inside_init = init;
6086   tree semantic_type = NULL_TREE;
6087   bool maybe_const = true;
6088
6089   if (type == error_mark_node
6090       || !init
6091       || init == error_mark_node
6092       || TREE_TYPE (init) == error_mark_node)
6093     return error_mark_node;
6094
6095   STRIP_TYPE_NOPS (inside_init);
6096
6097   if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
6098     {
6099       semantic_type = TREE_TYPE (inside_init);
6100       inside_init = TREE_OPERAND (inside_init, 0);
6101     }
6102   inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
6103   inside_init = decl_constant_value_for_optimization (inside_init);
6104
6105   /* Initialization of an array of chars from a string constant
6106      optionally enclosed in braces.  */
6107
6108   if (code == ARRAY_TYPE && inside_init
6109       && TREE_CODE (inside_init) == STRING_CST)
6110     {
6111       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
6112       /* Note that an array could be both an array of character type
6113          and an array of wchar_t if wchar_t is signed char or unsigned
6114          char.  */
6115       bool char_array = (typ1 == char_type_node
6116                          || typ1 == signed_char_type_node
6117                          || typ1 == unsigned_char_type_node);
6118       bool wchar_array = !!comptypes (typ1, wchar_type_node);
6119       bool char16_array = !!comptypes (typ1, char16_type_node);
6120       bool char32_array = !!comptypes (typ1, char32_type_node);
6121
6122       if (char_array || wchar_array || char16_array || char32_array)
6123         {
6124           struct c_expr expr;
6125           tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
6126           expr.value = inside_init;
6127           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
6128           expr.original_type = NULL;
6129           maybe_warn_string_init (type, expr);
6130
6131           if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
6132             pedwarn_init (init_loc, OPT_pedantic,
6133                           "initialization of a flexible array member");
6134
6135           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6136                          TYPE_MAIN_VARIANT (type)))
6137             return inside_init;
6138
6139           if (char_array)
6140             {
6141               if (typ2 != char_type_node)
6142                 {
6143                   error_init ("char-array initialized from wide string");
6144                   return error_mark_node;
6145                 }
6146             }
6147           else
6148             {
6149               if (typ2 == char_type_node)
6150                 {
6151                   error_init ("wide character array initialized from non-wide "
6152                               "string");
6153                   return error_mark_node;
6154                 }
6155               else if (!comptypes(typ1, typ2))
6156                 {
6157                   error_init ("wide character array initialized from "
6158                               "incompatible wide string");
6159                   return error_mark_node;
6160                 }
6161             }
6162
6163           TREE_TYPE (inside_init) = type;
6164           if (TYPE_DOMAIN (type) != 0
6165               && TYPE_SIZE (type) != 0
6166               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
6167             {
6168               unsigned HOST_WIDE_INT len = TREE_STRING_LENGTH (inside_init);
6169
6170               /* Subtract the size of a single (possibly wide) character
6171                  because it's ok to ignore the terminating null char
6172                  that is counted in the length of the constant.  */
6173               if (0 > compare_tree_int (TYPE_SIZE_UNIT (type),
6174                                         (len
6175                                          - (TYPE_PRECISION (typ1)
6176                                             / BITS_PER_UNIT))))
6177                 pedwarn_init (init_loc, 0,
6178                               ("initializer-string for array of chars "
6179                                "is too long"));
6180               else if (warn_cxx_compat
6181                        && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), len))
6182                 warning_at (init_loc, OPT_Wc___compat,
6183                             ("initializer-string for array chars "
6184                              "is too long for C++"));
6185             }
6186
6187           return inside_init;
6188         }
6189       else if (INTEGRAL_TYPE_P (typ1))
6190         {
6191           error_init ("array of inappropriate type initialized "
6192                       "from string constant");
6193           return error_mark_node;
6194         }
6195     }
6196
6197   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
6198      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
6199      below and handle as a constructor.  */
6200   if (code == VECTOR_TYPE
6201       && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
6202       && vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
6203       && TREE_CONSTANT (inside_init))
6204     {
6205       if (TREE_CODE (inside_init) == VECTOR_CST
6206           && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6207                         TYPE_MAIN_VARIANT (type)))
6208         return inside_init;
6209
6210       if (TREE_CODE (inside_init) == CONSTRUCTOR)
6211         {
6212           unsigned HOST_WIDE_INT ix;
6213           tree value;
6214           bool constant_p = true;
6215
6216           /* Iterate through elements and check if all constructor
6217              elements are *_CSTs.  */
6218           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
6219             if (!CONSTANT_CLASS_P (value))
6220               {
6221                 constant_p = false;
6222                 break;
6223               }
6224
6225           if (constant_p)
6226             return build_vector_from_ctor (type,
6227                                            CONSTRUCTOR_ELTS (inside_init));
6228         }
6229     }
6230
6231   if (warn_sequence_point)
6232     verify_sequence_points (inside_init);
6233
6234   /* Any type can be initialized
6235      from an expression of the same type, optionally with braces.  */
6236
6237   if (inside_init && TREE_TYPE (inside_init) != 0
6238       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
6239                      TYPE_MAIN_VARIANT (type))
6240           || (code == ARRAY_TYPE
6241               && comptypes (TREE_TYPE (inside_init), type))
6242           || (code == VECTOR_TYPE
6243               && comptypes (TREE_TYPE (inside_init), type))
6244           || (code == POINTER_TYPE
6245               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
6246               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
6247                             TREE_TYPE (type)))))
6248     {
6249       if (code == POINTER_TYPE)
6250         {
6251           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
6252             {
6253               if (TREE_CODE (inside_init) == STRING_CST
6254                   || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
6255                 inside_init = array_to_pointer_conversion
6256                   (init_loc, inside_init);
6257               else
6258                 {
6259                   error_init ("invalid use of non-lvalue array");
6260                   return error_mark_node;
6261                 }
6262             }
6263         }
6264
6265       if (code == VECTOR_TYPE)
6266         /* Although the types are compatible, we may require a
6267            conversion.  */
6268         inside_init = convert (type, inside_init);
6269
6270       if (require_constant
6271           && (code == VECTOR_TYPE || !flag_isoc99)
6272           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
6273         {
6274           /* As an extension, allow initializing objects with static storage
6275              duration with compound literals (which are then treated just as
6276              the brace enclosed list they contain).  Also allow this for
6277              vectors, as we can only assign them with compound literals.  */
6278           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
6279           inside_init = DECL_INITIAL (decl);
6280         }
6281
6282       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
6283           && TREE_CODE (inside_init) != CONSTRUCTOR)
6284         {
6285           error_init ("array initialized from non-constant array expression");
6286           return error_mark_node;
6287         }
6288
6289       /* Compound expressions can only occur here if -pedantic or
6290          -pedantic-errors is specified.  In the later case, we always want
6291          an error.  In the former case, we simply want a warning.  */
6292       if (require_constant && pedantic
6293           && TREE_CODE (inside_init) == COMPOUND_EXPR)
6294         {
6295           inside_init
6296             = valid_compound_expr_initializer (inside_init,
6297                                                TREE_TYPE (inside_init));
6298           if (inside_init == error_mark_node)
6299             error_init ("initializer element is not constant");
6300           else
6301             pedwarn_init (init_loc, OPT_pedantic,
6302                           "initializer element is not constant");
6303           if (flag_pedantic_errors)
6304             inside_init = error_mark_node;
6305         }
6306       else if (require_constant
6307                && !initializer_constant_valid_p (inside_init,
6308                                                  TREE_TYPE (inside_init)))
6309         {
6310           error_init ("initializer element is not constant");
6311           inside_init = error_mark_node;
6312         }
6313       else if (require_constant && !maybe_const)
6314         pedwarn_init (init_loc, 0,
6315                       "initializer element is not a constant expression");
6316
6317       /* Added to enable additional -Wmissing-format-attribute warnings.  */
6318       if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
6319         inside_init = convert_for_assignment (init_loc, type, inside_init,
6320                                               origtype,
6321                                               ic_init, null_pointer_constant,
6322                                               NULL_TREE, NULL_TREE, 0);
6323       return inside_init;
6324     }
6325
6326   /* Handle scalar types, including conversions.  */
6327
6328   if (code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE
6329       || code == POINTER_TYPE || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
6330       || code == COMPLEX_TYPE || code == VECTOR_TYPE)
6331     {
6332       if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
6333           && (TREE_CODE (init) == STRING_CST
6334               || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
6335         inside_init = init = array_to_pointer_conversion (init_loc, init);
6336       if (semantic_type)
6337         inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
6338                               inside_init);
6339       inside_init
6340         = convert_for_assignment (init_loc, type, inside_init, origtype,
6341                                   ic_init, null_pointer_constant,
6342                                   NULL_TREE, NULL_TREE, 0);
6343
6344       /* Check to see if we have already given an error message.  */
6345       if (inside_init == error_mark_node)
6346         ;
6347       else if (require_constant && !TREE_CONSTANT (inside_init))
6348         {
6349           error_init ("initializer element is not constant");
6350           inside_init = error_mark_node;
6351         }
6352       else if (require_constant
6353                && !initializer_constant_valid_p (inside_init,
6354                                                  TREE_TYPE (inside_init)))
6355         {
6356           error_init ("initializer element is not computable at load time");
6357           inside_init = error_mark_node;
6358         }
6359       else if (require_constant && !maybe_const)
6360         pedwarn_init (init_loc, 0,
6361                       "initializer element is not a constant expression");
6362
6363       return inside_init;
6364     }
6365
6366   /* Come here only for records and arrays.  */
6367
6368   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6369     {
6370       error_init ("variable-sized object may not be initialized");
6371       return error_mark_node;
6372     }
6373
6374   error_init ("invalid initializer");
6375   return error_mark_node;
6376 }
6377 \f
6378 /* Handle initializers that use braces.  */
6379
6380 /* Type of object we are accumulating a constructor for.
6381    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
6382 static tree constructor_type;
6383
6384 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
6385    left to fill.  */
6386 static tree constructor_fields;
6387
6388 /* For an ARRAY_TYPE, this is the specified index
6389    at which to store the next element we get.  */
6390 static tree constructor_index;
6391
6392 /* For an ARRAY_TYPE, this is the maximum index.  */
6393 static tree constructor_max_index;
6394
6395 /* For a RECORD_TYPE, this is the first field not yet written out.  */
6396 static tree constructor_unfilled_fields;
6397
6398 /* For an ARRAY_TYPE, this is the index of the first element
6399    not yet written out.  */
6400 static tree constructor_unfilled_index;
6401
6402 /* In a RECORD_TYPE, the byte index of the next consecutive field.
6403    This is so we can generate gaps between fields, when appropriate.  */
6404 static tree constructor_bit_index;
6405
6406 /* If we are saving up the elements rather than allocating them,
6407    this is the list of elements so far (in reverse order,
6408    most recent first).  */
6409 static VEC(constructor_elt,gc) *constructor_elements;
6410
6411 /* 1 if constructor should be incrementally stored into a constructor chain,
6412    0 if all the elements should be kept in AVL tree.  */
6413 static int constructor_incremental;
6414
6415 /* 1 if so far this constructor's elements are all compile-time constants.  */
6416 static int constructor_constant;
6417
6418 /* 1 if so far this constructor's elements are all valid address constants.  */
6419 static int constructor_simple;
6420
6421 /* 1 if this constructor has an element that cannot be part of a
6422    constant expression.  */
6423 static int constructor_nonconst;
6424
6425 /* 1 if this constructor is erroneous so far.  */
6426 static int constructor_erroneous;
6427
6428 /* Structure for managing pending initializer elements, organized as an
6429    AVL tree.  */
6430
6431 struct init_node
6432 {
6433   struct init_node *left, *right;
6434   struct init_node *parent;
6435   int balance;
6436   tree purpose;
6437   tree value;
6438   tree origtype;
6439 };
6440
6441 /* Tree of pending elements at this constructor level.
6442    These are elements encountered out of order
6443    which belong at places we haven't reached yet in actually
6444    writing the output.
6445    Will never hold tree nodes across GC runs.  */
6446 static struct init_node *constructor_pending_elts;
6447
6448 /* The SPELLING_DEPTH of this constructor.  */
6449 static int constructor_depth;
6450
6451 /* DECL node for which an initializer is being read.
6452    0 means we are reading a constructor expression
6453    such as (struct foo) {...}.  */
6454 static tree constructor_decl;
6455
6456 /* Nonzero if this is an initializer for a top-level decl.  */
6457 static int constructor_top_level;
6458
6459 /* Nonzero if there were any member designators in this initializer.  */
6460 static int constructor_designated;
6461
6462 /* Nesting depth of designator list.  */
6463 static int designator_depth;
6464
6465 /* Nonzero if there were diagnosed errors in this designator list.  */
6466 static int designator_erroneous;
6467
6468 \f
6469 /* This stack has a level for each implicit or explicit level of
6470    structuring in the initializer, including the outermost one.  It
6471    saves the values of most of the variables above.  */
6472
6473 struct constructor_range_stack;
6474
6475 struct constructor_stack
6476 {
6477   struct constructor_stack *next;
6478   tree type;
6479   tree fields;
6480   tree index;
6481   tree max_index;
6482   tree unfilled_index;
6483   tree unfilled_fields;
6484   tree bit_index;
6485   VEC(constructor_elt,gc) *elements;
6486   struct init_node *pending_elts;
6487   int offset;
6488   int depth;
6489   /* If value nonzero, this value should replace the entire
6490      constructor at this level.  */
6491   struct c_expr replacement_value;
6492   struct constructor_range_stack *range_stack;
6493   char constant;
6494   char simple;
6495   char nonconst;
6496   char implicit;
6497   char erroneous;
6498   char outer;
6499   char incremental;
6500   char designated;
6501 };
6502
6503 static struct constructor_stack *constructor_stack;
6504
6505 /* This stack represents designators from some range designator up to
6506    the last designator in the list.  */
6507
6508 struct constructor_range_stack
6509 {
6510   struct constructor_range_stack *next, *prev;
6511   struct constructor_stack *stack;
6512   tree range_start;
6513   tree index;
6514   tree range_end;
6515   tree fields;
6516 };
6517
6518 static struct constructor_range_stack *constructor_range_stack;
6519
6520 /* This stack records separate initializers that are nested.
6521    Nested initializers can't happen in ANSI C, but GNU C allows them
6522    in cases like { ... (struct foo) { ... } ... }.  */
6523
6524 struct initializer_stack
6525 {
6526   struct initializer_stack *next;
6527   tree decl;
6528   struct constructor_stack *constructor_stack;
6529   struct constructor_range_stack *constructor_range_stack;
6530   VEC(constructor_elt,gc) *elements;
6531   struct spelling *spelling;
6532   struct spelling *spelling_base;
6533   int spelling_size;
6534   char top_level;
6535   char require_constant_value;
6536   char require_constant_elements;
6537 };
6538
6539 static struct initializer_stack *initializer_stack;
6540 \f
6541 /* Prepare to parse and output the initializer for variable DECL.  */
6542
6543 void
6544 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
6545 {
6546   const char *locus;
6547   struct initializer_stack *p = XNEW (struct initializer_stack);
6548
6549   p->decl = constructor_decl;
6550   p->require_constant_value = require_constant_value;
6551   p->require_constant_elements = require_constant_elements;
6552   p->constructor_stack = constructor_stack;
6553   p->constructor_range_stack = constructor_range_stack;
6554   p->elements = constructor_elements;
6555   p->spelling = spelling;
6556   p->spelling_base = spelling_base;
6557   p->spelling_size = spelling_size;
6558   p->top_level = constructor_top_level;
6559   p->next = initializer_stack;
6560   initializer_stack = p;
6561
6562   constructor_decl = decl;
6563   constructor_designated = 0;
6564   constructor_top_level = top_level;
6565
6566   if (decl != 0 && decl != error_mark_node)
6567     {
6568       require_constant_value = TREE_STATIC (decl);
6569       require_constant_elements
6570         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
6571            /* For a scalar, you can always use any value to initialize,
6572               even within braces.  */
6573            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
6574                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
6575                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
6576                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
6577       locus = identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (decl)));
6578     }
6579   else
6580     {
6581       require_constant_value = 0;
6582       require_constant_elements = 0;
6583       locus = _("(anonymous)");
6584     }
6585
6586   constructor_stack = 0;
6587   constructor_range_stack = 0;
6588
6589   missing_braces_mentioned = 0;
6590
6591   spelling_base = 0;
6592   spelling_size = 0;
6593   RESTORE_SPELLING_DEPTH (0);
6594
6595   if (locus)
6596     push_string (locus);
6597 }
6598
6599 void
6600 finish_init (void)
6601 {
6602   struct initializer_stack *p = initializer_stack;
6603
6604   /* Free the whole constructor stack of this initializer.  */
6605   while (constructor_stack)
6606     {
6607       struct constructor_stack *q = constructor_stack;
6608       constructor_stack = q->next;
6609       free (q);
6610     }
6611
6612   gcc_assert (!constructor_range_stack);
6613
6614   /* Pop back to the data of the outer initializer (if any).  */
6615   free (spelling_base);
6616
6617   constructor_decl = p->decl;
6618   require_constant_value = p->require_constant_value;
6619   require_constant_elements = p->require_constant_elements;
6620   constructor_stack = p->constructor_stack;
6621   constructor_range_stack = p->constructor_range_stack;
6622   constructor_elements = p->elements;
6623   spelling = p->spelling;
6624   spelling_base = p->spelling_base;
6625   spelling_size = p->spelling_size;
6626   constructor_top_level = p->top_level;
6627   initializer_stack = p->next;
6628   free (p);
6629 }
6630 \f
6631 /* Call here when we see the initializer is surrounded by braces.
6632    This is instead of a call to push_init_level;
6633    it is matched by a call to pop_init_level.
6634
6635    TYPE is the type to initialize, for a constructor expression.
6636    For an initializer for a decl, TYPE is zero.  */
6637
6638 void
6639 really_start_incremental_init (tree type)
6640 {
6641   struct constructor_stack *p = XNEW (struct constructor_stack);
6642
6643   if (type == 0)
6644     type = TREE_TYPE (constructor_decl);
6645
6646   if (TREE_CODE (type) == VECTOR_TYPE
6647       && TYPE_VECTOR_OPAQUE (type))
6648     error ("opaque vector types cannot be initialized");
6649
6650   p->type = constructor_type;
6651   p->fields = constructor_fields;
6652   p->index = constructor_index;
6653   p->max_index = constructor_max_index;
6654   p->unfilled_index = constructor_unfilled_index;
6655   p->unfilled_fields = constructor_unfilled_fields;
6656   p->bit_index = constructor_bit_index;
6657   p->elements = constructor_elements;
6658   p->constant = constructor_constant;
6659   p->simple = constructor_simple;
6660   p->nonconst = constructor_nonconst;
6661   p->erroneous = constructor_erroneous;
6662   p->pending_elts = constructor_pending_elts;
6663   p->depth = constructor_depth;
6664   p->replacement_value.value = 0;
6665   p->replacement_value.original_code = ERROR_MARK;
6666   p->replacement_value.original_type = NULL;
6667   p->implicit = 0;
6668   p->range_stack = 0;
6669   p->outer = 0;
6670   p->incremental = constructor_incremental;
6671   p->designated = constructor_designated;
6672   p->next = 0;
6673   constructor_stack = p;
6674
6675   constructor_constant = 1;
6676   constructor_simple = 1;
6677   constructor_nonconst = 0;
6678   constructor_depth = SPELLING_DEPTH ();
6679   constructor_elements = 0;
6680   constructor_pending_elts = 0;
6681   constructor_type = type;
6682   constructor_incremental = 1;
6683   constructor_designated = 0;
6684   designator_depth = 0;
6685   designator_erroneous = 0;
6686
6687   if (TREE_CODE (constructor_type) == RECORD_TYPE
6688       || TREE_CODE (constructor_type) == UNION_TYPE)
6689     {
6690       constructor_fields = TYPE_FIELDS (constructor_type);
6691       /* Skip any nameless bit fields at the beginning.  */
6692       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6693              && DECL_NAME (constructor_fields) == 0)
6694         constructor_fields = DECL_CHAIN (constructor_fields);
6695
6696       constructor_unfilled_fields = constructor_fields;
6697       constructor_bit_index = bitsize_zero_node;
6698     }
6699   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6700     {
6701       if (TYPE_DOMAIN (constructor_type))
6702         {
6703           constructor_max_index
6704             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6705
6706           /* Detect non-empty initializations of zero-length arrays.  */
6707           if (constructor_max_index == NULL_TREE
6708               && TYPE_SIZE (constructor_type))
6709             constructor_max_index = integer_minus_one_node;
6710
6711           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
6712              to initialize VLAs will cause a proper error; avoid tree
6713              checking errors as well by setting a safe value.  */
6714           if (constructor_max_index
6715               && TREE_CODE (constructor_max_index) != INTEGER_CST)
6716             constructor_max_index = integer_minus_one_node;
6717
6718           constructor_index
6719             = convert (bitsizetype,
6720                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6721         }
6722       else
6723         {
6724           constructor_index = bitsize_zero_node;
6725           constructor_max_index = NULL_TREE;
6726         }
6727
6728       constructor_unfilled_index = constructor_index;
6729     }
6730   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6731     {
6732       /* Vectors are like simple fixed-size arrays.  */
6733       constructor_max_index =
6734         bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6735       constructor_index = bitsize_zero_node;
6736       constructor_unfilled_index = constructor_index;
6737     }
6738   else
6739     {
6740       /* Handle the case of int x = {5}; */
6741       constructor_fields = constructor_type;
6742       constructor_unfilled_fields = constructor_type;
6743     }
6744 }
6745 \f
6746 /* Push down into a subobject, for initialization.
6747    If this is for an explicit set of braces, IMPLICIT is 0.
6748    If it is because the next element belongs at a lower level,
6749    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
6750
6751 void
6752 push_init_level (int implicit, struct obstack * braced_init_obstack)
6753 {
6754   struct constructor_stack *p;
6755   tree value = NULL_TREE;
6756
6757   /* If we've exhausted any levels that didn't have braces,
6758      pop them now.  If implicit == 1, this will have been done in
6759      process_init_element; do not repeat it here because in the case
6760      of excess initializers for an empty aggregate this leads to an
6761      infinite cycle of popping a level and immediately recreating
6762      it.  */
6763   if (implicit != 1)
6764     {
6765       while (constructor_stack->implicit)
6766         {
6767           if ((TREE_CODE (constructor_type) == RECORD_TYPE
6768                || TREE_CODE (constructor_type) == UNION_TYPE)
6769               && constructor_fields == 0)
6770             process_init_element (pop_init_level (1, braced_init_obstack),
6771                                   true, braced_init_obstack);
6772           else if (TREE_CODE (constructor_type) == ARRAY_TYPE
6773                    && constructor_max_index
6774                    && tree_int_cst_lt (constructor_max_index,
6775                                        constructor_index))
6776             process_init_element (pop_init_level (1, braced_init_obstack),
6777                                   true, braced_init_obstack);
6778           else
6779             break;
6780         }
6781     }
6782
6783   /* Unless this is an explicit brace, we need to preserve previous
6784      content if any.  */
6785   if (implicit)
6786     {
6787       if ((TREE_CODE (constructor_type) == RECORD_TYPE
6788            || TREE_CODE (constructor_type) == UNION_TYPE)
6789           && constructor_fields)
6790         value = find_init_member (constructor_fields, braced_init_obstack);
6791       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6792         value = find_init_member (constructor_index, braced_init_obstack);
6793     }
6794
6795   p = XNEW (struct constructor_stack);
6796   p->type = constructor_type;
6797   p->fields = constructor_fields;
6798   p->index = constructor_index;
6799   p->max_index = constructor_max_index;
6800   p->unfilled_index = constructor_unfilled_index;
6801   p->unfilled_fields = constructor_unfilled_fields;
6802   p->bit_index = constructor_bit_index;
6803   p->elements = constructor_elements;
6804   p->constant = constructor_constant;
6805   p->simple = constructor_simple;
6806   p->nonconst = constructor_nonconst;
6807   p->erroneous = constructor_erroneous;
6808   p->pending_elts = constructor_pending_elts;
6809   p->depth = constructor_depth;
6810   p->replacement_value.value = 0;
6811   p->replacement_value.original_code = ERROR_MARK;
6812   p->replacement_value.original_type = NULL;
6813   p->implicit = implicit;
6814   p->outer = 0;
6815   p->incremental = constructor_incremental;
6816   p->designated = constructor_designated;
6817   p->next = constructor_stack;
6818   p->range_stack = 0;
6819   constructor_stack = p;
6820
6821   constructor_constant = 1;
6822   constructor_simple = 1;
6823   constructor_nonconst = 0;
6824   constructor_depth = SPELLING_DEPTH ();
6825   constructor_elements = 0;
6826   constructor_incremental = 1;
6827   constructor_designated = 0;
6828   constructor_pending_elts = 0;
6829   if (!implicit)
6830     {
6831       p->range_stack = constructor_range_stack;
6832       constructor_range_stack = 0;
6833       designator_depth = 0;
6834       designator_erroneous = 0;
6835     }
6836
6837   /* Don't die if an entire brace-pair level is superfluous
6838      in the containing level.  */
6839   if (constructor_type == 0)
6840     ;
6841   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6842            || TREE_CODE (constructor_type) == UNION_TYPE)
6843     {
6844       /* Don't die if there are extra init elts at the end.  */
6845       if (constructor_fields == 0)
6846         constructor_type = 0;
6847       else
6848         {
6849           constructor_type = TREE_TYPE (constructor_fields);
6850           push_member_name (constructor_fields);
6851           constructor_depth++;
6852         }
6853     }
6854   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6855     {
6856       constructor_type = TREE_TYPE (constructor_type);
6857       push_array_bounds (tree_low_cst (constructor_index, 1));
6858       constructor_depth++;
6859     }
6860
6861   if (constructor_type == 0)
6862     {
6863       error_init ("extra brace group at end of initializer");
6864       constructor_fields = 0;
6865       constructor_unfilled_fields = 0;
6866       return;
6867     }
6868
6869   if (value && TREE_CODE (value) == CONSTRUCTOR)
6870     {
6871       constructor_constant = TREE_CONSTANT (value);
6872       constructor_simple = TREE_STATIC (value);
6873       constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
6874       constructor_elements = CONSTRUCTOR_ELTS (value);
6875       if (!VEC_empty (constructor_elt, constructor_elements)
6876           && (TREE_CODE (constructor_type) == RECORD_TYPE
6877               || TREE_CODE (constructor_type) == ARRAY_TYPE))
6878         set_nonincremental_init (braced_init_obstack);
6879     }
6880
6881   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
6882     {
6883       missing_braces_mentioned = 1;
6884       warning_init (OPT_Wmissing_braces, "missing braces around initializer");
6885     }
6886
6887   if (TREE_CODE (constructor_type) == RECORD_TYPE
6888            || TREE_CODE (constructor_type) == UNION_TYPE)
6889     {
6890       constructor_fields = TYPE_FIELDS (constructor_type);
6891       /* Skip any nameless bit fields at the beginning.  */
6892       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6893              && DECL_NAME (constructor_fields) == 0)
6894         constructor_fields = DECL_CHAIN (constructor_fields);
6895
6896       constructor_unfilled_fields = constructor_fields;
6897       constructor_bit_index = bitsize_zero_node;
6898     }
6899   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6900     {
6901       /* Vectors are like simple fixed-size arrays.  */
6902       constructor_max_index =
6903         bitsize_int (TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6904       constructor_index = bitsize_int (0);
6905       constructor_unfilled_index = constructor_index;
6906     }
6907   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6908     {
6909       if (TYPE_DOMAIN (constructor_type))
6910         {
6911           constructor_max_index
6912             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6913
6914           /* Detect non-empty initializations of zero-length arrays.  */
6915           if (constructor_max_index == NULL_TREE
6916               && TYPE_SIZE (constructor_type))
6917             constructor_max_index = integer_minus_one_node;
6918
6919           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
6920              to initialize VLAs will cause a proper error; avoid tree
6921              checking errors as well by setting a safe value.  */
6922           if (constructor_max_index
6923               && TREE_CODE (constructor_max_index) != INTEGER_CST)
6924             constructor_max_index = integer_minus_one_node;
6925
6926           constructor_index
6927             = convert (bitsizetype,
6928                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6929         }
6930       else
6931         constructor_index = bitsize_zero_node;
6932
6933       constructor_unfilled_index = constructor_index;
6934       if (value && TREE_CODE (value) == STRING_CST)
6935         {
6936           /* We need to split the char/wchar array into individual
6937              characters, so that we don't have to special case it
6938              everywhere.  */
6939           set_nonincremental_init_from_string (value, braced_init_obstack);
6940         }
6941     }
6942   else
6943     {
6944       if (constructor_type != error_mark_node)
6945         warning_init (0, "braces around scalar initializer");
6946       constructor_fields = constructor_type;
6947       constructor_unfilled_fields = constructor_type;
6948     }
6949 }
6950
6951 /* At the end of an implicit or explicit brace level,
6952    finish up that level of constructor.  If a single expression
6953    with redundant braces initialized that level, return the
6954    c_expr structure for that expression.  Otherwise, the original_code
6955    element is set to ERROR_MARK.
6956    If we were outputting the elements as they are read, return 0 as the value
6957    from inner levels (process_init_element ignores that),
6958    but return error_mark_node as the value from the outermost level
6959    (that's what we want to put in DECL_INITIAL).
6960    Otherwise, return a CONSTRUCTOR expression as the value.  */
6961
6962 struct c_expr
6963 pop_init_level (int implicit, struct obstack * braced_init_obstack)
6964 {
6965   struct constructor_stack *p;
6966   struct c_expr ret;
6967   ret.value = 0;
6968   ret.original_code = ERROR_MARK;
6969   ret.original_type = NULL;
6970
6971   if (implicit == 0)
6972     {
6973       /* When we come to an explicit close brace,
6974          pop any inner levels that didn't have explicit braces.  */
6975       while (constructor_stack->implicit)
6976         {
6977           process_init_element (pop_init_level (1, braced_init_obstack),
6978                                 true, braced_init_obstack);
6979         }
6980       gcc_assert (!constructor_range_stack);
6981     }
6982
6983   /* Now output all pending elements.  */
6984   constructor_incremental = 1;
6985   output_pending_init_elements (1, braced_init_obstack);
6986
6987   p = constructor_stack;
6988
6989   /* Error for initializing a flexible array member, or a zero-length
6990      array member in an inappropriate context.  */
6991   if (constructor_type && constructor_fields
6992       && TREE_CODE (constructor_type) == ARRAY_TYPE
6993       && TYPE_DOMAIN (constructor_type)
6994       && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
6995     {
6996       /* Silently discard empty initializations.  The parser will
6997          already have pedwarned for empty brackets.  */
6998       if (integer_zerop (constructor_unfilled_index))
6999         constructor_type = NULL_TREE;
7000       else
7001         {
7002           gcc_assert (!TYPE_SIZE (constructor_type));
7003
7004           if (constructor_depth > 2)
7005             error_init ("initialization of flexible array member in a nested context");
7006           else
7007             pedwarn_init (input_location, OPT_pedantic,
7008                           "initialization of a flexible array member");
7009
7010           /* We have already issued an error message for the existence
7011              of a flexible array member not at the end of the structure.
7012              Discard the initializer so that we do not die later.  */
7013           if (DECL_CHAIN (constructor_fields) != NULL_TREE)
7014             constructor_type = NULL_TREE;
7015         }
7016     }
7017
7018   /* Warn when some struct elements are implicitly initialized to zero.  */
7019   if (warn_missing_field_initializers
7020       && constructor_type
7021       && TREE_CODE (constructor_type) == RECORD_TYPE
7022       && constructor_unfilled_fields)
7023     {
7024         bool constructor_zeroinit =
7025          (VEC_length (constructor_elt, constructor_elements) == 1
7026           && integer_zerop
7027               (VEC_index (constructor_elt, constructor_elements, 0)->value));
7028
7029         /* Do not warn for flexible array members or zero-length arrays.  */
7030         while (constructor_unfilled_fields
7031                && (!DECL_SIZE (constructor_unfilled_fields)
7032                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
7033           constructor_unfilled_fields = DECL_CHAIN (constructor_unfilled_fields);
7034
7035         if (constructor_unfilled_fields
7036             /* Do not warn if this level of the initializer uses member
7037                designators; it is likely to be deliberate.  */
7038             && !constructor_designated
7039             /* Do not warn about initializing with ` = {0}'.  */
7040             && !constructor_zeroinit)
7041           {
7042             push_member_name (constructor_unfilled_fields);
7043             warning_init (OPT_Wmissing_field_initializers,
7044                           "missing initializer");
7045             RESTORE_SPELLING_DEPTH (constructor_depth);
7046           }
7047     }
7048
7049   /* Pad out the end of the structure.  */
7050   if (p->replacement_value.value)
7051     /* If this closes a superfluous brace pair,
7052        just pass out the element between them.  */
7053     ret = p->replacement_value;
7054   else if (constructor_type == 0)
7055     ;
7056   else if (TREE_CODE (constructor_type) != RECORD_TYPE
7057            && TREE_CODE (constructor_type) != UNION_TYPE
7058            && TREE_CODE (constructor_type) != ARRAY_TYPE
7059            && TREE_CODE (constructor_type) != VECTOR_TYPE)
7060     {
7061       /* A nonincremental scalar initializer--just return
7062          the element, after verifying there is just one.  */
7063       if (VEC_empty (constructor_elt,constructor_elements))
7064         {
7065           if (!constructor_erroneous)
7066             error_init ("empty scalar initializer");
7067           ret.value = error_mark_node;
7068         }
7069       else if (VEC_length (constructor_elt,constructor_elements) != 1)
7070         {
7071           error_init ("extra elements in scalar initializer");
7072           ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
7073         }
7074       else
7075         ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
7076     }
7077   else
7078     {
7079       if (constructor_erroneous)
7080         ret.value = error_mark_node;
7081       else
7082         {
7083           ret.value = build_constructor (constructor_type,
7084                                          constructor_elements);
7085           if (constructor_constant)
7086             TREE_CONSTANT (ret.value) = 1;
7087           if (constructor_constant && constructor_simple)
7088             TREE_STATIC (ret.value) = 1;
7089           if (constructor_nonconst)
7090             CONSTRUCTOR_NON_CONST (ret.value) = 1;
7091         }
7092     }
7093
7094   if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
7095     {
7096       if (constructor_nonconst)
7097         ret.original_code = C_MAYBE_CONST_EXPR;
7098       else if (ret.original_code == C_MAYBE_CONST_EXPR)
7099         ret.original_code = ERROR_MARK;
7100     }
7101
7102   constructor_type = p->type;
7103   constructor_fields = p->fields;
7104   constructor_index = p->index;
7105   constructor_max_index = p->max_index;
7106   constructor_unfilled_index = p->unfilled_index;
7107   constructor_unfilled_fields = p->unfilled_fields;
7108   constructor_bit_index = p->bit_index;
7109   constructor_elements = p->elements;
7110   constructor_constant = p->constant;
7111   constructor_simple = p->simple;
7112   constructor_nonconst = p->nonconst;
7113   constructor_erroneous = p->erroneous;
7114   constructor_incremental = p->incremental;
7115   constructor_designated = p->designated;
7116   constructor_pending_elts = p->pending_elts;
7117   constructor_depth = p->depth;
7118   if (!p->implicit)
7119     constructor_range_stack = p->range_stack;
7120   RESTORE_SPELLING_DEPTH (constructor_depth);
7121
7122   constructor_stack = p->next;
7123   free (p);
7124
7125   if (ret.value == 0 && constructor_stack == 0)
7126     ret.value = error_mark_node;
7127   return ret;
7128 }
7129
7130 /* Common handling for both array range and field name designators.
7131    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
7132
7133 static int
7134 set_designator (int array, struct obstack * braced_init_obstack)
7135 {
7136   tree subtype;
7137   enum tree_code subcode;
7138
7139   /* Don't die if an entire brace-pair level is superfluous
7140      in the containing level.  */
7141   if (constructor_type == 0)
7142     return 1;
7143
7144   /* If there were errors in this designator list already, bail out
7145      silently.  */
7146   if (designator_erroneous)
7147     return 1;
7148
7149   if (!designator_depth)
7150     {
7151       gcc_assert (!constructor_range_stack);
7152
7153       /* Designator list starts at the level of closest explicit
7154          braces.  */
7155       while (constructor_stack->implicit)
7156         {
7157           process_init_element (pop_init_level (1, braced_init_obstack),
7158                                 true, braced_init_obstack);
7159         }
7160       constructor_designated = 1;
7161       return 0;
7162     }
7163
7164   switch (TREE_CODE (constructor_type))
7165     {
7166     case  RECORD_TYPE:
7167     case  UNION_TYPE:
7168       subtype = TREE_TYPE (constructor_fields);
7169       if (subtype != error_mark_node)
7170         subtype = TYPE_MAIN_VARIANT (subtype);
7171       break;
7172     case ARRAY_TYPE:
7173       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7174       break;
7175     default:
7176       gcc_unreachable ();
7177     }
7178
7179   subcode = TREE_CODE (subtype);
7180   if (array && subcode != ARRAY_TYPE)
7181     {
7182       error_init ("array index in non-array initializer");
7183       return 1;
7184     }
7185   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
7186     {
7187       error_init ("field name not in record or union initializer");
7188       return 1;
7189     }
7190
7191   constructor_designated = 1;
7192   push_init_level (2, braced_init_obstack);
7193   return 0;
7194 }
7195
7196 /* If there are range designators in designator list, push a new designator
7197    to constructor_range_stack.  RANGE_END is end of such stack range or
7198    NULL_TREE if there is no range designator at this level.  */
7199
7200 static void
7201 push_range_stack (tree range_end, struct obstack * braced_init_obstack)
7202 {
7203   struct constructor_range_stack *p;
7204
7205   p = (struct constructor_range_stack *)
7206     obstack_alloc (braced_init_obstack,
7207                    sizeof (struct constructor_range_stack));
7208   p->prev = constructor_range_stack;
7209   p->next = 0;
7210   p->fields = constructor_fields;
7211   p->range_start = constructor_index;
7212   p->index = constructor_index;
7213   p->stack = constructor_stack;
7214   p->range_end = range_end;
7215   if (constructor_range_stack)
7216     constructor_range_stack->next = p;
7217   constructor_range_stack = p;
7218 }
7219
7220 /* Within an array initializer, specify the next index to be initialized.
7221    FIRST is that index.  If LAST is nonzero, then initialize a range
7222    of indices, running from FIRST through LAST.  */
7223
7224 void
7225 set_init_index (tree first, tree last,
7226                 struct obstack * braced_init_obstack)
7227 {
7228   if (set_designator (1, braced_init_obstack))
7229     return;
7230
7231   designator_erroneous = 1;
7232
7233   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
7234       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
7235     {
7236       error_init ("array index in initializer not of integer type");
7237       return;
7238     }
7239
7240   if (TREE_CODE (first) != INTEGER_CST)
7241     {
7242       first = c_fully_fold (first, false, NULL);
7243       if (TREE_CODE (first) == INTEGER_CST)
7244         pedwarn_init (input_location, OPT_pedantic,
7245                       "array index in initializer is not "
7246                       "an integer constant expression");
7247     }
7248
7249   if (last && TREE_CODE (last) != INTEGER_CST)
7250     {
7251       last = c_fully_fold (last, false, NULL);
7252       if (TREE_CODE (last) == INTEGER_CST)
7253         pedwarn_init (input_location, OPT_pedantic,
7254                       "array index in initializer is not "
7255                       "an integer constant expression");
7256     }
7257
7258   if (TREE_CODE (first) != INTEGER_CST)
7259     error_init ("nonconstant array index in initializer");
7260   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
7261     error_init ("nonconstant array index in initializer");
7262   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
7263     error_init ("array index in non-array initializer");
7264   else if (tree_int_cst_sgn (first) == -1)
7265     error_init ("array index in initializer exceeds array bounds");
7266   else if (constructor_max_index
7267            && tree_int_cst_lt (constructor_max_index, first))
7268     error_init ("array index in initializer exceeds array bounds");
7269   else
7270     {
7271       constant_expression_warning (first);
7272       if (last)
7273         constant_expression_warning (last);
7274       constructor_index = convert (bitsizetype, first);
7275
7276       if (last)
7277         {
7278           if (tree_int_cst_equal (first, last))
7279             last = 0;
7280           else if (tree_int_cst_lt (last, first))
7281             {
7282               error_init ("empty index range in initializer");
7283               last = 0;
7284             }
7285           else
7286             {
7287               last = convert (bitsizetype, last);
7288               if (constructor_max_index != 0
7289                   && tree_int_cst_lt (constructor_max_index, last))
7290                 {
7291                   error_init ("array index range in initializer exceeds array bounds");
7292                   last = 0;
7293                 }
7294             }
7295         }
7296
7297       designator_depth++;
7298       designator_erroneous = 0;
7299       if (constructor_range_stack || last)
7300         push_range_stack (last, braced_init_obstack);
7301     }
7302 }
7303
7304 /* Within a struct initializer, specify the next field to be initialized.  */
7305
7306 void
7307 set_init_label (tree fieldname, struct obstack * braced_init_obstack)
7308 {
7309   tree field;
7310
7311   if (set_designator (0, braced_init_obstack))
7312     return;
7313
7314   designator_erroneous = 1;
7315
7316   if (TREE_CODE (constructor_type) != RECORD_TYPE
7317       && TREE_CODE (constructor_type) != UNION_TYPE)
7318     {
7319       error_init ("field name not in record or union initializer");
7320       return;
7321     }
7322
7323   field = lookup_field (constructor_type, fieldname);
7324
7325   if (field == 0)
7326     error ("unknown field %qE specified in initializer", fieldname);
7327   else
7328     do
7329       {
7330         constructor_fields = TREE_VALUE (field);
7331         designator_depth++;
7332         designator_erroneous = 0;
7333         if (constructor_range_stack)
7334           push_range_stack (NULL_TREE, braced_init_obstack);
7335         field = TREE_CHAIN (field);
7336         if (field)
7337           {
7338             if (set_designator (0, braced_init_obstack))
7339               return;
7340           }
7341       }
7342     while (field != NULL_TREE);
7343 }
7344 \f
7345 /* Add a new initializer to the tree of pending initializers.  PURPOSE
7346    identifies the initializer, either array index or field in a structure.
7347    VALUE is the value of that index or field.  If ORIGTYPE is not
7348    NULL_TREE, it is the original type of VALUE.
7349
7350    IMPLICIT is true if value comes from pop_init_level (1),
7351    the new initializer has been merged with the existing one
7352    and thus no warnings should be emitted about overriding an
7353    existing initializer.  */
7354
7355 static void
7356 add_pending_init (tree purpose, tree value, tree origtype, bool implicit,
7357                   struct obstack * braced_init_obstack)
7358 {
7359   struct init_node *p, **q, *r;
7360
7361   q = &constructor_pending_elts;
7362   p = 0;
7363
7364   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7365     {
7366       while (*q != 0)
7367         {
7368           p = *q;
7369           if (tree_int_cst_lt (purpose, p->purpose))
7370             q = &p->left;
7371           else if (tree_int_cst_lt (p->purpose, purpose))
7372             q = &p->right;
7373           else
7374             {
7375               if (!implicit)
7376                 {
7377                   if (TREE_SIDE_EFFECTS (p->value))
7378                     warning_init (0, "initialized field with side-effects overwritten");
7379                   else if (warn_override_init)
7380                     warning_init (OPT_Woverride_init, "initialized field overwritten");
7381                 }
7382               p->value = value;
7383               p->origtype = origtype;
7384               return;
7385             }
7386         }
7387     }
7388   else
7389     {
7390       tree bitpos;
7391
7392       bitpos = bit_position (purpose);
7393       while (*q != NULL)
7394         {
7395           p = *q;
7396           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
7397             q = &p->left;
7398           else if (p->purpose != purpose)
7399             q = &p->right;
7400           else
7401             {
7402               if (!implicit)
7403                 {
7404                   if (TREE_SIDE_EFFECTS (p->value))
7405                     warning_init (0, "initialized field with side-effects overwritten");
7406                   else if (warn_override_init)
7407                     warning_init (OPT_Woverride_init, "initialized field overwritten");
7408                 }
7409               p->value = value;
7410               p->origtype = origtype;
7411               return;
7412             }
7413         }
7414     }
7415
7416   r = (struct init_node *) obstack_alloc (braced_init_obstack,
7417                                           sizeof (struct init_node));
7418   r->purpose = purpose;
7419   r->value = value;
7420   r->origtype = origtype;
7421
7422   *q = r;
7423   r->parent = p;
7424   r->left = 0;
7425   r->right = 0;
7426   r->balance = 0;
7427
7428   while (p)
7429     {
7430       struct init_node *s;
7431
7432       if (r == p->left)
7433         {
7434           if (p->balance == 0)
7435             p->balance = -1;
7436           else if (p->balance < 0)
7437             {
7438               if (r->balance < 0)
7439                 {
7440                   /* L rotation.  */
7441                   p->left = r->right;
7442                   if (p->left)
7443                     p->left->parent = p;
7444                   r->right = p;
7445
7446                   p->balance = 0;
7447                   r->balance = 0;
7448
7449                   s = p->parent;
7450                   p->parent = r;
7451                   r->parent = s;
7452                   if (s)
7453                     {
7454                       if (s->left == p)
7455                         s->left = r;
7456                       else
7457                         s->right = r;
7458                     }
7459                   else
7460                     constructor_pending_elts = r;
7461                 }
7462               else
7463                 {
7464                   /* LR rotation.  */
7465                   struct init_node *t = r->right;
7466
7467                   r->right = t->left;
7468                   if (r->right)
7469                     r->right->parent = r;
7470                   t->left = r;
7471
7472                   p->left = t->right;
7473                   if (p->left)
7474                     p->left->parent = p;
7475                   t->right = p;
7476
7477                   p->balance = t->balance < 0;
7478                   r->balance = -(t->balance > 0);
7479                   t->balance = 0;
7480
7481                   s = p->parent;
7482                   p->parent = t;
7483                   r->parent = t;
7484                   t->parent = s;
7485                   if (s)
7486                     {
7487                       if (s->left == p)
7488                         s->left = t;
7489                       else
7490                         s->right = t;
7491                     }
7492                   else
7493                     constructor_pending_elts = t;
7494                 }
7495               break;
7496             }
7497           else
7498             {
7499               /* p->balance == +1; growth of left side balances the node.  */
7500               p->balance = 0;
7501               break;
7502             }
7503         }
7504       else /* r == p->right */
7505         {
7506           if (p->balance == 0)
7507             /* Growth propagation from right side.  */
7508             p->balance++;
7509           else if (p->balance > 0)
7510             {
7511               if (r->balance > 0)
7512                 {
7513                   /* R rotation.  */
7514                   p->right = r->left;
7515                   if (p->right)
7516                     p->right->parent = p;
7517                   r->left = p;
7518
7519                   p->balance = 0;
7520                   r->balance = 0;
7521
7522                   s = p->parent;
7523                   p->parent = r;
7524                   r->parent = s;
7525                   if (s)
7526                     {
7527                       if (s->left == p)
7528                         s->left = r;
7529                       else
7530                         s->right = r;
7531                     }
7532                   else
7533                     constructor_pending_elts = r;
7534                 }
7535               else /* r->balance == -1 */
7536                 {
7537                   /* RL rotation */
7538                   struct init_node *t = r->left;
7539
7540                   r->left = t->right;
7541                   if (r->left)
7542                     r->left->parent = r;
7543                   t->right = r;
7544
7545                   p->right = t->left;
7546                   if (p->right)
7547                     p->right->parent = p;
7548                   t->left = p;
7549
7550                   r->balance = (t->balance < 0);
7551                   p->balance = -(t->balance > 0);
7552                   t->balance = 0;
7553
7554                   s = p->parent;
7555                   p->parent = t;
7556                   r->parent = t;
7557                   t->parent = s;
7558                   if (s)
7559                     {
7560                       if (s->left == p)
7561                         s->left = t;
7562                       else
7563                         s->right = t;
7564                     }
7565                   else
7566                     constructor_pending_elts = t;
7567                 }
7568               break;
7569             }
7570           else
7571             {
7572               /* p->balance == -1; growth of right side balances the node.  */
7573               p->balance = 0;
7574               break;
7575             }
7576         }
7577
7578       r = p;
7579       p = p->parent;
7580     }
7581 }
7582
7583 /* Build AVL tree from a sorted chain.  */
7584
7585 static void
7586 set_nonincremental_init (struct obstack * braced_init_obstack)
7587 {
7588   unsigned HOST_WIDE_INT ix;
7589   tree index, value;
7590
7591   if (TREE_CODE (constructor_type) != RECORD_TYPE
7592       && TREE_CODE (constructor_type) != ARRAY_TYPE)
7593     return;
7594
7595   FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
7596     {
7597       add_pending_init (index, value, NULL_TREE, false,
7598                         braced_init_obstack);
7599     }
7600   constructor_elements = 0;
7601   if (TREE_CODE (constructor_type) == RECORD_TYPE)
7602     {
7603       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
7604       /* Skip any nameless bit fields at the beginning.  */
7605       while (constructor_unfilled_fields != 0
7606              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7607              && DECL_NAME (constructor_unfilled_fields) == 0)
7608         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
7609
7610     }
7611   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7612     {
7613       if (TYPE_DOMAIN (constructor_type))
7614         constructor_unfilled_index
7615             = convert (bitsizetype,
7616                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
7617       else
7618         constructor_unfilled_index = bitsize_zero_node;
7619     }
7620   constructor_incremental = 0;
7621 }
7622
7623 /* Build AVL tree from a string constant.  */
7624
7625 static void
7626 set_nonincremental_init_from_string (tree str,
7627                                      struct obstack * braced_init_obstack)
7628 {
7629   tree value, purpose, type;
7630   HOST_WIDE_INT val[2];
7631   const char *p, *end;
7632   int byte, wchar_bytes, charwidth, bitpos;
7633
7634   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
7635
7636   wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT;
7637   charwidth = TYPE_PRECISION (char_type_node);
7638   type = TREE_TYPE (constructor_type);
7639   p = TREE_STRING_POINTER (str);
7640   end = p + TREE_STRING_LENGTH (str);
7641
7642   for (purpose = bitsize_zero_node;
7643        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
7644        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
7645     {
7646       if (wchar_bytes == 1)
7647         {
7648           val[1] = (unsigned char) *p++;
7649           val[0] = 0;
7650         }
7651       else
7652         {
7653           val[0] = 0;
7654           val[1] = 0;
7655           for (byte = 0; byte < wchar_bytes; byte++)
7656             {
7657               if (BYTES_BIG_ENDIAN)
7658                 bitpos = (wchar_bytes - byte - 1) * charwidth;
7659               else
7660                 bitpos = byte * charwidth;
7661               val[bitpos < HOST_BITS_PER_WIDE_INT]
7662                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
7663                    << (bitpos % HOST_BITS_PER_WIDE_INT);
7664             }
7665         }
7666
7667       if (!TYPE_UNSIGNED (type))
7668         {
7669           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
7670           if (bitpos < HOST_BITS_PER_WIDE_INT)
7671             {
7672               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
7673                 {
7674                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
7675                   val[0] = -1;
7676                 }
7677             }
7678           else if (bitpos == HOST_BITS_PER_WIDE_INT)
7679             {
7680               if (val[1] < 0)
7681                 val[0] = -1;
7682             }
7683           else if (val[0] & (((HOST_WIDE_INT) 1)
7684                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
7685             val[0] |= ((HOST_WIDE_INT) -1)
7686                       << (bitpos - HOST_BITS_PER_WIDE_INT);
7687         }
7688
7689       value = build_int_cst_wide (type, val[1], val[0]);
7690       add_pending_init (purpose, value, NULL_TREE, false,
7691                         braced_init_obstack);
7692     }
7693
7694   constructor_incremental = 0;
7695 }
7696
7697 /* Return value of FIELD in pending initializer or zero if the field was
7698    not initialized yet.  */
7699
7700 static tree
7701 find_init_member (tree field, struct obstack * braced_init_obstack)
7702 {
7703   struct init_node *p;
7704
7705   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7706     {
7707       if (constructor_incremental
7708           && tree_int_cst_lt (field, constructor_unfilled_index))
7709         set_nonincremental_init (braced_init_obstack);
7710
7711       p = constructor_pending_elts;
7712       while (p)
7713         {
7714           if (tree_int_cst_lt (field, p->purpose))
7715             p = p->left;
7716           else if (tree_int_cst_lt (p->purpose, field))
7717             p = p->right;
7718           else
7719             return p->value;
7720         }
7721     }
7722   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7723     {
7724       tree bitpos = bit_position (field);
7725
7726       if (constructor_incremental
7727           && (!constructor_unfilled_fields
7728               || tree_int_cst_lt (bitpos,
7729                                   bit_position (constructor_unfilled_fields))))
7730         set_nonincremental_init (braced_init_obstack);
7731
7732       p = constructor_pending_elts;
7733       while (p)
7734         {
7735           if (field == p->purpose)
7736             return p->value;
7737           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
7738             p = p->left;
7739           else
7740             p = p->right;
7741         }
7742     }
7743   else if (TREE_CODE (constructor_type) == UNION_TYPE)
7744     {
7745       if (!VEC_empty (constructor_elt, constructor_elements)
7746           && (VEC_last (constructor_elt, constructor_elements)->index
7747               == field))
7748         return VEC_last (constructor_elt, constructor_elements)->value;
7749     }
7750   return 0;
7751 }
7752
7753 /* "Output" the next constructor element.
7754    At top level, really output it to assembler code now.
7755    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
7756    If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
7757    TYPE is the data type that the containing data type wants here.
7758    FIELD is the field (a FIELD_DECL) or the index that this element fills.
7759    If VALUE is a string constant, STRICT_STRING is true if it is
7760    unparenthesized or we should not warn here for it being parenthesized.
7761    For other types of VALUE, STRICT_STRING is not used.
7762
7763    PENDING if non-nil means output pending elements that belong
7764    right after this element.  (PENDING is normally 1;
7765    it is 0 while outputting pending elements, to avoid recursion.)
7766
7767    IMPLICIT is true if value comes from pop_init_level (1),
7768    the new initializer has been merged with the existing one
7769    and thus no warnings should be emitted about overriding an
7770    existing initializer.  */
7771
7772 static void
7773 output_init_element (tree value, tree origtype, bool strict_string, tree type,
7774                      tree field, int pending, bool implicit,
7775                      struct obstack * braced_init_obstack)
7776 {
7777   tree semantic_type = NULL_TREE;
7778   constructor_elt *celt;
7779   bool maybe_const = true;
7780   bool npc;
7781
7782   if (type == error_mark_node || value == error_mark_node)
7783     {
7784       constructor_erroneous = 1;
7785       return;
7786     }
7787   if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
7788       && (TREE_CODE (value) == STRING_CST
7789           || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
7790       && !(TREE_CODE (value) == STRING_CST
7791            && TREE_CODE (type) == ARRAY_TYPE
7792            && INTEGRAL_TYPE_P (TREE_TYPE (type)))
7793       && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
7794                      TYPE_MAIN_VARIANT (type)))
7795     value = array_to_pointer_conversion (input_location, value);
7796
7797   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
7798       && require_constant_value && !flag_isoc99 && pending)
7799     {
7800       /* As an extension, allow initializing objects with static storage
7801          duration with compound literals (which are then treated just as
7802          the brace enclosed list they contain).  */
7803       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
7804       value = DECL_INITIAL (decl);
7805     }
7806
7807   npc = null_pointer_constant_p (value);
7808   if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
7809     {
7810       semantic_type = TREE_TYPE (value);
7811       value = TREE_OPERAND (value, 0);
7812     }
7813   value = c_fully_fold (value, require_constant_value, &maybe_const);
7814
7815   if (value == error_mark_node)
7816     constructor_erroneous = 1;
7817   else if (!TREE_CONSTANT (value))
7818     constructor_constant = 0;
7819   else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
7820            || ((TREE_CODE (constructor_type) == RECORD_TYPE
7821                 || TREE_CODE (constructor_type) == UNION_TYPE)
7822                && DECL_C_BIT_FIELD (field)
7823                && TREE_CODE (value) != INTEGER_CST))
7824     constructor_simple = 0;
7825   if (!maybe_const)
7826     constructor_nonconst = 1;
7827
7828   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
7829     {
7830       if (require_constant_value)
7831         {
7832           error_init ("initializer element is not constant");
7833           value = error_mark_node;
7834         }
7835       else if (require_constant_elements)
7836         pedwarn (input_location, 0,
7837                  "initializer element is not computable at load time");
7838     }
7839   else if (!maybe_const
7840            && (require_constant_value || require_constant_elements))
7841     pedwarn_init (input_location, 0,
7842                   "initializer element is not a constant expression");
7843
7844   /* Issue -Wc++-compat warnings about initializing a bitfield with
7845      enum type.  */
7846   if (warn_cxx_compat
7847       && field != NULL_TREE
7848       && TREE_CODE (field) == FIELD_DECL
7849       && DECL_BIT_FIELD_TYPE (field) != NULL_TREE
7850       && (TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))
7851           != TYPE_MAIN_VARIANT (type))
7852       && TREE_CODE (DECL_BIT_FIELD_TYPE (field)) == ENUMERAL_TYPE)
7853     {
7854       tree checktype = origtype != NULL_TREE ? origtype : TREE_TYPE (value);
7855       if (checktype != error_mark_node
7856           && (TYPE_MAIN_VARIANT (checktype)
7857               != TYPE_MAIN_VARIANT (DECL_BIT_FIELD_TYPE (field))))
7858         warning_init (OPT_Wc___compat,
7859                       "enum conversion in initialization is invalid in C++");
7860     }
7861
7862   /* If this field is empty (and not at the end of structure),
7863      don't do anything other than checking the initializer.  */
7864   if (field
7865       && (TREE_TYPE (field) == error_mark_node
7866           || (COMPLETE_TYPE_P (TREE_TYPE (field))
7867               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
7868               && (TREE_CODE (constructor_type) == ARRAY_TYPE
7869                   || DECL_CHAIN (field)))))
7870     return;
7871
7872   if (semantic_type)
7873     value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
7874   value = digest_init (input_location, type, value, origtype, npc,
7875                        strict_string, require_constant_value);
7876   if (value == error_mark_node)
7877     {
7878       constructor_erroneous = 1;
7879       return;
7880     }
7881   if (require_constant_value || require_constant_elements)
7882     constant_expression_warning (value);
7883
7884   /* If this element doesn't come next in sequence,
7885      put it on constructor_pending_elts.  */
7886   if (TREE_CODE (constructor_type) == ARRAY_TYPE
7887       && (!constructor_incremental
7888           || !tree_int_cst_equal (field, constructor_unfilled_index)))
7889     {
7890       if (constructor_incremental
7891           && tree_int_cst_lt (field, constructor_unfilled_index))
7892         set_nonincremental_init (braced_init_obstack);
7893
7894       add_pending_init (field, value, origtype, implicit,
7895                         braced_init_obstack);
7896       return;
7897     }
7898   else if (TREE_CODE (constructor_type) == RECORD_TYPE
7899            && (!constructor_incremental
7900                || field != constructor_unfilled_fields))
7901     {
7902       /* We do this for records but not for unions.  In a union,
7903          no matter which field is specified, it can be initialized
7904          right away since it starts at the beginning of the union.  */
7905       if (constructor_incremental)
7906         {
7907           if (!constructor_unfilled_fields)
7908             set_nonincremental_init (braced_init_obstack);
7909           else
7910             {
7911               tree bitpos, unfillpos;
7912
7913               bitpos = bit_position (field);
7914               unfillpos = bit_position (constructor_unfilled_fields);
7915
7916               if (tree_int_cst_lt (bitpos, unfillpos))
7917                 set_nonincremental_init (braced_init_obstack);
7918             }
7919         }
7920
7921       add_pending_init (field, value, origtype, implicit,
7922                         braced_init_obstack);
7923       return;
7924     }
7925   else if (TREE_CODE (constructor_type) == UNION_TYPE
7926            && !VEC_empty (constructor_elt, constructor_elements))
7927     {
7928       if (!implicit)
7929         {
7930           if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
7931                                            constructor_elements)->value))
7932             warning_init (0,
7933                           "initialized field with side-effects overwritten");
7934           else if (warn_override_init)
7935             warning_init (OPT_Woverride_init, "initialized field overwritten");
7936         }
7937
7938       /* We can have just one union field set.  */
7939       constructor_elements = 0;
7940     }
7941
7942   /* Otherwise, output this element either to
7943      constructor_elements or to the assembler file.  */
7944
7945   celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
7946   celt->index = field;
7947   celt->value = value;
7948
7949   /* Advance the variable that indicates sequential elements output.  */
7950   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7951     constructor_unfilled_index
7952       = size_binop_loc (input_location, PLUS_EXPR, constructor_unfilled_index,
7953                         bitsize_one_node);
7954   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7955     {
7956       constructor_unfilled_fields
7957         = DECL_CHAIN (constructor_unfilled_fields);
7958
7959       /* Skip any nameless bit fields.  */
7960       while (constructor_unfilled_fields != 0
7961              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7962              && DECL_NAME (constructor_unfilled_fields) == 0)
7963         constructor_unfilled_fields =
7964           DECL_CHAIN (constructor_unfilled_fields);
7965     }
7966   else if (TREE_CODE (constructor_type) == UNION_TYPE)
7967     constructor_unfilled_fields = 0;
7968
7969   /* Now output any pending elements which have become next.  */
7970   if (pending)
7971     output_pending_init_elements (0, braced_init_obstack);
7972 }
7973
7974 /* Output any pending elements which have become next.
7975    As we output elements, constructor_unfilled_{fields,index}
7976    advances, which may cause other elements to become next;
7977    if so, they too are output.
7978
7979    If ALL is 0, we return when there are
7980    no more pending elements to output now.
7981
7982    If ALL is 1, we output space as necessary so that
7983    we can output all the pending elements.  */
7984 static void
7985 output_pending_init_elements (int all, struct obstack * braced_init_obstack)
7986 {
7987   struct init_node *elt = constructor_pending_elts;
7988   tree next;
7989
7990  retry:
7991
7992   /* Look through the whole pending tree.
7993      If we find an element that should be output now,
7994      output it.  Otherwise, set NEXT to the element
7995      that comes first among those still pending.  */
7996
7997   next = 0;
7998   while (elt)
7999     {
8000       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8001         {
8002           if (tree_int_cst_equal (elt->purpose,
8003                                   constructor_unfilled_index))
8004             output_init_element (elt->value, elt->origtype, true,
8005                                  TREE_TYPE (constructor_type),
8006                                  constructor_unfilled_index, 0, false,
8007                                  braced_init_obstack);
8008           else if (tree_int_cst_lt (constructor_unfilled_index,
8009                                     elt->purpose))
8010             {
8011               /* Advance to the next smaller node.  */
8012               if (elt->left)
8013                 elt = elt->left;
8014               else
8015                 {
8016                   /* We have reached the smallest node bigger than the
8017                      current unfilled index.  Fill the space first.  */
8018                   next = elt->purpose;
8019                   break;
8020                 }
8021             }
8022           else
8023             {
8024               /* Advance to the next bigger node.  */
8025               if (elt->right)
8026                 elt = elt->right;
8027               else
8028                 {
8029                   /* We have reached the biggest node in a subtree.  Find
8030                      the parent of it, which is the next bigger node.  */
8031                   while (elt->parent && elt->parent->right == elt)
8032                     elt = elt->parent;
8033                   elt = elt->parent;
8034                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
8035                                               elt->purpose))
8036                     {
8037                       next = elt->purpose;
8038                       break;
8039                     }
8040                 }
8041             }
8042         }
8043       else if (TREE_CODE (constructor_type) == RECORD_TYPE
8044                || TREE_CODE (constructor_type) == UNION_TYPE)
8045         {
8046           tree ctor_unfilled_bitpos, elt_bitpos;
8047
8048           /* If the current record is complete we are done.  */
8049           if (constructor_unfilled_fields == 0)
8050             break;
8051
8052           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
8053           elt_bitpos = bit_position (elt->purpose);
8054           /* We can't compare fields here because there might be empty
8055              fields in between.  */
8056           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
8057             {
8058               constructor_unfilled_fields = elt->purpose;
8059               output_init_element (elt->value, elt->origtype, true,
8060                                    TREE_TYPE (elt->purpose),
8061                                    elt->purpose, 0, false,
8062                                    braced_init_obstack);
8063             }
8064           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
8065             {
8066               /* Advance to the next smaller node.  */
8067               if (elt->left)
8068                 elt = elt->left;
8069               else
8070                 {
8071                   /* We have reached the smallest node bigger than the
8072                      current unfilled field.  Fill the space first.  */
8073                   next = elt->purpose;
8074                   break;
8075                 }
8076             }
8077           else
8078             {
8079               /* Advance to the next bigger node.  */
8080               if (elt->right)
8081                 elt = elt->right;
8082               else
8083                 {
8084                   /* We have reached the biggest node in a subtree.  Find
8085                      the parent of it, which is the next bigger node.  */
8086                   while (elt->parent && elt->parent->right == elt)
8087                     elt = elt->parent;
8088                   elt = elt->parent;
8089                   if (elt
8090                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
8091                                            bit_position (elt->purpose))))
8092                     {
8093                       next = elt->purpose;
8094                       break;
8095                     }
8096                 }
8097             }
8098         }
8099     }
8100
8101   /* Ordinarily return, but not if we want to output all
8102      and there are elements left.  */
8103   if (!(all && next != 0))
8104     return;
8105
8106   /* If it's not incremental, just skip over the gap, so that after
8107      jumping to retry we will output the next successive element.  */
8108   if (TREE_CODE (constructor_type) == RECORD_TYPE
8109       || TREE_CODE (constructor_type) == UNION_TYPE)
8110     constructor_unfilled_fields = next;
8111   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8112     constructor_unfilled_index = next;
8113
8114   /* ELT now points to the node in the pending tree with the next
8115      initializer to output.  */
8116   goto retry;
8117 }
8118 \f
8119 /* Add one non-braced element to the current constructor level.
8120    This adjusts the current position within the constructor's type.
8121    This may also start or terminate implicit levels
8122    to handle a partly-braced initializer.
8123
8124    Once this has found the correct level for the new element,
8125    it calls output_init_element.
8126
8127    IMPLICIT is true if value comes from pop_init_level (1),
8128    the new initializer has been merged with the existing one
8129    and thus no warnings should be emitted about overriding an
8130    existing initializer.  */
8131
8132 void
8133 process_init_element (struct c_expr value, bool implicit,
8134                       struct obstack * braced_init_obstack)
8135 {
8136   tree orig_value = value.value;
8137   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
8138   bool strict_string = value.original_code == STRING_CST;
8139
8140   designator_depth = 0;
8141   designator_erroneous = 0;
8142
8143   /* Handle superfluous braces around string cst as in
8144      char x[] = {"foo"}; */
8145   if (string_flag
8146       && constructor_type
8147       && TREE_CODE (constructor_type) == ARRAY_TYPE
8148       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
8149       && integer_zerop (constructor_unfilled_index))
8150     {
8151       if (constructor_stack->replacement_value.value)
8152         error_init ("excess elements in char array initializer");
8153       constructor_stack->replacement_value = value;
8154       return;
8155     }
8156
8157   if (constructor_stack->replacement_value.value != 0)
8158     {
8159       error_init ("excess elements in struct initializer");
8160       return;
8161     }
8162
8163   /* Ignore elements of a brace group if it is entirely superfluous
8164      and has already been diagnosed.  */
8165   if (constructor_type == 0)
8166     return;
8167
8168   /* If we've exhausted any levels that didn't have braces,
8169      pop them now.  */
8170   while (constructor_stack->implicit)
8171     {
8172       if ((TREE_CODE (constructor_type) == RECORD_TYPE
8173            || TREE_CODE (constructor_type) == UNION_TYPE)
8174           && constructor_fields == 0)
8175         process_init_element (pop_init_level (1, braced_init_obstack),
8176                               true, braced_init_obstack);
8177       else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
8178                 || TREE_CODE (constructor_type) == VECTOR_TYPE)
8179                && (constructor_max_index == 0
8180                    || tree_int_cst_lt (constructor_max_index,
8181                                        constructor_index)))
8182         process_init_element (pop_init_level (1, braced_init_obstack),
8183                               true, braced_init_obstack);
8184       else
8185         break;
8186     }
8187
8188   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
8189   if (constructor_range_stack)
8190     {
8191       /* If value is a compound literal and we'll be just using its
8192          content, don't put it into a SAVE_EXPR.  */
8193       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
8194           || !require_constant_value
8195           || flag_isoc99)
8196         {
8197           tree semantic_type = NULL_TREE;
8198           if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
8199             {
8200               semantic_type = TREE_TYPE (value.value);
8201               value.value = TREE_OPERAND (value.value, 0);
8202             }
8203           value.value = c_save_expr (value.value);
8204           if (semantic_type)
8205             value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
8206                                   value.value);
8207         }
8208     }
8209
8210   while (1)
8211     {
8212       if (TREE_CODE (constructor_type) == RECORD_TYPE)
8213         {
8214           tree fieldtype;
8215           enum tree_code fieldcode;
8216
8217           if (constructor_fields == 0)
8218             {
8219               pedwarn_init (input_location, 0,
8220                             "excess elements in struct initializer");
8221               break;
8222             }
8223
8224           fieldtype = TREE_TYPE (constructor_fields);
8225           if (fieldtype != error_mark_node)
8226             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
8227           fieldcode = TREE_CODE (fieldtype);
8228
8229           /* Error for non-static initialization of a flexible array member.  */
8230           if (fieldcode == ARRAY_TYPE
8231               && !require_constant_value
8232               && TYPE_SIZE (fieldtype) == NULL_TREE
8233               && DECL_CHAIN (constructor_fields) == NULL_TREE)
8234             {
8235               error_init ("non-static initialization of a flexible array member");
8236               break;
8237             }
8238
8239           /* Accept a string constant to initialize a subarray.  */
8240           if (value.value != 0
8241               && fieldcode == ARRAY_TYPE
8242               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
8243               && string_flag)
8244             value.value = orig_value;
8245           /* Otherwise, if we have come to a subaggregate,
8246              and we don't have an element of its type, push into it.  */
8247           else if (value.value != 0
8248                    && value.value != error_mark_node
8249                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
8250                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
8251                        || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
8252             {
8253               push_init_level (1, braced_init_obstack);
8254               continue;
8255             }
8256
8257           if (value.value)
8258             {
8259               push_member_name (constructor_fields);
8260               output_init_element (value.value, value.original_type,
8261                                    strict_string, fieldtype,
8262                                    constructor_fields, 1, implicit,
8263                                    braced_init_obstack);
8264               RESTORE_SPELLING_DEPTH (constructor_depth);
8265             }
8266           else
8267             /* Do the bookkeeping for an element that was
8268                directly output as a constructor.  */
8269             {
8270               /* For a record, keep track of end position of last field.  */
8271               if (DECL_SIZE (constructor_fields))
8272                 constructor_bit_index
8273                   = size_binop_loc (input_location, PLUS_EXPR,
8274                                     bit_position (constructor_fields),
8275                                     DECL_SIZE (constructor_fields));
8276
8277               /* If the current field was the first one not yet written out,
8278                  it isn't now, so update.  */
8279               if (constructor_unfilled_fields == constructor_fields)
8280                 {
8281                   constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
8282                   /* Skip any nameless bit fields.  */
8283                   while (constructor_unfilled_fields != 0
8284                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
8285                          && DECL_NAME (constructor_unfilled_fields) == 0)
8286                     constructor_unfilled_fields =
8287                       DECL_CHAIN (constructor_unfilled_fields);
8288                 }
8289             }
8290
8291           constructor_fields = DECL_CHAIN (constructor_fields);
8292           /* Skip any nameless bit fields at the beginning.  */
8293           while (constructor_fields != 0
8294                  && DECL_C_BIT_FIELD (constructor_fields)
8295                  && DECL_NAME (constructor_fields) == 0)
8296             constructor_fields = DECL_CHAIN (constructor_fields);
8297         }
8298       else if (TREE_CODE (constructor_type) == UNION_TYPE)
8299         {
8300           tree fieldtype;
8301           enum tree_code fieldcode;
8302
8303           if (constructor_fields == 0)
8304             {
8305               pedwarn_init (input_location, 0,
8306                             "excess elements in union initializer");
8307               break;
8308             }
8309
8310           fieldtype = TREE_TYPE (constructor_fields);
8311           if (fieldtype != error_mark_node)
8312             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
8313           fieldcode = TREE_CODE (fieldtype);
8314
8315           /* Warn that traditional C rejects initialization of unions.
8316              We skip the warning if the value is zero.  This is done
8317              under the assumption that the zero initializer in user
8318              code appears conditioned on e.g. __STDC__ to avoid
8319              "missing initializer" warnings and relies on default
8320              initialization to zero in the traditional C case.
8321              We also skip the warning if the initializer is designated,
8322              again on the assumption that this must be conditional on
8323              __STDC__ anyway (and we've already complained about the
8324              member-designator already).  */
8325           if (!in_system_header && !constructor_designated
8326               && !(value.value && (integer_zerop (value.value)
8327                                    || real_zerop (value.value))))
8328             warning (OPT_Wtraditional, "traditional C rejects initialization "
8329                      "of unions");
8330
8331           /* Accept a string constant to initialize a subarray.  */
8332           if (value.value != 0
8333               && fieldcode == ARRAY_TYPE
8334               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
8335               && string_flag)
8336             value.value = orig_value;
8337           /* Otherwise, if we have come to a subaggregate,
8338              and we don't have an element of its type, push into it.  */
8339           else if (value.value != 0
8340                    && value.value != error_mark_node
8341                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
8342                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
8343                        || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
8344             {
8345               push_init_level (1, braced_init_obstack);
8346               continue;
8347             }
8348
8349           if (value.value)
8350             {
8351               push_member_name (constructor_fields);
8352               output_init_element (value.value, value.original_type,
8353                                    strict_string, fieldtype,
8354                                    constructor_fields, 1, implicit,
8355                                    braced_init_obstack);
8356               RESTORE_SPELLING_DEPTH (constructor_depth);
8357             }
8358           else
8359             /* Do the bookkeeping for an element that was
8360                directly output as a constructor.  */
8361             {
8362               constructor_bit_index = DECL_SIZE (constructor_fields);
8363               constructor_unfilled_fields = DECL_CHAIN (constructor_fields);
8364             }
8365
8366           constructor_fields = 0;
8367         }
8368       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
8369         {
8370           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8371           enum tree_code eltcode = TREE_CODE (elttype);
8372
8373           /* Accept a string constant to initialize a subarray.  */
8374           if (value.value != 0
8375               && eltcode == ARRAY_TYPE
8376               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
8377               && string_flag)
8378             value.value = orig_value;
8379           /* Otherwise, if we have come to a subaggregate,
8380              and we don't have an element of its type, push into it.  */
8381           else if (value.value != 0
8382                    && value.value != error_mark_node
8383                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
8384                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
8385                        || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
8386             {
8387               push_init_level (1, braced_init_obstack);
8388               continue;
8389             }
8390
8391           if (constructor_max_index != 0
8392               && (tree_int_cst_lt (constructor_max_index, constructor_index)
8393                   || integer_all_onesp (constructor_max_index)))
8394             {
8395               pedwarn_init (input_location, 0,
8396                             "excess elements in array initializer");
8397               break;
8398             }
8399
8400           /* Now output the actual element.  */
8401           if (value.value)
8402             {
8403               push_array_bounds (tree_low_cst (constructor_index, 1));
8404               output_init_element (value.value, value.original_type,
8405                                    strict_string, elttype,
8406                                    constructor_index, 1, implicit,
8407                                    braced_init_obstack);
8408               RESTORE_SPELLING_DEPTH (constructor_depth);
8409             }
8410
8411           constructor_index
8412             = size_binop_loc (input_location, PLUS_EXPR,
8413                               constructor_index, bitsize_one_node);
8414
8415           if (!value.value)
8416             /* If we are doing the bookkeeping for an element that was
8417                directly output as a constructor, we must update
8418                constructor_unfilled_index.  */
8419             constructor_unfilled_index = constructor_index;
8420         }
8421       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
8422         {
8423           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
8424
8425          /* Do a basic check of initializer size.  Note that vectors
8426             always have a fixed size derived from their type.  */
8427           if (tree_int_cst_lt (constructor_max_index, constructor_index))
8428             {
8429               pedwarn_init (input_location, 0,
8430                             "excess elements in vector initializer");
8431               break;
8432             }
8433
8434           /* Now output the actual element.  */
8435           if (value.value)
8436             {
8437               if (TREE_CODE (value.value) == VECTOR_CST)
8438                 elttype = TYPE_MAIN_VARIANT (constructor_type);
8439               output_init_element (value.value, value.original_type,
8440                                    strict_string, elttype,
8441                                    constructor_index, 1, implicit,
8442                                    braced_init_obstack);
8443             }
8444
8445           constructor_index
8446             = size_binop_loc (input_location,
8447                               PLUS_EXPR, constructor_index, bitsize_one_node);
8448
8449           if (!value.value)
8450             /* If we are doing the bookkeeping for an element that was
8451                directly output as a constructor, we must update
8452                constructor_unfilled_index.  */
8453             constructor_unfilled_index = constructor_index;
8454         }
8455
8456       /* Handle the sole element allowed in a braced initializer
8457          for a scalar variable.  */
8458       else if (constructor_type != error_mark_node
8459                && constructor_fields == 0)
8460         {
8461           pedwarn_init (input_location, 0,
8462                         "excess elements in scalar initializer");
8463           break;
8464         }
8465       else
8466         {
8467           if (value.value)
8468             output_init_element (value.value, value.original_type,
8469                                  strict_string, constructor_type,
8470                                  NULL_TREE, 1, implicit,
8471                                  braced_init_obstack);
8472           constructor_fields = 0;
8473         }
8474
8475       /* Handle range initializers either at this level or anywhere higher
8476          in the designator stack.  */
8477       if (constructor_range_stack)
8478         {
8479           struct constructor_range_stack *p, *range_stack;
8480           int finish = 0;
8481
8482           range_stack = constructor_range_stack;
8483           constructor_range_stack = 0;
8484           while (constructor_stack != range_stack->stack)
8485             {
8486               gcc_assert (constructor_stack->implicit);
8487               process_init_element (pop_init_level (1,
8488                                                     braced_init_obstack),
8489                                     true, braced_init_obstack);
8490             }
8491           for (p = range_stack;
8492                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
8493                p = p->prev)
8494             {
8495               gcc_assert (constructor_stack->implicit);
8496               process_init_element (pop_init_level (1, braced_init_obstack),
8497                                     true, braced_init_obstack);
8498             }
8499
8500           p->index = size_binop_loc (input_location,
8501                                      PLUS_EXPR, p->index, bitsize_one_node);
8502           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
8503             finish = 1;
8504
8505           while (1)
8506             {
8507               constructor_index = p->index;
8508               constructor_fields = p->fields;
8509               if (finish && p->range_end && p->index == p->range_start)
8510                 {
8511                   finish = 0;
8512                   p->prev = 0;
8513                 }
8514               p = p->next;
8515               if (!p)
8516                 break;
8517               push_init_level (2, braced_init_obstack);
8518               p->stack = constructor_stack;
8519               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
8520                 p->index = p->range_start;
8521             }
8522
8523           if (!finish)
8524             constructor_range_stack = range_stack;
8525           continue;
8526         }
8527
8528       break;
8529     }
8530
8531   constructor_range_stack = 0;
8532 }
8533 \f
8534 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
8535    (guaranteed to be 'volatile' or null) and ARGS (represented using
8536    an ASM_EXPR node).  */
8537 tree
8538 build_asm_stmt (tree cv_qualifier, tree args)
8539 {
8540   if (!ASM_VOLATILE_P (args) && cv_qualifier)
8541     ASM_VOLATILE_P (args) = 1;
8542   return add_stmt (args);
8543 }
8544
8545 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
8546    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
8547    SIMPLE indicates whether there was anything at all after the
8548    string in the asm expression -- asm("blah") and asm("blah" : )
8549    are subtly different.  We use a ASM_EXPR node to represent this.  */
8550 tree
8551 build_asm_expr (location_t loc, tree string, tree outputs, tree inputs,
8552                 tree clobbers, tree labels, bool simple)
8553 {
8554   tree tail;
8555   tree args;
8556   int i;
8557   const char *constraint;
8558   const char **oconstraints;
8559   bool allows_mem, allows_reg, is_inout;
8560   int ninputs, noutputs;
8561
8562   ninputs = list_length (inputs);
8563   noutputs = list_length (outputs);
8564   oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
8565
8566   string = resolve_asm_operand_names (string, outputs, inputs, labels);
8567
8568   /* Remove output conversions that change the type but not the mode.  */
8569   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
8570     {
8571       tree output = TREE_VALUE (tail);
8572
8573       /* ??? Really, this should not be here.  Users should be using a
8574          proper lvalue, dammit.  But there's a long history of using casts
8575          in the output operands.  In cases like longlong.h, this becomes a
8576          primitive form of typechecking -- if the cast can be removed, then
8577          the output operand had a type of the proper width; otherwise we'll
8578          get an error.  Gross, but ...  */
8579       STRIP_NOPS (output);
8580
8581       if (!lvalue_or_else (loc, output, lv_asm))
8582         output = error_mark_node;
8583
8584       if (output != error_mark_node
8585           && (TREE_READONLY (output)
8586               || TYPE_READONLY (TREE_TYPE (output))
8587               || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
8588                    || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
8589                   && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
8590         readonly_error (output, lv_asm);
8591
8592       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
8593       oconstraints[i] = constraint;
8594
8595       if (parse_output_constraint (&constraint, i, ninputs, noutputs,
8596                                    &allows_mem, &allows_reg, &is_inout))
8597         {
8598           /* If the operand is going to end up in memory,
8599              mark it addressable.  */
8600           if (!allows_reg && !c_mark_addressable (output))
8601             output = error_mark_node;
8602           if (!(!allows_reg && allows_mem)
8603               && output != error_mark_node
8604               && VOID_TYPE_P (TREE_TYPE (output)))
8605             {
8606               error_at (loc, "invalid use of void expression");
8607               output = error_mark_node;
8608             }
8609         }
8610       else
8611         output = error_mark_node;
8612
8613       TREE_VALUE (tail) = output;
8614     }
8615
8616   for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
8617     {
8618       tree input;
8619
8620       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
8621       input = TREE_VALUE (tail);
8622
8623       if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
8624                                   oconstraints, &allows_mem, &allows_reg))
8625         {
8626           /* If the operand is going to end up in memory,
8627              mark it addressable.  */
8628           if (!allows_reg && allows_mem)
8629             {
8630               /* Strip the nops as we allow this case.  FIXME, this really
8631                  should be rejected or made deprecated.  */
8632               STRIP_NOPS (input);
8633               if (!c_mark_addressable (input))
8634                 input = error_mark_node;
8635             }
8636           else if (input != error_mark_node && VOID_TYPE_P (TREE_TYPE (input)))
8637             {
8638               error_at (loc, "invalid use of void expression");
8639               input = error_mark_node;
8640             }
8641         }
8642       else
8643         input = error_mark_node;
8644
8645       TREE_VALUE (tail) = input;
8646     }
8647
8648   /* ASMs with labels cannot have outputs.  This should have been
8649      enforced by the parser.  */
8650   gcc_assert (outputs == NULL || labels == NULL);
8651
8652   args = build_stmt (loc, ASM_EXPR, string, outputs, inputs, clobbers, labels);
8653
8654   /* asm statements without outputs, including simple ones, are treated
8655      as volatile.  */
8656   ASM_INPUT_P (args) = simple;
8657   ASM_VOLATILE_P (args) = (noutputs == 0);
8658
8659   return args;
8660 }
8661 \f
8662 /* Generate a goto statement to LABEL.  LOC is the location of the
8663    GOTO.  */
8664
8665 tree
8666 c_finish_goto_label (location_t loc, tree label)
8667 {
8668   tree decl = lookup_label_for_goto (loc, label);
8669   if (!decl)
8670     return NULL_TREE;
8671   TREE_USED (decl) = 1;
8672   {
8673     tree t = build1 (GOTO_EXPR, void_type_node, decl);
8674     SET_EXPR_LOCATION (t, loc);
8675     return add_stmt (t);
8676   }
8677 }
8678
8679 /* Generate a computed goto statement to EXPR.  LOC is the location of
8680    the GOTO.  */
8681
8682 tree
8683 c_finish_goto_ptr (location_t loc, tree expr)
8684 {
8685   tree t;
8686   pedwarn (loc, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
8687   expr = c_fully_fold (expr, false, NULL);
8688   expr = convert (ptr_type_node, expr);
8689   t = build1 (GOTO_EXPR, void_type_node, expr);
8690   SET_EXPR_LOCATION (t, loc);
8691   return add_stmt (t);
8692 }
8693
8694 /* Generate a C `return' statement.  RETVAL is the expression for what
8695    to return, or a null pointer for `return;' with no value.  LOC is
8696    the location of the return statement.  If ORIGTYPE is not NULL_TREE, it
8697    is the original type of RETVAL.  */
8698
8699 tree
8700 c_finish_return (location_t loc, tree retval, tree origtype)
8701 {
8702   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
8703   bool no_warning = false;
8704   bool npc = false;
8705
8706   if (TREE_THIS_VOLATILE (current_function_decl))
8707     warning_at (loc, 0,
8708                 "function declared %<noreturn%> has a %<return%> statement");
8709
8710   if (retval)
8711     {
8712       tree semantic_type = NULL_TREE;
8713       npc = null_pointer_constant_p (retval);
8714       if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
8715         {
8716           semantic_type = TREE_TYPE (retval);
8717           retval = TREE_OPERAND (retval, 0);
8718         }
8719       retval = c_fully_fold (retval, false, NULL);
8720       if (semantic_type)
8721         retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
8722     }
8723
8724   if (!retval)
8725     {
8726       current_function_returns_null = 1;
8727       if ((warn_return_type || flag_isoc99)
8728           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
8729         {
8730           pedwarn_c99 (loc, flag_isoc99 ? 0 : OPT_Wreturn_type,
8731                        "%<return%> with no value, in "
8732                        "function returning non-void");
8733           no_warning = true;
8734         }
8735     }
8736   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
8737     {
8738       current_function_returns_null = 1;
8739       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
8740         pedwarn (loc, 0,
8741                  "%<return%> with a value, in function returning void");
8742       else
8743         pedwarn (loc, OPT_pedantic, "ISO C forbids "
8744                  "%<return%> with expression, in function returning void");
8745     }
8746   else
8747     {
8748       tree t = convert_for_assignment (loc, valtype, retval, origtype,
8749                                        ic_return,
8750                                        npc, NULL_TREE, NULL_TREE, 0);
8751       tree res = DECL_RESULT (current_function_decl);
8752       tree inner;
8753
8754       current_function_returns_value = 1;
8755       if (t == error_mark_node)
8756         return NULL_TREE;
8757
8758       inner = t = convert (TREE_TYPE (res), t);
8759
8760       /* Strip any conversions, additions, and subtractions, and see if
8761          we are returning the address of a local variable.  Warn if so.  */
8762       while (1)
8763         {
8764           switch (TREE_CODE (inner))
8765             {
8766             CASE_CONVERT:
8767             case NON_LVALUE_EXPR:
8768             case PLUS_EXPR:
8769             case POINTER_PLUS_EXPR:
8770               inner = TREE_OPERAND (inner, 0);
8771               continue;
8772
8773             case MINUS_EXPR:
8774               /* If the second operand of the MINUS_EXPR has a pointer
8775                  type (or is converted from it), this may be valid, so
8776                  don't give a warning.  */
8777               {
8778                 tree op1 = TREE_OPERAND (inner, 1);
8779
8780                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
8781                        && (CONVERT_EXPR_P (op1)
8782                            || TREE_CODE (op1) == NON_LVALUE_EXPR))
8783                   op1 = TREE_OPERAND (op1, 0);
8784
8785                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
8786                   break;
8787
8788                 inner = TREE_OPERAND (inner, 0);
8789                 continue;
8790               }
8791
8792             case ADDR_EXPR:
8793               inner = TREE_OPERAND (inner, 0);
8794
8795               while (REFERENCE_CLASS_P (inner)
8796                      && TREE_CODE (inner) != INDIRECT_REF)
8797                 inner = TREE_OPERAND (inner, 0);
8798
8799               if (DECL_P (inner)
8800                   && !DECL_EXTERNAL (inner)
8801                   && !TREE_STATIC (inner)
8802                   && DECL_CONTEXT (inner) == current_function_decl)
8803                 warning_at (loc,
8804                             0, "function returns address of local variable");
8805               break;
8806
8807             default:
8808               break;
8809             }
8810
8811           break;
8812         }
8813
8814       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
8815       SET_EXPR_LOCATION (retval, loc);
8816
8817       if (warn_sequence_point)
8818         verify_sequence_points (retval);
8819     }
8820
8821   ret_stmt = build_stmt (loc, RETURN_EXPR, retval);
8822   TREE_NO_WARNING (ret_stmt) |= no_warning;
8823   return add_stmt (ret_stmt);
8824 }
8825 \f
8826 struct c_switch {
8827   /* The SWITCH_EXPR being built.  */
8828   tree switch_expr;
8829
8830   /* The original type of the testing expression, i.e. before the
8831      default conversion is applied.  */
8832   tree orig_type;
8833
8834   /* A splay-tree mapping the low element of a case range to the high
8835      element, or NULL_TREE if there is no high element.  Used to
8836      determine whether or not a new case label duplicates an old case
8837      label.  We need a tree, rather than simply a hash table, because
8838      of the GNU case range extension.  */
8839   splay_tree cases;
8840
8841   /* The bindings at the point of the switch.  This is used for
8842      warnings crossing decls when branching to a case label.  */
8843   struct c_spot_bindings *bindings;
8844
8845   /* The next node on the stack.  */
8846   struct c_switch *next;
8847 };
8848
8849 /* A stack of the currently active switch statements.  The innermost
8850    switch statement is on the top of the stack.  There is no need to
8851    mark the stack for garbage collection because it is only active
8852    during the processing of the body of a function, and we never
8853    collect at that point.  */
8854
8855 struct c_switch *c_switch_stack;
8856
8857 /* Start a C switch statement, testing expression EXP.  Return the new
8858    SWITCH_EXPR.  SWITCH_LOC is the location of the `switch'.
8859    SWITCH_COND_LOC is the location of the switch's condition.  */
8860
8861 tree
8862 c_start_case (location_t switch_loc,
8863               location_t switch_cond_loc,
8864               tree exp)
8865 {
8866   tree orig_type = error_mark_node;
8867   struct c_switch *cs;
8868
8869   if (exp != error_mark_node)
8870     {
8871       orig_type = TREE_TYPE (exp);
8872
8873       if (!INTEGRAL_TYPE_P (orig_type))
8874         {
8875           if (orig_type != error_mark_node)
8876             {
8877               error_at (switch_cond_loc, "switch quantity not an integer");
8878               orig_type = error_mark_node;
8879             }
8880           exp = integer_zero_node;
8881         }
8882       else
8883         {
8884           tree type = TYPE_MAIN_VARIANT (orig_type);
8885
8886           if (!in_system_header
8887               && (type == long_integer_type_node
8888                   || type == long_unsigned_type_node))
8889             warning_at (switch_cond_loc,
8890                         OPT_Wtraditional, "%<long%> switch expression not "
8891                         "converted to %<int%> in ISO C");
8892
8893           exp = c_fully_fold (exp, false, NULL);
8894           exp = default_conversion (exp);
8895
8896           if (warn_sequence_point)
8897             verify_sequence_points (exp);
8898         }
8899     }
8900
8901   /* Add this new SWITCH_EXPR to the stack.  */
8902   cs = XNEW (struct c_switch);
8903   cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
8904   SET_EXPR_LOCATION (cs->switch_expr, switch_loc);
8905   cs->orig_type = orig_type;
8906   cs->cases = splay_tree_new (case_compare, NULL, NULL);
8907   cs->bindings = c_get_switch_bindings ();
8908   cs->next = c_switch_stack;
8909   c_switch_stack = cs;
8910
8911   return add_stmt (cs->switch_expr);
8912 }
8913
8914 /* Process a case label at location LOC.  */
8915
8916 tree
8917 do_case (location_t loc, tree low_value, tree high_value)
8918 {
8919   tree label = NULL_TREE;
8920
8921   if (low_value && TREE_CODE (low_value) != INTEGER_CST)
8922     {
8923       low_value = c_fully_fold (low_value, false, NULL);
8924       if (TREE_CODE (low_value) == INTEGER_CST)
8925         pedwarn (input_location, OPT_pedantic,
8926                  "case label is not an integer constant expression");
8927     }
8928
8929   if (high_value && TREE_CODE (high_value) != INTEGER_CST)
8930     {
8931       high_value = c_fully_fold (high_value, false, NULL);
8932       if (TREE_CODE (high_value) == INTEGER_CST)
8933         pedwarn (input_location, OPT_pedantic,
8934                  "case label is not an integer constant expression");
8935     }
8936
8937   if (c_switch_stack == NULL)
8938     {
8939       if (low_value)
8940         error_at (loc, "case label not within a switch statement");
8941       else
8942         error_at (loc, "%<default%> label not within a switch statement");
8943       return NULL_TREE;
8944     }
8945
8946   if (c_check_switch_jump_warnings (c_switch_stack->bindings,
8947                                     EXPR_LOCATION (c_switch_stack->switch_expr),
8948                                     loc))
8949     return NULL_TREE;
8950
8951   label = c_add_case_label (loc, c_switch_stack->cases,
8952                             SWITCH_COND (c_switch_stack->switch_expr),
8953                             c_switch_stack->orig_type,
8954                             low_value, high_value);
8955   if (label == error_mark_node)
8956     label = NULL_TREE;
8957   return label;
8958 }
8959
8960 /* Finish the switch statement.  */
8961
8962 void
8963 c_finish_case (tree body)
8964 {
8965   struct c_switch *cs = c_switch_stack;
8966   location_t switch_location;
8967
8968   SWITCH_BODY (cs->switch_expr) = body;
8969
8970   /* Emit warnings as needed.  */
8971   switch_location = EXPR_LOCATION (cs->switch_expr);
8972   c_do_switch_warnings (cs->cases, switch_location,
8973                         TREE_TYPE (cs->switch_expr),
8974                         SWITCH_COND (cs->switch_expr));
8975
8976   /* Pop the stack.  */
8977   c_switch_stack = cs->next;
8978   splay_tree_delete (cs->cases);
8979   c_release_switch_bindings (cs->bindings);
8980   XDELETE (cs);
8981 }
8982 \f
8983 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
8984    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8985    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
8986    statement, and was not surrounded with parenthesis.  */
8987
8988 void
8989 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
8990                   tree else_block, bool nested_if)
8991 {
8992   tree stmt;
8993
8994   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
8995   if (warn_parentheses && nested_if && else_block == NULL)
8996     {
8997       tree inner_if = then_block;
8998
8999       /* We know from the grammar productions that there is an IF nested
9000          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
9001          it might not be exactly THEN_BLOCK, but should be the last
9002          non-container statement within.  */
9003       while (1)
9004         switch (TREE_CODE (inner_if))
9005           {
9006           case COND_EXPR:
9007             goto found;
9008           case BIND_EXPR:
9009             inner_if = BIND_EXPR_BODY (inner_if);
9010             break;
9011           case STATEMENT_LIST:
9012             inner_if = expr_last (then_block);
9013             break;
9014           case TRY_FINALLY_EXPR:
9015           case TRY_CATCH_EXPR:
9016             inner_if = TREE_OPERAND (inner_if, 0);
9017             break;
9018           default:
9019             gcc_unreachable ();
9020           }
9021     found:
9022
9023       if (COND_EXPR_ELSE (inner_if))
9024          warning_at (if_locus, OPT_Wparentheses,
9025                      "suggest explicit braces to avoid ambiguous %<else%>");
9026     }
9027
9028   stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
9029   SET_EXPR_LOCATION (stmt, if_locus);
9030   add_stmt (stmt);
9031 }
9032
9033 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
9034    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
9035    is false for DO loops.  INCR is the FOR increment expression.  BODY is
9036    the statement controlled by the loop.  BLAB is the break label.  CLAB is
9037    the continue label.  Everything is allowed to be NULL.  */
9038
9039 void
9040 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
9041                tree blab, tree clab, bool cond_is_first)
9042 {
9043   tree entry = NULL, exit = NULL, t;
9044
9045   /* If the condition is zero don't generate a loop construct.  */
9046   if (cond && integer_zerop (cond))
9047     {
9048       if (cond_is_first)
9049         {
9050           t = build_and_jump (&blab);
9051           SET_EXPR_LOCATION (t, start_locus);
9052           add_stmt (t);
9053         }
9054     }
9055   else
9056     {
9057       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
9058
9059       /* If we have an exit condition, then we build an IF with gotos either
9060          out of the loop, or to the top of it.  If there's no exit condition,
9061          then we just build a jump back to the top.  */
9062       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
9063
9064       if (cond && !integer_nonzerop (cond))
9065         {
9066           /* Canonicalize the loop condition to the end.  This means
9067              generating a branch to the loop condition.  Reuse the
9068              continue label, if possible.  */
9069           if (cond_is_first)
9070             {
9071               if (incr || !clab)
9072                 {
9073                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
9074                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
9075                 }
9076               else
9077                 t = build1 (GOTO_EXPR, void_type_node, clab);
9078               SET_EXPR_LOCATION (t, start_locus);
9079               add_stmt (t);
9080             }
9081
9082           t = build_and_jump (&blab);
9083           if (cond_is_first)
9084             exit = fold_build3_loc (start_locus,
9085                                 COND_EXPR, void_type_node, cond, exit, t);
9086           else
9087             exit = fold_build3_loc (input_location,
9088                                 COND_EXPR, void_type_node, cond, exit, t);
9089         }
9090
9091       add_stmt (top);
9092     }
9093
9094   if (body)
9095     add_stmt (body);
9096   if (clab)
9097     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
9098   if (incr)
9099     add_stmt (incr);
9100   if (entry)
9101     add_stmt (entry);
9102   if (exit)
9103     add_stmt (exit);
9104   if (blab)
9105     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
9106 }
9107
9108 tree
9109 c_finish_bc_stmt (location_t loc, tree *label_p, bool is_break)
9110 {
9111   bool skip;
9112   tree label = *label_p;
9113
9114   /* In switch statements break is sometimes stylistically used after
9115      a return statement.  This can lead to spurious warnings about
9116      control reaching the end of a non-void function when it is
9117      inlined.  Note that we are calling block_may_fallthru with
9118      language specific tree nodes; this works because
9119      block_may_fallthru returns true when given something it does not
9120      understand.  */
9121   skip = !block_may_fallthru (cur_stmt_list);
9122
9123   if (!label)
9124     {
9125       if (!skip)
9126         *label_p = label = create_artificial_label (loc);
9127     }
9128   else if (TREE_CODE (label) == LABEL_DECL)
9129     ;
9130   else switch (TREE_INT_CST_LOW (label))
9131     {
9132     case 0:
9133       if (is_break)
9134         error_at (loc, "break statement not within loop or switch");
9135       else
9136         error_at (loc, "continue statement not within a loop");
9137       return NULL_TREE;
9138
9139     case 1:
9140       gcc_assert (is_break);
9141       error_at (loc, "break statement used with OpenMP for loop");
9142       return NULL_TREE;
9143
9144     default:
9145       gcc_unreachable ();
9146     }
9147
9148   if (skip)
9149     return NULL_TREE;
9150
9151   if (!is_break)
9152     add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
9153
9154   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
9155 }
9156
9157 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
9158
9159 static void
9160 emit_side_effect_warnings (location_t loc, tree expr)
9161 {
9162   if (expr == error_mark_node)
9163     ;
9164   else if (!TREE_SIDE_EFFECTS (expr))
9165     {
9166       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
9167         warning_at (loc, OPT_Wunused_value, "statement with no effect");
9168     }
9169   else
9170     warn_if_unused_value (expr, loc);
9171 }
9172
9173 /* Process an expression as if it were a complete statement.  Emit
9174    diagnostics, but do not call ADD_STMT.  LOC is the location of the
9175    statement.  */
9176
9177 tree
9178 c_process_expr_stmt (location_t loc, tree expr)
9179 {
9180   tree exprv;
9181
9182   if (!expr)
9183     return NULL_TREE;
9184
9185   expr = c_fully_fold (expr, false, NULL);
9186
9187   if (warn_sequence_point)
9188     verify_sequence_points (expr);
9189
9190   if (TREE_TYPE (expr) != error_mark_node
9191       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
9192       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
9193     error_at (loc, "expression statement has incomplete type");
9194
9195   /* If we're not processing a statement expression, warn about unused values.
9196      Warnings for statement expressions will be emitted later, once we figure
9197      out which is the result.  */
9198   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
9199       && warn_unused_value)
9200     emit_side_effect_warnings (loc, expr);
9201
9202   exprv = expr;
9203   while (TREE_CODE (exprv) == COMPOUND_EXPR)
9204     exprv = TREE_OPERAND (exprv, 1);
9205   while (CONVERT_EXPR_P (exprv))
9206     exprv = TREE_OPERAND (exprv, 0);
9207   if (DECL_P (exprv)
9208       || handled_component_p (exprv)
9209       || TREE_CODE (exprv) == ADDR_EXPR)
9210     mark_exp_read (exprv);
9211
9212   /* If the expression is not of a type to which we cannot assign a line
9213      number, wrap the thing in a no-op NOP_EXPR.  */
9214   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
9215     {
9216       expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
9217       SET_EXPR_LOCATION (expr, loc);
9218     }
9219
9220   return expr;
9221 }
9222
9223 /* Emit an expression as a statement.  LOC is the location of the
9224    expression.  */
9225
9226 tree
9227 c_finish_expr_stmt (location_t loc, tree expr)
9228 {
9229   if (expr)
9230     return add_stmt (c_process_expr_stmt (loc, expr));
9231   else
9232     return NULL;
9233 }
9234
9235 /* Do the opposite and emit a statement as an expression.  To begin,
9236    create a new binding level and return it.  */
9237
9238 tree
9239 c_begin_stmt_expr (void)
9240 {
9241   tree ret;
9242
9243   /* We must force a BLOCK for this level so that, if it is not expanded
9244      later, there is a way to turn off the entire subtree of blocks that
9245      are contained in it.  */
9246   keep_next_level ();
9247   ret = c_begin_compound_stmt (true);
9248
9249   c_bindings_start_stmt_expr (c_switch_stack == NULL
9250                               ? NULL
9251                               : c_switch_stack->bindings);
9252
9253   /* Mark the current statement list as belonging to a statement list.  */
9254   STATEMENT_LIST_STMT_EXPR (ret) = 1;
9255
9256   return ret;
9257 }
9258
9259 /* LOC is the location of the compound statement to which this body
9260    belongs.  */
9261
9262 tree
9263 c_finish_stmt_expr (location_t loc, tree body)
9264 {
9265   tree last, type, tmp, val;
9266   tree *last_p;
9267
9268   body = c_end_compound_stmt (loc, body, true);
9269
9270   c_bindings_end_stmt_expr (c_switch_stack == NULL
9271                             ? NULL
9272                             : c_switch_stack->bindings);
9273
9274   /* Locate the last statement in BODY.  See c_end_compound_stmt
9275      about always returning a BIND_EXPR.  */
9276   last_p = &BIND_EXPR_BODY (body);
9277   last = BIND_EXPR_BODY (body);
9278
9279  continue_searching:
9280   if (TREE_CODE (last) == STATEMENT_LIST)
9281     {
9282       tree_stmt_iterator i;
9283
9284       /* This can happen with degenerate cases like ({ }).  No value.  */
9285       if (!TREE_SIDE_EFFECTS (last))
9286         return body;
9287
9288       /* If we're supposed to generate side effects warnings, process
9289          all of the statements except the last.  */
9290       if (warn_unused_value)
9291         {
9292           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
9293             {
9294               location_t tloc;
9295               tree t = tsi_stmt (i);
9296
9297               tloc = EXPR_HAS_LOCATION (t) ? EXPR_LOCATION (t) : loc;
9298               emit_side_effect_warnings (tloc, t);
9299             }
9300         }
9301       else
9302         i = tsi_last (last);
9303       last_p = tsi_stmt_ptr (i);
9304       last = *last_p;
9305     }
9306
9307   /* If the end of the list is exception related, then the list was split
9308      by a call to push_cleanup.  Continue searching.  */
9309   if (TREE_CODE (last) == TRY_FINALLY_EXPR
9310       || TREE_CODE (last) == TRY_CATCH_EXPR)
9311     {
9312       last_p = &TREE_OPERAND (last, 0);
9313       last = *last_p;
9314       goto continue_searching;
9315     }
9316
9317   if (last == error_mark_node)
9318     return last;
9319
9320   /* In the case that the BIND_EXPR is not necessary, return the
9321      expression out from inside it.  */
9322   if (last == BIND_EXPR_BODY (body)
9323       && BIND_EXPR_VARS (body) == NULL)
9324     {
9325       /* Even if this looks constant, do not allow it in a constant
9326          expression.  */
9327       last = c_wrap_maybe_const (last, true);
9328       /* Do not warn if the return value of a statement expression is
9329          unused.  */
9330       TREE_NO_WARNING (last) = 1;
9331       return last;
9332     }
9333
9334   /* Extract the type of said expression.  */
9335   type = TREE_TYPE (last);
9336
9337   /* If we're not returning a value at all, then the BIND_EXPR that
9338      we already have is a fine expression to return.  */
9339   if (!type || VOID_TYPE_P (type))
9340     return body;
9341
9342   /* Now that we've located the expression containing the value, it seems
9343      silly to make voidify_wrapper_expr repeat the process.  Create a
9344      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
9345   tmp = create_tmp_var_raw (type, NULL);
9346
9347   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
9348      tree_expr_nonnegative_p giving up immediately.  */
9349   val = last;
9350   if (TREE_CODE (val) == NOP_EXPR
9351       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
9352     val = TREE_OPERAND (val, 0);
9353
9354   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
9355   SET_EXPR_LOCATION (*last_p, EXPR_LOCATION (last));
9356
9357   {
9358     tree t = build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
9359     SET_EXPR_LOCATION (t, loc);
9360     return t;
9361   }
9362 }
9363 \f
9364 /* Begin and end compound statements.  This is as simple as pushing
9365    and popping new statement lists from the tree.  */
9366
9367 tree
9368 c_begin_compound_stmt (bool do_scope)
9369 {
9370   tree stmt = push_stmt_list ();
9371   if (do_scope)
9372     push_scope ();
9373   return stmt;
9374 }
9375
9376 /* End a compound statement.  STMT is the statement.  LOC is the
9377    location of the compound statement-- this is usually the location
9378    of the opening brace.  */
9379
9380 tree
9381 c_end_compound_stmt (location_t loc, tree stmt, bool do_scope)
9382 {
9383   tree block = NULL;
9384
9385   if (do_scope)
9386     {
9387       if (c_dialect_objc ())
9388         objc_clear_super_receiver ();
9389       block = pop_scope ();
9390     }
9391
9392   stmt = pop_stmt_list (stmt);
9393   stmt = c_build_bind_expr (loc, block, stmt);
9394
9395   /* If this compound statement is nested immediately inside a statement
9396      expression, then force a BIND_EXPR to be created.  Otherwise we'll
9397      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
9398      STATEMENT_LISTs merge, and thus we can lose track of what statement
9399      was really last.  */
9400   if (building_stmt_list_p ()
9401       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
9402       && TREE_CODE (stmt) != BIND_EXPR)
9403     {
9404       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
9405       TREE_SIDE_EFFECTS (stmt) = 1;
9406       SET_EXPR_LOCATION (stmt, loc);
9407     }
9408
9409   return stmt;
9410 }
9411
9412 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
9413    when the current scope is exited.  EH_ONLY is true when this is not
9414    meant to apply to normal control flow transfer.  */
9415
9416 void
9417 push_cleanup (tree decl, tree cleanup, bool eh_only)
9418 {
9419   enum tree_code code;
9420   tree stmt, list;
9421   bool stmt_expr;
9422
9423   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
9424   stmt = build_stmt (DECL_SOURCE_LOCATION (decl), code, NULL, cleanup);
9425   add_stmt (stmt);
9426   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
9427   list = push_stmt_list ();
9428   TREE_OPERAND (stmt, 0) = list;
9429   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
9430 }
9431
9432 /* Convert scalar to vector for the range of operations.  */
9433 static enum stv_conv
9434 scalar_to_vector (location_t loc, enum tree_code code, tree op0, tree op1)
9435 {
9436   tree type0 = TREE_TYPE (op0);
9437   tree type1 = TREE_TYPE (op1);
9438   bool integer_only_op = false;
9439   enum stv_conv ret = stv_firstarg;
9440
9441   gcc_assert (TREE_CODE (type0) == VECTOR_TYPE
9442               || TREE_CODE (type1) == VECTOR_TYPE);
9443   switch (code)
9444     {
9445       case RSHIFT_EXPR:
9446       case LSHIFT_EXPR:
9447         if (TREE_CODE (type0) == INTEGER_TYPE
9448             && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9449           {
9450             if (unsafe_conversion_p (TREE_TYPE (type1), op0, false))
9451               {
9452                 error_at (loc, "conversion of scalar to vector "
9453                                "involves truncation");
9454                 return stv_error;
9455               }
9456             else
9457               return stv_firstarg;
9458           }
9459         break;
9460
9461       case BIT_IOR_EXPR:
9462       case BIT_XOR_EXPR:
9463       case BIT_AND_EXPR:
9464         integer_only_op = true;
9465         /* ... fall through ...  */
9466
9467       case PLUS_EXPR:
9468       case MINUS_EXPR:
9469       case MULT_EXPR:
9470       case TRUNC_DIV_EXPR:
9471       case TRUNC_MOD_EXPR:
9472       case RDIV_EXPR:
9473         if (TREE_CODE (type0) == VECTOR_TYPE)
9474           {
9475             tree tmp;
9476             ret = stv_secondarg;
9477             /* Swap TYPE0 with TYPE1 and OP0 with OP1  */
9478             tmp = type0; type0 = type1; type1 = tmp;
9479             tmp = op0; op0 = op1; op1 = tmp;
9480           }
9481
9482         if (TREE_CODE (type0) == INTEGER_TYPE
9483             && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9484           {
9485             if (unsafe_conversion_p (TREE_TYPE (type1), op0, false))
9486               {
9487                 error_at (loc, "conversion of scalar to vector "
9488                                "involves truncation");
9489                 return stv_error;
9490               }
9491             return ret;
9492           }
9493         else if (!integer_only_op
9494                     /* Allow integer --> real conversion if safe.  */
9495                  && (TREE_CODE (type0) == REAL_TYPE
9496                      || TREE_CODE (type0) == INTEGER_TYPE)
9497                  && SCALAR_FLOAT_TYPE_P (TREE_TYPE (type1)))
9498           {
9499             if (unsafe_conversion_p (TREE_TYPE (type1), op0, false))
9500               {
9501                 error_at (loc, "conversion of scalar to vector "
9502                                "involves truncation");
9503                 return stv_error;
9504               }
9505             return ret;
9506           }
9507       default:
9508         break;
9509     }
9510
9511   return stv_nothing;
9512 }
9513 \f
9514 /* Build a binary-operation expression without default conversions.
9515    CODE is the kind of expression to build.
9516    LOCATION is the operator's location.
9517    This function differs from `build' in several ways:
9518    the data type of the result is computed and recorded in it,
9519    warnings are generated if arg data types are invalid,
9520    special handling for addition and subtraction of pointers is known,
9521    and some optimization is done (operations on narrow ints
9522    are done in the narrower type when that gives the same result).
9523    Constant folding is also done before the result is returned.
9524
9525    Note that the operands will never have enumeral types, or function
9526    or array types, because either they will have the default conversions
9527    performed or they have both just been converted to some other type in which
9528    the arithmetic is to be done.  */
9529
9530 tree
9531 build_binary_op (location_t location, enum tree_code code,
9532                  tree orig_op0, tree orig_op1, int convert_p)
9533 {
9534   tree type0, type1, orig_type0, orig_type1;
9535   tree eptype;
9536   enum tree_code code0, code1;
9537   tree op0, op1;
9538   tree ret = error_mark_node;
9539   const char *invalid_op_diag;
9540   bool op0_int_operands, op1_int_operands;
9541   bool int_const, int_const_or_overflow, int_operands;
9542
9543   /* Expression code to give to the expression when it is built.
9544      Normally this is CODE, which is what the caller asked for,
9545      but in some special cases we change it.  */
9546   enum tree_code resultcode = code;
9547
9548   /* Data type in which the computation is to be performed.
9549      In the simplest cases this is the common type of the arguments.  */
9550   tree result_type = NULL;
9551
9552   /* When the computation is in excess precision, the type of the
9553      final EXCESS_PRECISION_EXPR.  */
9554   tree semantic_result_type = NULL;
9555
9556   /* Nonzero means operands have already been type-converted
9557      in whatever way is necessary.
9558      Zero means they need to be converted to RESULT_TYPE.  */
9559   int converted = 0;
9560
9561   /* Nonzero means create the expression with this type, rather than
9562      RESULT_TYPE.  */
9563   tree build_type = 0;
9564
9565   /* Nonzero means after finally constructing the expression
9566      convert it to this type.  */
9567   tree final_type = 0;
9568
9569   /* Nonzero if this is an operation like MIN or MAX which can
9570      safely be computed in short if both args are promoted shorts.
9571      Also implies COMMON.
9572      -1 indicates a bitwise operation; this makes a difference
9573      in the exact conditions for when it is safe to do the operation
9574      in a narrower mode.  */
9575   int shorten = 0;
9576
9577   /* Nonzero if this is a comparison operation;
9578      if both args are promoted shorts, compare the original shorts.
9579      Also implies COMMON.  */
9580   int short_compare = 0;
9581
9582   /* Nonzero if this is a right-shift operation, which can be computed on the
9583      original short and then promoted if the operand is a promoted short.  */
9584   int short_shift = 0;
9585
9586   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
9587   int common = 0;
9588
9589   /* True means types are compatible as far as ObjC is concerned.  */
9590   bool objc_ok;
9591
9592   /* True means this is an arithmetic operation that may need excess
9593      precision.  */
9594   bool may_need_excess_precision;
9595
9596   /* True means this is a boolean operation that converts both its
9597      operands to truth-values.  */
9598   bool boolean_op = false;
9599
9600   if (location == UNKNOWN_LOCATION)
9601     location = input_location;
9602
9603   op0 = orig_op0;
9604   op1 = orig_op1;
9605
9606   op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
9607   if (op0_int_operands)
9608     op0 = remove_c_maybe_const_expr (op0);
9609   op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
9610   if (op1_int_operands)
9611     op1 = remove_c_maybe_const_expr (op1);
9612   int_operands = (op0_int_operands && op1_int_operands);
9613   if (int_operands)
9614     {
9615       int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
9616                                && TREE_CODE (orig_op1) == INTEGER_CST);
9617       int_const = (int_const_or_overflow
9618                    && !TREE_OVERFLOW (orig_op0)
9619                    && !TREE_OVERFLOW (orig_op1));
9620     }
9621   else
9622     int_const = int_const_or_overflow = false;
9623
9624   /* Do not apply default conversion in mixed vector/scalar expression.  */
9625   if (convert_p
9626       && !((TREE_CODE (TREE_TYPE (op0)) == VECTOR_TYPE)
9627            != (TREE_CODE (TREE_TYPE (op1)) == VECTOR_TYPE)))
9628     {
9629       op0 = default_conversion (op0);
9630       op1 = default_conversion (op1);
9631     }
9632
9633   orig_type0 = type0 = TREE_TYPE (op0);
9634   orig_type1 = type1 = TREE_TYPE (op1);
9635
9636   /* The expression codes of the data types of the arguments tell us
9637      whether the arguments are integers, floating, pointers, etc.  */
9638   code0 = TREE_CODE (type0);
9639   code1 = TREE_CODE (type1);
9640
9641   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
9642   STRIP_TYPE_NOPS (op0);
9643   STRIP_TYPE_NOPS (op1);
9644
9645   /* If an error was already reported for one of the arguments,
9646      avoid reporting another error.  */
9647
9648   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
9649     return error_mark_node;
9650
9651   if ((invalid_op_diag
9652        = targetm.invalid_binary_op (code, type0, type1)))
9653     {
9654       error_at (location, invalid_op_diag);
9655       return error_mark_node;
9656     }
9657
9658   switch (code)
9659     {
9660     case PLUS_EXPR:
9661     case MINUS_EXPR:
9662     case MULT_EXPR:
9663     case TRUNC_DIV_EXPR:
9664     case CEIL_DIV_EXPR:
9665     case FLOOR_DIV_EXPR:
9666     case ROUND_DIV_EXPR:
9667     case EXACT_DIV_EXPR:
9668       may_need_excess_precision = true;
9669       break;
9670     default:
9671       may_need_excess_precision = false;
9672       break;
9673     }
9674   if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
9675     {
9676       op0 = TREE_OPERAND (op0, 0);
9677       type0 = TREE_TYPE (op0);
9678     }
9679   else if (may_need_excess_precision
9680            && (eptype = excess_precision_type (type0)) != NULL_TREE)
9681     {
9682       type0 = eptype;
9683       op0 = convert (eptype, op0);
9684     }
9685   if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
9686     {
9687       op1 = TREE_OPERAND (op1, 0);
9688       type1 = TREE_TYPE (op1);
9689     }
9690   else if (may_need_excess_precision
9691            && (eptype = excess_precision_type (type1)) != NULL_TREE)
9692     {
9693       type1 = eptype;
9694       op1 = convert (eptype, op1);
9695     }
9696
9697   objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
9698
9699   /* In case when one of the operands of the binary operation is
9700      a vector and another is a scalar -- convert scalar to vector.  */
9701   if ((code0 == VECTOR_TYPE) != (code1 == VECTOR_TYPE))
9702     {
9703       enum stv_conv convert_flag = scalar_to_vector (location, code, op0, op1);
9704
9705       switch (convert_flag)
9706         {
9707           case stv_error:
9708             return error_mark_node;
9709           case stv_firstarg:
9710             {
9711               bool maybe_const = true;
9712               tree sc;
9713               sc = c_fully_fold (op0, false, &maybe_const);
9714               sc = save_expr (sc);
9715               sc = convert (TREE_TYPE (type1), sc);
9716               op0 = build_vector_from_val (type1, sc);
9717               if (!maybe_const)
9718                 op0 = c_wrap_maybe_const (op0, true);
9719               orig_type0 = type0 = TREE_TYPE (op0);
9720               code0 = TREE_CODE (type0);
9721               converted = 1;
9722               break;
9723             }
9724           case stv_secondarg:
9725             {
9726               bool maybe_const = true;
9727               tree sc;
9728               sc = c_fully_fold (op1, false, &maybe_const);
9729               sc = save_expr (sc);
9730               sc = convert (TREE_TYPE (type0), sc);
9731               op1 = build_vector_from_val (type0, sc);
9732               if (!maybe_const)
9733                 op0 = c_wrap_maybe_const (op1, true);
9734               orig_type1 = type1 = TREE_TYPE (op1);
9735               code1 = TREE_CODE (type1);
9736               converted = 1;
9737               break;
9738             }
9739           default:
9740             break;
9741         }
9742     }
9743
9744   switch (code)
9745     {
9746     case PLUS_EXPR:
9747       /* Handle the pointer + int case.  */
9748       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9749         {
9750           ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
9751           goto return_build_binary_op;
9752         }
9753       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
9754         {
9755           ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
9756           goto return_build_binary_op;
9757         }
9758       else
9759         common = 1;
9760       break;
9761
9762     case MINUS_EXPR:
9763       /* Subtraction of two similar pointers.
9764          We must subtract them as integers, then divide by object size.  */
9765       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
9766           && comp_target_types (location, type0, type1))
9767         {
9768           ret = pointer_diff (location, op0, op1);
9769           goto return_build_binary_op;
9770         }
9771       /* Handle pointer minus int.  Just like pointer plus int.  */
9772       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9773         {
9774           ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
9775           goto return_build_binary_op;
9776         }
9777       else
9778         common = 1;
9779       break;
9780
9781     case MULT_EXPR:
9782       common = 1;
9783       break;
9784
9785     case TRUNC_DIV_EXPR:
9786     case CEIL_DIV_EXPR:
9787     case FLOOR_DIV_EXPR:
9788     case ROUND_DIV_EXPR:
9789     case EXACT_DIV_EXPR:
9790       warn_for_div_by_zero (location, op1);
9791
9792       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9793            || code0 == FIXED_POINT_TYPE
9794            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
9795           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9796               || code1 == FIXED_POINT_TYPE
9797               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
9798         {
9799           enum tree_code tcode0 = code0, tcode1 = code1;
9800
9801           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
9802             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
9803           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
9804             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
9805
9806           if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
9807               || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
9808             resultcode = RDIV_EXPR;
9809           else
9810             /* Although it would be tempting to shorten always here, that
9811                loses on some targets, since the modulo instruction is
9812                undefined if the quotient can't be represented in the
9813                computation mode.  We shorten only if unsigned or if
9814                dividing by something we know != -1.  */
9815             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
9816                        || (TREE_CODE (op1) == INTEGER_CST
9817                            && !integer_all_onesp (op1)));
9818           common = 1;
9819         }
9820       break;
9821
9822     case BIT_AND_EXPR:
9823     case BIT_IOR_EXPR:
9824     case BIT_XOR_EXPR:
9825       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
9826         shorten = -1;
9827       /* Allow vector types which are not floating point types.   */
9828       else if (code0 == VECTOR_TYPE
9829                && code1 == VECTOR_TYPE
9830                && !VECTOR_FLOAT_TYPE_P (type0)
9831                && !VECTOR_FLOAT_TYPE_P (type1))
9832         common = 1;
9833       break;
9834
9835     case TRUNC_MOD_EXPR:
9836     case FLOOR_MOD_EXPR:
9837       warn_for_div_by_zero (location, op1);
9838
9839       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9840           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9841           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE)
9842         common = 1;
9843       else if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
9844         {
9845           /* Although it would be tempting to shorten always here, that loses
9846              on some targets, since the modulo instruction is undefined if the
9847              quotient can't be represented in the computation mode.  We shorten
9848              only if unsigned or if dividing by something we know != -1.  */
9849           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
9850                      || (TREE_CODE (op1) == INTEGER_CST
9851                          && !integer_all_onesp (op1)));
9852           common = 1;
9853         }
9854       break;
9855
9856     case TRUTH_ANDIF_EXPR:
9857     case TRUTH_ORIF_EXPR:
9858     case TRUTH_AND_EXPR:
9859     case TRUTH_OR_EXPR:
9860     case TRUTH_XOR_EXPR:
9861       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
9862            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
9863            || code0 == FIXED_POINT_TYPE)
9864           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
9865               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
9866               || code1 == FIXED_POINT_TYPE))
9867         {
9868           /* Result of these operations is always an int,
9869              but that does not mean the operands should be
9870              converted to ints!  */
9871           result_type = integer_type_node;
9872           op0 = c_common_truthvalue_conversion (location, op0);
9873           op1 = c_common_truthvalue_conversion (location, op1);
9874           converted = 1;
9875           boolean_op = true;
9876         }
9877       if (code == TRUTH_ANDIF_EXPR)
9878         {
9879           int_const_or_overflow = (int_operands
9880                                    && TREE_CODE (orig_op0) == INTEGER_CST
9881                                    && (op0 == truthvalue_false_node
9882                                        || TREE_CODE (orig_op1) == INTEGER_CST));
9883           int_const = (int_const_or_overflow
9884                        && !TREE_OVERFLOW (orig_op0)
9885                        && (op0 == truthvalue_false_node
9886                            || !TREE_OVERFLOW (orig_op1)));
9887         }
9888       else if (code == TRUTH_ORIF_EXPR)
9889         {
9890           int_const_or_overflow = (int_operands
9891                                    && TREE_CODE (orig_op0) == INTEGER_CST
9892                                    && (op0 == truthvalue_true_node
9893                                        || TREE_CODE (orig_op1) == INTEGER_CST));
9894           int_const = (int_const_or_overflow
9895                        && !TREE_OVERFLOW (orig_op0)
9896                        && (op0 == truthvalue_true_node
9897                            || !TREE_OVERFLOW (orig_op1)));
9898         }
9899       break;
9900
9901       /* Shift operations: result has same type as first operand;
9902          always convert second operand to int.
9903          Also set SHORT_SHIFT if shifting rightward.  */
9904
9905     case RSHIFT_EXPR:
9906       if (code0 == VECTOR_TYPE && code1 == INTEGER_TYPE
9907           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE)
9908         {
9909           result_type = type0;
9910           converted = 1;
9911         }
9912       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9913           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9914           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
9915           && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
9916         {
9917           result_type = type0;
9918           converted = 1;
9919         }
9920       else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9921           && code1 == INTEGER_TYPE)
9922         {
9923           if (TREE_CODE (op1) == INTEGER_CST)
9924             {
9925               if (tree_int_cst_sgn (op1) < 0)
9926                 {
9927                   int_const = false;
9928                   if (c_inhibit_evaluation_warnings == 0)
9929                     warning (0, "right shift count is negative");
9930                 }
9931               else
9932                 {
9933                   if (!integer_zerop (op1))
9934                     short_shift = 1;
9935
9936                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9937                     {
9938                       int_const = false;
9939                       if (c_inhibit_evaluation_warnings == 0)
9940                         warning (0, "right shift count >= width of type");
9941                     }
9942                 }
9943             }
9944
9945           /* Use the type of the value to be shifted.  */
9946           result_type = type0;
9947           /* Convert the non vector shift-count to an integer, regardless
9948              of size of value being shifted.  */
9949           if (TREE_CODE (TREE_TYPE (op1)) != VECTOR_TYPE
9950               && TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9951             op1 = convert (integer_type_node, op1);
9952           /* Avoid converting op1 to result_type later.  */
9953           converted = 1;
9954         }
9955       break;
9956
9957     case LSHIFT_EXPR:
9958       if (code0 == VECTOR_TYPE && code1 == INTEGER_TYPE
9959           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE)
9960         {
9961           result_type = type0;
9962           converted = 1;
9963         }
9964       else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9965           && TREE_CODE (TREE_TYPE (type0)) == INTEGER_TYPE
9966           && TREE_CODE (TREE_TYPE (type1)) == INTEGER_TYPE
9967           && TYPE_VECTOR_SUBPARTS (type0) == TYPE_VECTOR_SUBPARTS (type1))
9968         {
9969           result_type = type0;
9970           converted = 1;
9971         }
9972       else if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9973           && code1 == INTEGER_TYPE)
9974         {
9975           if (TREE_CODE (op1) == INTEGER_CST)
9976             {
9977               if (tree_int_cst_sgn (op1) < 0)
9978                 {
9979                   int_const = false;
9980                   if (c_inhibit_evaluation_warnings == 0)
9981                     warning (0, "left shift count is negative");
9982                 }
9983
9984               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9985                 {
9986                   int_const = false;
9987                   if (c_inhibit_evaluation_warnings == 0)
9988                     warning (0, "left shift count >= width of type");
9989                 }
9990             }
9991
9992           /* Use the type of the value to be shifted.  */
9993           result_type = type0;
9994           /* Convert the non vector shift-count to an integer, regardless
9995              of size of value being shifted.  */
9996           if (TREE_CODE (TREE_TYPE (op1)) != VECTOR_TYPE
9997               && TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9998             op1 = convert (integer_type_node, op1);
9999           /* Avoid converting op1 to result_type later.  */
10000           converted = 1;
10001         }
10002       break;
10003
10004     case EQ_EXPR:
10005     case NE_EXPR:
10006       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
10007         {
10008           tree intt;
10009           if (TREE_TYPE (type0) != TREE_TYPE (type1))
10010             {
10011               error_at (location, "comparing vectors with different "
10012                                   "element types");
10013               return error_mark_node;
10014             }
10015
10016           if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))
10017             {
10018               error_at (location, "comparing vectors with different "
10019                                   "number of elements");
10020               return error_mark_node;
10021             }
10022
10023           /* Always construct signed integer vector type.  */
10024           intt = c_common_type_for_size (GET_MODE_BITSIZE
10025                                            (TYPE_MODE (TREE_TYPE (type0))), 0);
10026           result_type = build_opaque_vector_type (intt,
10027                                                   TYPE_VECTOR_SUBPARTS (type0));
10028           converted = 1;
10029           break;
10030         }
10031       if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
10032         warning_at (location,
10033                     OPT_Wfloat_equal,
10034                     "comparing floating point with == or != is unsafe");
10035       /* Result of comparison is always int,
10036          but don't convert the args to int!  */
10037       build_type = integer_type_node;
10038       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
10039            || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
10040           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
10041               || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
10042         short_compare = 1;
10043       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
10044         {
10045           if (TREE_CODE (op0) == ADDR_EXPR
10046               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
10047             {
10048               if (code == EQ_EXPR)
10049                 warning_at (location,
10050                             OPT_Waddress,
10051                             "the comparison will always evaluate as %<false%> "
10052                             "for the address of %qD will never be NULL",
10053                             TREE_OPERAND (op0, 0));
10054               else
10055                 warning_at (location,
10056                             OPT_Waddress,
10057                             "the comparison will always evaluate as %<true%> "
10058                             "for the address of %qD will never be NULL",
10059                             TREE_OPERAND (op0, 0));
10060             }
10061           result_type = type0;
10062         }
10063       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
10064         {
10065           if (TREE_CODE (op1) == ADDR_EXPR
10066               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
10067             {
10068               if (code == EQ_EXPR)
10069                 warning_at (location,
10070                             OPT_Waddress,
10071                             "the comparison will always evaluate as %<false%> "
10072                             "for the address of %qD will never be NULL",
10073                             TREE_OPERAND (op1, 0));
10074               else
10075                 warning_at (location,
10076                             OPT_Waddress,
10077                             "the comparison will always evaluate as %<true%> "
10078                             "for the address of %qD will never be NULL",
10079                             TREE_OPERAND (op1, 0));
10080             }
10081           result_type = type1;
10082         }
10083       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
10084         {
10085           tree tt0 = TREE_TYPE (type0);
10086           tree tt1 = TREE_TYPE (type1);
10087           addr_space_t as0 = TYPE_ADDR_SPACE (tt0);
10088           addr_space_t as1 = TYPE_ADDR_SPACE (tt1);
10089           addr_space_t as_common = ADDR_SPACE_GENERIC;
10090
10091           /* Anything compares with void *.  void * compares with anything.
10092              Otherwise, the targets must be compatible
10093              and both must be object or both incomplete.  */
10094           if (comp_target_types (location, type0, type1))
10095             result_type = common_pointer_type (type0, type1);
10096           else if (!addr_space_superset (as0, as1, &as_common))
10097             {
10098               error_at (location, "comparison of pointers to "
10099                         "disjoint address spaces");
10100               return error_mark_node;
10101             }
10102           else if (VOID_TYPE_P (tt0))
10103             {
10104               if (pedantic && TREE_CODE (tt1) == FUNCTION_TYPE)
10105                 pedwarn (location, OPT_pedantic, "ISO C forbids "
10106                          "comparison of %<void *%> with function pointer");
10107             }
10108           else if (VOID_TYPE_P (tt1))
10109             {
10110               if (pedantic && TREE_CODE (tt0) == FUNCTION_TYPE)
10111                 pedwarn (location, OPT_pedantic, "ISO C forbids "
10112                          "comparison of %<void *%> with function pointer");
10113             }
10114           else
10115             /* Avoid warning about the volatile ObjC EH puts on decls.  */
10116             if (!objc_ok)
10117               pedwarn (location, 0,
10118                        "comparison of distinct pointer types lacks a cast");
10119
10120           if (result_type == NULL_TREE)
10121             {
10122               int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
10123               result_type = build_pointer_type
10124                               (build_qualified_type (void_type_node, qual));
10125             }
10126         }
10127       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
10128         {
10129           result_type = type0;
10130           pedwarn (location, 0, "comparison between pointer and integer");
10131         }
10132       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
10133         {
10134           result_type = type1;
10135           pedwarn (location, 0, "comparison between pointer and integer");
10136         }
10137       break;
10138
10139     case LE_EXPR:
10140     case GE_EXPR:
10141     case LT_EXPR:
10142     case GT_EXPR:
10143       if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE)
10144         {
10145           tree intt;
10146           if (TREE_TYPE (type0) != TREE_TYPE (type1))
10147             {
10148               error_at (location, "comparing vectors with different "
10149                                   "element types");
10150               return error_mark_node;
10151             }
10152
10153           if (TYPE_VECTOR_SUBPARTS (type0) != TYPE_VECTOR_SUBPARTS (type1))
10154             {
10155               error_at (location, "comparing vectors with different "
10156                                   "number of elements");
10157               return error_mark_node;
10158             }
10159
10160           /* Always construct signed integer vector type.  */
10161           intt = c_common_type_for_size (GET_MODE_BITSIZE
10162                                            (TYPE_MODE (TREE_TYPE (type0))), 0);
10163           result_type = build_opaque_vector_type (intt,
10164                                                   TYPE_VECTOR_SUBPARTS (type0));
10165           converted = 1;
10166           break;
10167         }
10168       build_type = integer_type_node;
10169       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
10170            || code0 == FIXED_POINT_TYPE)
10171           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
10172               || code1 == FIXED_POINT_TYPE))
10173         short_compare = 1;
10174       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
10175         {
10176           addr_space_t as0 = TYPE_ADDR_SPACE (TREE_TYPE (type0));
10177           addr_space_t as1 = TYPE_ADDR_SPACE (TREE_TYPE (type1));
10178           addr_space_t as_common;
10179
10180           if (comp_target_types (location, type0, type1))
10181             {
10182               result_type = common_pointer_type (type0, type1);
10183               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
10184                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
10185                 pedwarn (location, 0,
10186                          "comparison of complete and incomplete pointers");
10187               else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
10188                 pedwarn (location, OPT_pedantic, "ISO C forbids "
10189                          "ordered comparisons of pointers to functions");
10190               else if (null_pointer_constant_p (orig_op0)
10191                        || null_pointer_constant_p (orig_op1))
10192                 warning_at (location, OPT_Wextra,
10193                             "ordered comparison of pointer with null pointer");
10194
10195             }
10196           else if (!addr_space_superset (as0, as1, &as_common))
10197             {
10198               error_at (location, "comparison of pointers to "
10199                         "disjoint address spaces");
10200               return error_mark_node;
10201             }
10202           else
10203             {
10204               int qual = ENCODE_QUAL_ADDR_SPACE (as_common);
10205               result_type = build_pointer_type
10206                               (build_qualified_type (void_type_node, qual));
10207               pedwarn (location, 0,
10208                        "comparison of distinct pointer types lacks a cast");
10209             }
10210         }
10211       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
10212         {
10213           result_type = type0;
10214           if (pedantic)
10215             pedwarn (location, OPT_pedantic,
10216                      "ordered comparison of pointer with integer zero");
10217           else if (extra_warnings)
10218             warning_at (location, OPT_Wextra,
10219                         "ordered comparison of pointer with integer zero");
10220         }
10221       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
10222         {
10223           result_type = type1;
10224           if (pedantic)
10225             pedwarn (location, OPT_pedantic,
10226                      "ordered comparison of pointer with integer zero");
10227           else if (extra_warnings)
10228             warning_at (location, OPT_Wextra,
10229                         "ordered comparison of pointer with integer zero");
10230         }
10231       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
10232         {
10233           result_type = type0;
10234           pedwarn (location, 0, "comparison between pointer and integer");
10235         }
10236       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
10237         {
10238           result_type = type1;
10239           pedwarn (location, 0, "comparison between pointer and integer");
10240         }
10241       break;
10242
10243     default:
10244       gcc_unreachable ();
10245     }
10246
10247   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
10248     return error_mark_node;
10249
10250   if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
10251       && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
10252           || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
10253                                                     TREE_TYPE (type1))))
10254     {
10255       binary_op_error (location, code, type0, type1);
10256       return error_mark_node;
10257     }
10258
10259   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
10260        || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
10261       &&
10262       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
10263        || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
10264     {
10265       bool first_complex = (code0 == COMPLEX_TYPE);
10266       bool second_complex = (code1 == COMPLEX_TYPE);
10267       int none_complex = (!first_complex && !second_complex);
10268
10269       if (shorten || common || short_compare)
10270         {
10271           result_type = c_common_type (type0, type1);
10272           do_warn_double_promotion (result_type, type0, type1,
10273                                     "implicit conversion from %qT to %qT "
10274                                     "to match other operand of binary "
10275                                     "expression",
10276                                     location);
10277           if (result_type == error_mark_node)
10278             return error_mark_node;
10279         }
10280
10281       if (first_complex != second_complex
10282           && (code == PLUS_EXPR
10283               || code == MINUS_EXPR
10284               || code == MULT_EXPR
10285               || (code == TRUNC_DIV_EXPR && first_complex))
10286           && TREE_CODE (TREE_TYPE (result_type)) == REAL_TYPE
10287           && flag_signed_zeros)
10288         {
10289           /* An operation on mixed real/complex operands must be
10290              handled specially, but the language-independent code can
10291              more easily optimize the plain complex arithmetic if
10292              -fno-signed-zeros.  */
10293           tree real_type = TREE_TYPE (result_type);
10294           tree real, imag;
10295           if (type0 != orig_type0 || type1 != orig_type1)
10296             {
10297               gcc_assert (may_need_excess_precision && common);
10298               semantic_result_type = c_common_type (orig_type0, orig_type1);
10299             }
10300           if (first_complex)
10301             {
10302               if (TREE_TYPE (op0) != result_type)
10303                 op0 = convert_and_check (result_type, op0);
10304               if (TREE_TYPE (op1) != real_type)
10305                 op1 = convert_and_check (real_type, op1);
10306             }
10307           else
10308             {
10309               if (TREE_TYPE (op0) != real_type)
10310                 op0 = convert_and_check (real_type, op0);
10311               if (TREE_TYPE (op1) != result_type)
10312                 op1 = convert_and_check (result_type, op1);
10313             }
10314           if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
10315             return error_mark_node;
10316           if (first_complex)
10317             {
10318               op0 = c_save_expr (op0);
10319               real = build_unary_op (EXPR_LOCATION (orig_op0), REALPART_EXPR,
10320                                      op0, 1);
10321               imag = build_unary_op (EXPR_LOCATION (orig_op0), IMAGPART_EXPR,
10322                                      op0, 1);
10323               switch (code)
10324                 {
10325                 case MULT_EXPR:
10326                 case TRUNC_DIV_EXPR:
10327                   op1 = c_save_expr (op1);
10328                   imag = build2 (resultcode, real_type, imag, op1);
10329                   /* Fall through.  */
10330                 case PLUS_EXPR:
10331                 case MINUS_EXPR:
10332                   real = build2 (resultcode, real_type, real, op1);
10333                   break;
10334                 default:
10335                   gcc_unreachable();
10336                 }
10337             }
10338           else
10339             {
10340               op1 = c_save_expr (op1);
10341               real = build_unary_op (EXPR_LOCATION (orig_op1), REALPART_EXPR,
10342                                      op1, 1);
10343               imag = build_unary_op (EXPR_LOCATION (orig_op1), IMAGPART_EXPR,
10344                                      op1, 1);
10345               switch (code)
10346                 {
10347                 case MULT_EXPR:
10348                   op0 = c_save_expr (op0);
10349                   imag = build2 (resultcode, real_type, op0, imag);
10350                   /* Fall through.  */
10351                 case PLUS_EXPR:
10352                   real = build2 (resultcode, real_type, op0, real);
10353                   break;
10354                 case MINUS_EXPR:
10355                   real = build2 (resultcode, real_type, op0, real);
10356                   imag = build1 (NEGATE_EXPR, real_type, imag);
10357                   break;
10358                 default:
10359                   gcc_unreachable();
10360                 }
10361             }
10362           ret = build2 (COMPLEX_EXPR, result_type, real, imag);
10363           goto return_build_binary_op;
10364         }
10365
10366       /* For certain operations (which identify themselves by shorten != 0)
10367          if both args were extended from the same smaller type,
10368          do the arithmetic in that type and then extend.
10369
10370          shorten !=0 and !=1 indicates a bitwise operation.
10371          For them, this optimization is safe only if
10372          both args are zero-extended or both are sign-extended.
10373          Otherwise, we might change the result.
10374          Eg, (short)-1 | (unsigned short)-1 is (int)-1
10375          but calculated in (unsigned short) it would be (unsigned short)-1.  */
10376
10377       if (shorten && none_complex)
10378         {
10379           final_type = result_type;
10380           result_type = shorten_binary_op (result_type, op0, op1,
10381                                            shorten == -1);
10382         }
10383
10384       /* Shifts can be shortened if shifting right.  */
10385
10386       if (short_shift)
10387         {
10388           int unsigned_arg;
10389           tree arg0 = get_narrower (op0, &unsigned_arg);
10390
10391           final_type = result_type;
10392
10393           if (arg0 == op0 && final_type == TREE_TYPE (op0))
10394             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
10395
10396           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
10397               && tree_int_cst_sgn (op1) > 0
10398               /* We can shorten only if the shift count is less than the
10399                  number of bits in the smaller type size.  */
10400               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
10401               /* We cannot drop an unsigned shift after sign-extension.  */
10402               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
10403             {
10404               /* Do an unsigned shift if the operand was zero-extended.  */
10405               result_type
10406                 = c_common_signed_or_unsigned_type (unsigned_arg,
10407                                                     TREE_TYPE (arg0));
10408               /* Convert value-to-be-shifted to that type.  */
10409               if (TREE_TYPE (op0) != result_type)
10410                 op0 = convert (result_type, op0);
10411               converted = 1;
10412             }
10413         }
10414
10415       /* Comparison operations are shortened too but differently.
10416          They identify themselves by setting short_compare = 1.  */
10417
10418       if (short_compare)
10419         {
10420           /* Don't write &op0, etc., because that would prevent op0
10421              from being kept in a register.
10422              Instead, make copies of the our local variables and
10423              pass the copies by reference, then copy them back afterward.  */
10424           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
10425           enum tree_code xresultcode = resultcode;
10426           tree val
10427             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
10428
10429           if (val != 0)
10430             {
10431               ret = val;
10432               goto return_build_binary_op;
10433             }
10434
10435           op0 = xop0, op1 = xop1;
10436           converted = 1;
10437           resultcode = xresultcode;
10438
10439           if (c_inhibit_evaluation_warnings == 0)
10440             {
10441               bool op0_maybe_const = true;
10442               bool op1_maybe_const = true;
10443               tree orig_op0_folded, orig_op1_folded;
10444
10445               if (in_late_binary_op)
10446                 {
10447                   orig_op0_folded = orig_op0;
10448                   orig_op1_folded = orig_op1;
10449                 }
10450               else
10451                 {
10452                   /* Fold for the sake of possible warnings, as in
10453                      build_conditional_expr.  This requires the
10454                      "original" values to be folded, not just op0 and
10455                      op1.  */
10456                   c_inhibit_evaluation_warnings++;
10457                   op0 = c_fully_fold (op0, require_constant_value,
10458                                       &op0_maybe_const);
10459                   op1 = c_fully_fold (op1, require_constant_value,
10460                                       &op1_maybe_const);
10461                   c_inhibit_evaluation_warnings--;
10462                   orig_op0_folded = c_fully_fold (orig_op0,
10463                                                   require_constant_value,
10464                                                   NULL);
10465                   orig_op1_folded = c_fully_fold (orig_op1,
10466                                                   require_constant_value,
10467                                                   NULL);
10468                 }
10469
10470               if (warn_sign_compare)
10471                 warn_for_sign_compare (location, orig_op0_folded,
10472                                        orig_op1_folded, op0, op1,
10473                                        result_type, resultcode);
10474               if (!in_late_binary_op && !int_operands)
10475                 {
10476                   if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
10477                     op0 = c_wrap_maybe_const (op0, !op0_maybe_const);
10478                   if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
10479                     op1 = c_wrap_maybe_const (op1, !op1_maybe_const);
10480                 }
10481             }
10482         }
10483     }
10484
10485   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
10486      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
10487      Then the expression will be built.
10488      It will be given type FINAL_TYPE if that is nonzero;
10489      otherwise, it will be given type RESULT_TYPE.  */
10490
10491   if (!result_type)
10492     {
10493       binary_op_error (location, code, TREE_TYPE (op0), TREE_TYPE (op1));
10494       return error_mark_node;
10495     }
10496
10497   if (build_type == NULL_TREE)
10498     {
10499       build_type = result_type;
10500       if ((type0 != orig_type0 || type1 != orig_type1)
10501           && !boolean_op)
10502         {
10503           gcc_assert (may_need_excess_precision && common);
10504           semantic_result_type = c_common_type (orig_type0, orig_type1);
10505         }
10506     }
10507
10508   if (!converted)
10509     {
10510       op0 = ep_convert_and_check (result_type, op0, semantic_result_type);
10511       op1 = ep_convert_and_check (result_type, op1, semantic_result_type);
10512
10513       /* This can happen if one operand has a vector type, and the other
10514          has a different type.  */
10515       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
10516         return error_mark_node;
10517     }
10518
10519   /* Treat expressions in initializers specially as they can't trap.  */
10520   if (int_const_or_overflow)
10521     ret = (require_constant_value
10522            ? fold_build2_initializer_loc (location, resultcode, build_type,
10523                                           op0, op1)
10524            : fold_build2_loc (location, resultcode, build_type, op0, op1));
10525   else
10526     ret = build2 (resultcode, build_type, op0, op1);
10527   if (final_type != 0)
10528     ret = convert (final_type, ret);
10529
10530  return_build_binary_op:
10531   gcc_assert (ret != error_mark_node);
10532   if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
10533     ret = (int_operands
10534            ? note_integer_operands (ret)
10535            : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
10536   else if (TREE_CODE (ret) != INTEGER_CST && int_operands
10537            && !in_late_binary_op)
10538     ret = note_integer_operands (ret);
10539   if (semantic_result_type)
10540     ret = build1 (EXCESS_PRECISION_EXPR, semantic_result_type, ret);
10541   protected_set_expr_location (ret, location);
10542   return ret;
10543 }
10544
10545
10546 /* Convert EXPR to be a truth-value, validating its type for this
10547    purpose.  LOCATION is the source location for the expression.  */
10548
10549 tree
10550 c_objc_common_truthvalue_conversion (location_t location, tree expr)
10551 {
10552   bool int_const, int_operands;
10553
10554   switch (TREE_CODE (TREE_TYPE (expr)))
10555     {
10556     case ARRAY_TYPE:
10557       error_at (location, "used array that cannot be converted to pointer where scalar is required");
10558       return error_mark_node;
10559
10560     case RECORD_TYPE:
10561       error_at (location, "used struct type value where scalar is required");
10562       return error_mark_node;
10563
10564     case UNION_TYPE:
10565       error_at (location, "used union type value where scalar is required");
10566       return error_mark_node;
10567
10568     case VOID_TYPE:
10569       error_at (location, "void value not ignored as it ought to be");
10570       return error_mark_node;
10571
10572     case FUNCTION_TYPE:
10573       gcc_unreachable ();
10574
10575     case VECTOR_TYPE:
10576       error_at (location, "used vector type where scalar is required");
10577       return error_mark_node;
10578
10579     default:
10580       break;
10581     }
10582
10583   int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
10584   int_operands = EXPR_INT_CONST_OPERANDS (expr);
10585   if (int_operands)
10586     expr = remove_c_maybe_const_expr (expr);
10587
10588   /* ??? Should we also give an error for vectors rather than leaving
10589      those to give errors later?  */
10590   expr = c_common_truthvalue_conversion (location, expr);
10591
10592   if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
10593     {
10594       if (TREE_OVERFLOW (expr))
10595         return expr;
10596       else
10597         return note_integer_operands (expr);
10598     }
10599   if (TREE_CODE (expr) == INTEGER_CST && !int_const)
10600     return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
10601   return expr;
10602 }
10603 \f
10604
10605 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
10606    required.  */
10607
10608 tree
10609 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
10610 {
10611   if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
10612     {
10613       tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
10614       /* Executing a compound literal inside a function reinitializes
10615          it.  */
10616       if (!TREE_STATIC (decl))
10617         *se = true;
10618       return decl;
10619     }
10620   else
10621     return expr;
10622 }
10623 \f
10624 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
10625
10626 tree
10627 c_begin_omp_parallel (void)
10628 {
10629   tree block;
10630
10631   keep_next_level ();
10632   block = c_begin_compound_stmt (true);
10633
10634   return block;
10635 }
10636
10637 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound
10638    statement.  LOC is the location of the OMP_PARALLEL.  */
10639
10640 tree
10641 c_finish_omp_parallel (location_t loc, tree clauses, tree block)
10642 {
10643   tree stmt;
10644
10645   block = c_end_compound_stmt (loc, block, true);
10646
10647   stmt = make_node (OMP_PARALLEL);
10648   TREE_TYPE (stmt) = void_type_node;
10649   OMP_PARALLEL_CLAUSES (stmt) = clauses;
10650   OMP_PARALLEL_BODY (stmt) = block;
10651   SET_EXPR_LOCATION (stmt, loc);
10652
10653   return add_stmt (stmt);
10654 }
10655
10656 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
10657
10658 tree
10659 c_begin_omp_task (void)
10660 {
10661   tree block;
10662
10663   keep_next_level ();
10664   block = c_begin_compound_stmt (true);
10665
10666   return block;
10667 }
10668
10669 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound
10670    statement.  LOC is the location of the #pragma.  */
10671
10672 tree
10673 c_finish_omp_task (location_t loc, tree clauses, tree block)
10674 {
10675   tree stmt;
10676
10677   block = c_end_compound_stmt (loc, block, true);
10678
10679   stmt = make_node (OMP_TASK);
10680   TREE_TYPE (stmt) = void_type_node;
10681   OMP_TASK_CLAUSES (stmt) = clauses;
10682   OMP_TASK_BODY (stmt) = block;
10683   SET_EXPR_LOCATION (stmt, loc);
10684
10685   return add_stmt (stmt);
10686 }
10687
10688 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
10689    Remove any elements from the list that are invalid.  */
10690
10691 tree
10692 c_finish_omp_clauses (tree clauses)
10693 {
10694   bitmap_head generic_head, firstprivate_head, lastprivate_head;
10695   tree c, t, *pc = &clauses;
10696   const char *name;
10697
10698   bitmap_obstack_initialize (NULL);
10699   bitmap_initialize (&generic_head, &bitmap_default_obstack);
10700   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
10701   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
10702
10703   for (pc = &clauses, c = clauses; c ; c = *pc)
10704     {
10705       bool remove = false;
10706       bool need_complete = false;
10707       bool need_implicitly_determined = false;
10708
10709       switch (OMP_CLAUSE_CODE (c))
10710         {
10711         case OMP_CLAUSE_SHARED:
10712           name = "shared";
10713           need_implicitly_determined = true;
10714           goto check_dup_generic;
10715
10716         case OMP_CLAUSE_PRIVATE:
10717           name = "private";
10718           need_complete = true;
10719           need_implicitly_determined = true;
10720           goto check_dup_generic;
10721
10722         case OMP_CLAUSE_REDUCTION:
10723           name = "reduction";
10724           need_implicitly_determined = true;
10725           t = OMP_CLAUSE_DECL (c);
10726           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
10727               || POINTER_TYPE_P (TREE_TYPE (t)))
10728             {
10729               error_at (OMP_CLAUSE_LOCATION (c),
10730                         "%qE has invalid type for %<reduction%>", t);
10731               remove = true;
10732             }
10733           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
10734             {
10735               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
10736               const char *r_name = NULL;
10737
10738               switch (r_code)
10739                 {
10740                 case PLUS_EXPR:
10741                 case MULT_EXPR:
10742                 case MINUS_EXPR:
10743                 case MIN_EXPR:
10744                 case MAX_EXPR:
10745                   break;
10746                 case BIT_AND_EXPR:
10747                   r_name = "&";
10748                   break;
10749                 case BIT_XOR_EXPR:
10750                   r_name = "^";
10751                   break;
10752                 case BIT_IOR_EXPR:
10753                   r_name = "|";
10754                   break;
10755                 case TRUTH_ANDIF_EXPR:
10756                   r_name = "&&";
10757                   break;
10758                 case TRUTH_ORIF_EXPR:
10759                   r_name = "||";
10760                   break;
10761                 default:
10762                   gcc_unreachable ();
10763                 }
10764               if (r_name)
10765                 {
10766                   error_at (OMP_CLAUSE_LOCATION (c),
10767                             "%qE has invalid type for %<reduction(%s)%>",
10768                             t, r_name);
10769                   remove = true;
10770                 }
10771             }
10772           goto check_dup_generic;
10773
10774         case OMP_CLAUSE_COPYPRIVATE:
10775           name = "copyprivate";
10776           goto check_dup_generic;
10777
10778         case OMP_CLAUSE_COPYIN:
10779           name = "copyin";
10780           t = OMP_CLAUSE_DECL (c);
10781           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
10782             {
10783               error_at (OMP_CLAUSE_LOCATION (c),
10784                         "%qE must be %<threadprivate%> for %<copyin%>", t);
10785               remove = true;
10786             }
10787           goto check_dup_generic;
10788
10789         check_dup_generic:
10790           t = OMP_CLAUSE_DECL (c);
10791           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10792             {
10793               error_at (OMP_CLAUSE_LOCATION (c),
10794                         "%qE is not a variable in clause %qs", t, name);
10795               remove = true;
10796             }
10797           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10798                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
10799                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
10800             {
10801               error_at (OMP_CLAUSE_LOCATION (c),
10802                         "%qE appears more than once in data clauses", t);
10803               remove = true;
10804             }
10805           else
10806             bitmap_set_bit (&generic_head, DECL_UID (t));
10807           break;
10808
10809         case OMP_CLAUSE_FIRSTPRIVATE:
10810           name = "firstprivate";
10811           t = OMP_CLAUSE_DECL (c);
10812           need_complete = true;
10813           need_implicitly_determined = true;
10814           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10815             {
10816               error_at (OMP_CLAUSE_LOCATION (c),
10817                         "%qE is not a variable in clause %<firstprivate%>", t);
10818               remove = true;
10819             }
10820           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10821                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
10822             {
10823               error_at (OMP_CLAUSE_LOCATION (c),
10824                         "%qE appears more than once in data clauses", t);
10825               remove = true;
10826             }
10827           else
10828             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
10829           break;
10830
10831         case OMP_CLAUSE_LASTPRIVATE:
10832           name = "lastprivate";
10833           t = OMP_CLAUSE_DECL (c);
10834           need_complete = true;
10835           need_implicitly_determined = true;
10836           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
10837             {
10838               error_at (OMP_CLAUSE_LOCATION (c),
10839                         "%qE is not a variable in clause %<lastprivate%>", t);
10840               remove = true;
10841             }
10842           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
10843                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
10844             {
10845               error_at (OMP_CLAUSE_LOCATION (c),
10846                      "%qE appears more than once in data clauses", t);
10847               remove = true;
10848             }
10849           else
10850             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
10851           break;
10852
10853         case OMP_CLAUSE_IF:
10854         case OMP_CLAUSE_NUM_THREADS:
10855         case OMP_CLAUSE_SCHEDULE:
10856         case OMP_CLAUSE_NOWAIT:
10857         case OMP_CLAUSE_ORDERED:
10858         case OMP_CLAUSE_DEFAULT:
10859         case OMP_CLAUSE_UNTIED:
10860         case OMP_CLAUSE_COLLAPSE:
10861         case OMP_CLAUSE_FINAL:
10862         case OMP_CLAUSE_MERGEABLE:
10863           pc = &OMP_CLAUSE_CHAIN (c);
10864           continue;
10865
10866         default:
10867           gcc_unreachable ();
10868         }
10869
10870       if (!remove)
10871         {
10872           t = OMP_CLAUSE_DECL (c);
10873
10874           if (need_complete)
10875             {
10876               t = require_complete_type (t);
10877               if (t == error_mark_node)
10878                 remove = true;
10879             }
10880
10881           if (need_implicitly_determined)
10882             {
10883               const char *share_name = NULL;
10884
10885               if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
10886                 share_name = "threadprivate";
10887               else switch (c_omp_predetermined_sharing (t))
10888                 {
10889                 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
10890                   break;
10891                 case OMP_CLAUSE_DEFAULT_SHARED:
10892                   /* const vars may be specified in firstprivate clause.  */
10893                   if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_FIRSTPRIVATE
10894                       && TREE_READONLY (t))
10895                     break;
10896                   share_name = "shared";
10897                   break;
10898                 case OMP_CLAUSE_DEFAULT_PRIVATE:
10899                   share_name = "private";
10900                   break;
10901                 default:
10902                   gcc_unreachable ();
10903                 }
10904               if (share_name)
10905                 {
10906                   error_at (OMP_CLAUSE_LOCATION (c),
10907                             "%qE is predetermined %qs for %qs",
10908                             t, share_name, name);
10909                   remove = true;
10910                 }
10911             }
10912         }
10913
10914       if (remove)
10915         *pc = OMP_CLAUSE_CHAIN (c);
10916       else
10917         pc = &OMP_CLAUSE_CHAIN (c);
10918     }
10919
10920   bitmap_obstack_release (NULL);
10921   return clauses;
10922 }
10923
10924 /* Make a variant type in the proper way for C/C++, propagating qualifiers
10925    down to the element type of an array.  */
10926
10927 tree
10928 c_build_qualified_type (tree type, int type_quals)
10929 {
10930   if (type == error_mark_node)
10931     return type;
10932
10933   if (TREE_CODE (type) == ARRAY_TYPE)
10934     {
10935       tree t;
10936       tree element_type = c_build_qualified_type (TREE_TYPE (type),
10937                                                   type_quals);
10938
10939       /* See if we already have an identically qualified type.  */
10940       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
10941         {
10942           if (TYPE_QUALS (strip_array_types (t)) == type_quals
10943               && TYPE_NAME (t) == TYPE_NAME (type)
10944               && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
10945               && attribute_list_equal (TYPE_ATTRIBUTES (t),
10946                                        TYPE_ATTRIBUTES (type)))
10947             break;
10948         }
10949       if (!t)
10950         {
10951           tree domain = TYPE_DOMAIN (type);
10952
10953           t = build_variant_type_copy (type);
10954           TREE_TYPE (t) = element_type;
10955
10956           if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
10957               || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
10958             SET_TYPE_STRUCTURAL_EQUALITY (t);
10959           else if (TYPE_CANONICAL (element_type) != element_type
10960                    || (domain && TYPE_CANONICAL (domain) != domain))
10961             {
10962               tree unqualified_canon
10963                 = build_array_type (TYPE_CANONICAL (element_type),
10964                                     domain? TYPE_CANONICAL (domain)
10965                                           : NULL_TREE);
10966               TYPE_CANONICAL (t)
10967                 = c_build_qualified_type (unqualified_canon, type_quals);
10968             }
10969           else
10970             TYPE_CANONICAL (t) = t;
10971         }
10972       return t;
10973     }
10974
10975   /* A restrict-qualified pointer type must be a pointer to object or
10976      incomplete type.  Note that the use of POINTER_TYPE_P also allows
10977      REFERENCE_TYPEs, which is appropriate for C++.  */
10978   if ((type_quals & TYPE_QUAL_RESTRICT)
10979       && (!POINTER_TYPE_P (type)
10980           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
10981     {
10982       error ("invalid use of %<restrict%>");
10983       type_quals &= ~TYPE_QUAL_RESTRICT;
10984     }
10985
10986   return build_qualified_type (type, type_quals);
10987 }
10988
10989 /* Build a VA_ARG_EXPR for the C parser.  */
10990
10991 tree
10992 c_build_va_arg (location_t loc, tree expr, tree type)
10993 {
10994   if (warn_cxx_compat && TREE_CODE (type) == ENUMERAL_TYPE)
10995     warning_at (loc, OPT_Wc___compat,
10996                 "C++ requires promoted type, not enum type, in %<va_arg%>");
10997   return build_va_arg (loc, expr, type);
10998 }