gcc/c-typeck.c

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