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