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