gcc/c-typeck.c

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