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                && (constructor_max_index == 0
7292                    || tree_int_cst_lt (constructor_max_index,
7293                                        constructor_index)))
7294         process_init_element (pop_init_level (1), true);
7295       else
7296         break;
7297     }
7298
7299   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
7300   if (constructor_range_stack)
7301     {
7302       /* If value is a compound literal and we'll be just using its
7303          content, don't put it into a SAVE_EXPR.  */
7304       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
7305           || !require_constant_value
7306           || flag_isoc99)
7307         {
7308           tree semantic_type = NULL_TREE;
7309           if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
7310             {
7311               semantic_type = TREE_TYPE (value.value);
7312               value.value = TREE_OPERAND (value.value, 0);
7313             }
7314           value.value = c_save_expr (value.value);
7315           if (semantic_type)
7316             value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
7317                                   value.value);
7318         }
7319     }
7320
7321   while (1)
7322     {
7323       if (TREE_CODE (constructor_type) == RECORD_TYPE)
7324         {
7325           tree fieldtype;
7326           enum tree_code fieldcode;
7327
7328           if (constructor_fields == 0)
7329             {
7330               pedwarn_init (input_location, 0,
7331                             "excess elements in struct initializer");
7332               break;
7333             }
7334
7335           fieldtype = TREE_TYPE (constructor_fields);
7336           if (fieldtype != error_mark_node)
7337             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
7338           fieldcode = TREE_CODE (fieldtype);
7339
7340           /* Error for non-static initialization of a flexible array member.  */
7341           if (fieldcode == ARRAY_TYPE
7342               && !require_constant_value
7343               && TYPE_SIZE (fieldtype) == NULL_TREE
7344               && TREE_CHAIN (constructor_fields) == NULL_TREE)
7345             {
7346               error_init ("non-static initialization of a flexible array member");
7347               break;
7348             }
7349
7350           /* Accept a string constant to initialize a subarray.  */
7351           if (value.value != 0
7352               && fieldcode == ARRAY_TYPE
7353               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
7354               && string_flag)
7355             value.value = orig_value;
7356           /* Otherwise, if we have come to a subaggregate,
7357              and we don't have an element of its type, push into it.  */
7358           else if (value.value != 0
7359                    && value.value != error_mark_node
7360                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
7361                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
7362                        || fieldcode == UNION_TYPE))
7363             {
7364               push_init_level (1);
7365               continue;
7366             }
7367
7368           if (value.value)
7369             {
7370               push_member_name (constructor_fields);
7371               output_init_element (value.value, value.original_type,
7372                                    strict_string, fieldtype,
7373                                    constructor_fields, 1, implicit);
7374               RESTORE_SPELLING_DEPTH (constructor_depth);
7375             }
7376           else
7377             /* Do the bookkeeping for an element that was
7378                directly output as a constructor.  */
7379             {
7380               /* For a record, keep track of end position of last field.  */
7381               if (DECL_SIZE (constructor_fields))
7382                 constructor_bit_index
7383                   = size_binop (PLUS_EXPR,
7384                                 bit_position (constructor_fields),
7385                                 DECL_SIZE (constructor_fields));
7386
7387               /* If the current field was the first one not yet written out,
7388                  it isn't now, so update.  */
7389               if (constructor_unfilled_fields == constructor_fields)
7390                 {
7391                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
7392                   /* Skip any nameless bit fields.  */
7393                   while (constructor_unfilled_fields != 0
7394                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7395                          && DECL_NAME (constructor_unfilled_fields) == 0)
7396                     constructor_unfilled_fields =
7397                       TREE_CHAIN (constructor_unfilled_fields);
7398                 }
7399             }
7400
7401           constructor_fields = TREE_CHAIN (constructor_fields);
7402           /* Skip any nameless bit fields at the beginning.  */
7403           while (constructor_fields != 0
7404                  && DECL_C_BIT_FIELD (constructor_fields)
7405                  && DECL_NAME (constructor_fields) == 0)
7406             constructor_fields = TREE_CHAIN (constructor_fields);
7407         }
7408       else if (TREE_CODE (constructor_type) == UNION_TYPE)
7409         {
7410           tree fieldtype;
7411           enum tree_code fieldcode;
7412
7413           if (constructor_fields == 0)
7414             {
7415               pedwarn_init (input_location, 0,
7416                             "excess elements in union initializer");
7417               break;
7418             }
7419
7420           fieldtype = TREE_TYPE (constructor_fields);
7421           if (fieldtype != error_mark_node)
7422             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
7423           fieldcode = TREE_CODE (fieldtype);
7424
7425           /* Warn that traditional C rejects initialization of unions.
7426              We skip the warning if the value is zero.  This is done
7427              under the assumption that the zero initializer in user
7428              code appears conditioned on e.g. __STDC__ to avoid
7429              "missing initializer" warnings and relies on default
7430              initialization to zero in the traditional C case.
7431              We also skip the warning if the initializer is designated,
7432              again on the assumption that this must be conditional on
7433              __STDC__ anyway (and we've already complained about the
7434              member-designator already).  */
7435           if (!in_system_header && !constructor_designated
7436               && !(value.value && (integer_zerop (value.value)
7437                                    || real_zerop (value.value))))
7438             warning (OPT_Wtraditional, "traditional C rejects initialization "
7439                      "of unions");
7440
7441           /* Accept a string constant to initialize a subarray.  */
7442           if (value.value != 0
7443               && fieldcode == ARRAY_TYPE
7444               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
7445               && string_flag)
7446             value.value = orig_value;
7447           /* Otherwise, if we have come to a subaggregate,
7448              and we don't have an element of its type, push into it.  */
7449           else if (value.value != 0
7450                    && value.value != error_mark_node
7451                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
7452                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
7453                        || fieldcode == UNION_TYPE))
7454             {
7455               push_init_level (1);
7456               continue;
7457             }
7458
7459           if (value.value)
7460             {
7461               push_member_name (constructor_fields);
7462               output_init_element (value.value, value.original_type,
7463                                    strict_string, fieldtype,
7464                                    constructor_fields, 1, implicit);
7465               RESTORE_SPELLING_DEPTH (constructor_depth);
7466             }
7467           else
7468             /* Do the bookkeeping for an element that was
7469                directly output as a constructor.  */
7470             {
7471               constructor_bit_index = DECL_SIZE (constructor_fields);
7472               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
7473             }
7474
7475           constructor_fields = 0;
7476         }
7477       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7478         {
7479           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7480           enum tree_code eltcode = TREE_CODE (elttype);
7481
7482           /* Accept a string constant to initialize a subarray.  */
7483           if (value.value != 0
7484               && eltcode == ARRAY_TYPE
7485               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
7486               && string_flag)
7487             value.value = orig_value;
7488           /* Otherwise, if we have come to a subaggregate,
7489              and we don't have an element of its type, push into it.  */
7490           else if (value.value != 0
7491                    && value.value != error_mark_node
7492                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
7493                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
7494                        || eltcode == UNION_TYPE))
7495             {
7496               push_init_level (1);
7497               continue;
7498             }
7499
7500           if (constructor_max_index != 0
7501               && (tree_int_cst_lt (constructor_max_index, constructor_index)
7502                   || integer_all_onesp (constructor_max_index)))
7503             {
7504               pedwarn_init (input_location, 0,
7505                             "excess elements in array initializer");
7506               break;
7507             }
7508
7509           /* Now output the actual element.  */
7510           if (value.value)
7511             {
7512               push_array_bounds (tree_low_cst (constructor_index, 1));
7513               output_init_element (value.value, value.original_type,
7514                                    strict_string, elttype,
7515                                    constructor_index, 1, implicit);
7516               RESTORE_SPELLING_DEPTH (constructor_depth);
7517             }
7518
7519           constructor_index
7520             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
7521
7522           if (!value.value)
7523             /* If we are doing the bookkeeping for an element that was
7524                directly output as a constructor, we must update
7525                constructor_unfilled_index.  */
7526             constructor_unfilled_index = constructor_index;
7527         }
7528       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
7529         {
7530           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7531
7532          /* Do a basic check of initializer size.  Note that vectors
7533             always have a fixed size derived from their type.  */
7534           if (tree_int_cst_lt (constructor_max_index, constructor_index))
7535             {
7536               pedwarn_init (input_location, 0,
7537                             "excess elements in vector initializer");
7538               break;
7539             }
7540
7541           /* Now output the actual element.  */
7542           if (value.value)
7543             output_init_element (value.value, value.original_type,
7544                                  strict_string, elttype,
7545                                  constructor_index, 1, implicit);
7546
7547           constructor_index
7548             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
7549
7550           if (!value.value)
7551             /* If we are doing the bookkeeping for an element that was
7552                directly output as a constructor, we must update
7553                constructor_unfilled_index.  */
7554             constructor_unfilled_index = constructor_index;
7555         }
7556
7557       /* Handle the sole element allowed in a braced initializer
7558          for a scalar variable.  */
7559       else if (constructor_type != error_mark_node
7560                && constructor_fields == 0)
7561         {
7562           pedwarn_init (input_location, 0,
7563                         "excess elements in scalar initializer");
7564           break;
7565         }
7566       else
7567         {
7568           if (value.value)
7569             output_init_element (value.value, value.original_type,
7570                                  strict_string, constructor_type,
7571                                  NULL_TREE, 1, implicit);
7572           constructor_fields = 0;
7573         }
7574
7575       /* Handle range initializers either at this level or anywhere higher
7576          in the designator stack.  */
7577       if (constructor_range_stack)
7578         {
7579           struct constructor_range_stack *p, *range_stack;
7580           int finish = 0;
7581
7582           range_stack = constructor_range_stack;
7583           constructor_range_stack = 0;
7584           while (constructor_stack != range_stack->stack)
7585             {
7586               gcc_assert (constructor_stack->implicit);
7587               process_init_element (pop_init_level (1), true);
7588             }
7589           for (p = range_stack;
7590                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
7591                p = p->prev)
7592             {
7593               gcc_assert (constructor_stack->implicit);
7594               process_init_element (pop_init_level (1), true);
7595             }
7596
7597           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
7598           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
7599             finish = 1;
7600
7601           while (1)
7602             {
7603               constructor_index = p->index;
7604               constructor_fields = p->fields;
7605               if (finish && p->range_end && p->index == p->range_start)
7606                 {
7607                   finish = 0;
7608                   p->prev = 0;
7609                 }
7610               p = p->next;
7611               if (!p)
7612                 break;
7613               push_init_level (2);
7614               p->stack = constructor_stack;
7615               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
7616                 p->index = p->range_start;
7617             }
7618
7619           if (!finish)
7620             constructor_range_stack = range_stack;
7621           continue;
7622         }
7623
7624       break;
7625     }
7626
7627   constructor_range_stack = 0;
7628 }
7629 \f
7630 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
7631    (guaranteed to be 'volatile' or null) and ARGS (represented using
7632    an ASM_EXPR node).  */
7633 tree
7634 build_asm_stmt (tree cv_qualifier, tree args)
7635 {
7636   if (!ASM_VOLATILE_P (args) && cv_qualifier)
7637     ASM_VOLATILE_P (args) = 1;
7638   return add_stmt (args);
7639 }
7640
7641 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
7642    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
7643    SIMPLE indicates whether there was anything at all after the
7644    string in the asm expression -- asm("blah") and asm("blah" : )
7645    are subtly different.  We use a ASM_EXPR node to represent this.  */
7646 tree
7647 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
7648                 bool simple)
7649 {
7650   tree tail;
7651   tree args;
7652   int i;
7653   const char *constraint;
7654   const char **oconstraints;
7655   bool allows_mem, allows_reg, is_inout;
7656   int ninputs, noutputs;
7657
7658   ninputs = list_length (inputs);
7659   noutputs = list_length (outputs);
7660   oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
7661
7662   string = resolve_asm_operand_names (string, outputs, inputs);
7663
7664   /* Remove output conversions that change the type but not the mode.  */
7665   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
7666     {
7667       tree output = TREE_VALUE (tail);
7668
7669       /* ??? Really, this should not be here.  Users should be using a
7670          proper lvalue, dammit.  But there's a long history of using casts
7671          in the output operands.  In cases like longlong.h, this becomes a
7672          primitive form of typechecking -- if the cast can be removed, then
7673          the output operand had a type of the proper width; otherwise we'll
7674          get an error.  Gross, but ...  */
7675       STRIP_NOPS (output);
7676
7677       if (!lvalue_or_else (output, lv_asm))
7678         output = error_mark_node;
7679
7680       if (output != error_mark_node
7681           && (TREE_READONLY (output)
7682               || TYPE_READONLY (TREE_TYPE (output))
7683               || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
7684                    || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
7685                   && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
7686         readonly_error (output, lv_asm);
7687
7688       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
7689       oconstraints[i] = constraint;
7690
7691       if (parse_output_constraint (&constraint, i, ninputs, noutputs,
7692                                    &allows_mem, &allows_reg, &is_inout))
7693         {
7694           /* If the operand is going to end up in memory,
7695              mark it addressable.  */
7696           if (!allows_reg && !c_mark_addressable (output))
7697             output = error_mark_node;
7698         }
7699       else
7700         output = error_mark_node;
7701
7702       TREE_VALUE (tail) = output;
7703     }
7704
7705   for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
7706     {
7707       tree input;
7708
7709       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
7710       input = TREE_VALUE (tail);
7711
7712       if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
7713                                   oconstraints, &allows_mem, &allows_reg))
7714         {
7715           /* If the operand is going to end up in memory,
7716              mark it addressable.  */
7717           if (!allows_reg && allows_mem)
7718             {
7719               /* Strip the nops as we allow this case.  FIXME, this really
7720                  should be rejected or made deprecated.  */
7721               STRIP_NOPS (input);
7722               if (!c_mark_addressable (input))
7723                 input = error_mark_node;
7724           }
7725         }
7726       else
7727         input = error_mark_node;
7728
7729       TREE_VALUE (tail) = input;
7730     }
7731
7732   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
7733
7734   /* asm statements without outputs, including simple ones, are treated
7735      as volatile.  */
7736   ASM_INPUT_P (args) = simple;
7737   ASM_VOLATILE_P (args) = (noutputs == 0);
7738
7739   return args;
7740 }
7741 \f
7742 /* Generate a goto statement to LABEL.  */
7743
7744 tree
7745 c_finish_goto_label (tree label)
7746 {
7747   tree decl = lookup_label (label);
7748   if (!decl)
7749     return NULL_TREE;
7750
7751   if (C_DECL_UNJUMPABLE_STMT_EXPR (decl))
7752     {
7753       error ("jump into statement expression");
7754       return NULL_TREE;
7755     }
7756
7757   if (C_DECL_UNJUMPABLE_VM (decl))
7758     {
7759       error ("jump into scope of identifier with variably modified type");
7760       return NULL_TREE;
7761     }
7762
7763   if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl))
7764     {
7765       /* No jump from outside this statement expression context, so
7766          record that there is a jump from within this context.  */
7767       struct c_label_list *nlist;
7768       nlist = XOBNEW (&parser_obstack, struct c_label_list);
7769       nlist->next = label_context_stack_se->labels_used;
7770       nlist->label = decl;
7771       label_context_stack_se->labels_used = nlist;
7772     }
7773
7774   if (!C_DECL_UNDEFINABLE_VM (decl))
7775     {
7776       /* No jump from outside this context context of identifiers with
7777          variably modified type, so record that there is a jump from
7778          within this context.  */
7779       struct c_label_list *nlist;
7780       nlist = XOBNEW (&parser_obstack, struct c_label_list);
7781       nlist->next = label_context_stack_vm->labels_used;
7782       nlist->label = decl;
7783       label_context_stack_vm->labels_used = nlist;
7784     }
7785
7786   TREE_USED (decl) = 1;
7787   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
7788 }
7789
7790 /* Generate a computed goto statement to EXPR.  */
7791
7792 tree
7793 c_finish_goto_ptr (tree expr)
7794 {
7795   pedwarn (input_location, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
7796   expr = c_fully_fold (expr, false, NULL);
7797   expr = convert (ptr_type_node, expr);
7798   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
7799 }
7800
7801 /* Generate a C `return' statement.  RETVAL is the expression for what
7802    to return, or a null pointer for `return;' with no value.  If
7803    ORIGTYPE is not NULL_TREE, it is the original type of RETVAL.  */
7804
7805 tree
7806 c_finish_return (tree retval, tree origtype)
7807 {
7808   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
7809   bool no_warning = false;
7810   bool npc = false;
7811
7812   if (TREE_THIS_VOLATILE (current_function_decl))
7813     warning (0, "function declared %<noreturn%> has a %<return%> statement");
7814
7815   if (retval)
7816     {
7817       tree semantic_type = NULL_TREE;
7818       npc = null_pointer_constant_p (retval);
7819       if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
7820         {
7821           semantic_type = TREE_TYPE (retval);
7822           retval = TREE_OPERAND (retval, 0);
7823         }
7824       retval = c_fully_fold (retval, false, NULL);
7825       if (semantic_type)
7826         retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
7827     }
7828
7829   if (!retval)
7830     {
7831       current_function_returns_null = 1;
7832       if ((warn_return_type || flag_isoc99)
7833           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7834         {
7835           pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wreturn_type,
7836                        "%<return%> with no value, in "
7837                        "function returning non-void");
7838           no_warning = true;
7839         }
7840     }
7841   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7842     {
7843       current_function_returns_null = 1;
7844       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7845         pedwarn (input_location, 0,
7846                  "%<return%> with a value, in function returning void");
7847       else
7848         pedwarn (input_location, OPT_pedantic, "ISO C forbids "
7849                  "%<return%> with expression, in function returning void");
7850     }
7851   else
7852     {
7853       tree t = convert_for_assignment (valtype, retval, origtype, ic_return,
7854                                        npc, NULL_TREE, NULL_TREE, 0);
7855       tree res = DECL_RESULT (current_function_decl);
7856       tree inner;
7857
7858       current_function_returns_value = 1;
7859       if (t == error_mark_node)
7860         return NULL_TREE;
7861
7862       inner = t = convert (TREE_TYPE (res), t);
7863
7864       /* Strip any conversions, additions, and subtractions, and see if
7865          we are returning the address of a local variable.  Warn if so.  */
7866       while (1)
7867         {
7868           switch (TREE_CODE (inner))
7869             {
7870             CASE_CONVERT:
7871             case NON_LVALUE_EXPR:
7872             case PLUS_EXPR:
7873             case POINTER_PLUS_EXPR:
7874               inner = TREE_OPERAND (inner, 0);
7875               continue;
7876
7877             case MINUS_EXPR:
7878               /* If the second operand of the MINUS_EXPR has a pointer
7879                  type (or is converted from it), this may be valid, so
7880                  don't give a warning.  */
7881               {
7882                 tree op1 = TREE_OPERAND (inner, 1);
7883
7884                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
7885                        && (CONVERT_EXPR_P (op1)
7886                            || TREE_CODE (op1) == NON_LVALUE_EXPR))
7887                   op1 = TREE_OPERAND (op1, 0);
7888
7889                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7890                   break;
7891
7892                 inner = TREE_OPERAND (inner, 0);
7893                 continue;
7894               }
7895
7896             case ADDR_EXPR:
7897               inner = TREE_OPERAND (inner, 0);
7898
7899               while (REFERENCE_CLASS_P (inner)
7900                      && TREE_CODE (inner) != INDIRECT_REF)
7901                 inner = TREE_OPERAND (inner, 0);
7902
7903               if (DECL_P (inner)
7904                   && !DECL_EXTERNAL (inner)
7905                   && !TREE_STATIC (inner)
7906                   && DECL_CONTEXT (inner) == current_function_decl)
7907                 warning (0, "function returns address of local variable");
7908               break;
7909
7910             default:
7911               break;
7912             }
7913
7914           break;
7915         }
7916
7917       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
7918
7919       if (warn_sequence_point)
7920         verify_sequence_points (retval);
7921     }
7922
7923   ret_stmt = build_stmt (RETURN_EXPR, retval);
7924   TREE_NO_WARNING (ret_stmt) |= no_warning;
7925   return add_stmt (ret_stmt);
7926 }
7927 \f
7928 struct c_switch {
7929   /* The SWITCH_EXPR being built.  */
7930   tree switch_expr;
7931
7932   /* The original type of the testing expression, i.e. before the
7933      default conversion is applied.  */
7934   tree orig_type;
7935
7936   /* A splay-tree mapping the low element of a case range to the high
7937      element, or NULL_TREE if there is no high element.  Used to
7938      determine whether or not a new case label duplicates an old case
7939      label.  We need a tree, rather than simply a hash table, because
7940      of the GNU case range extension.  */
7941   splay_tree cases;
7942
7943   /* Number of nested statement expressions within this switch
7944      statement; if nonzero, case and default labels may not
7945      appear.  */
7946   unsigned int blocked_stmt_expr;
7947
7948   /* Scope of outermost declarations of identifiers with variably
7949      modified type within this switch statement; if nonzero, case and
7950      default labels may not appear.  */
7951   unsigned int blocked_vm;
7952
7953   /* The next node on the stack.  */
7954   struct c_switch *next;
7955 };
7956
7957 /* A stack of the currently active switch statements.  The innermost
7958    switch statement is on the top of the stack.  There is no need to
7959    mark the stack for garbage collection because it is only active
7960    during the processing of the body of a function, and we never
7961    collect at that point.  */
7962
7963 struct c_switch *c_switch_stack;
7964
7965 /* Start a C switch statement, testing expression EXP.  Return the new
7966    SWITCH_EXPR.  */
7967
7968 tree
7969 c_start_case (tree exp)
7970 {
7971   tree orig_type = error_mark_node;
7972   struct c_switch *cs;
7973
7974   if (exp != error_mark_node)
7975     {
7976       orig_type = TREE_TYPE (exp);
7977
7978       if (!INTEGRAL_TYPE_P (orig_type))
7979         {
7980           if (orig_type != error_mark_node)
7981             {
7982               error ("switch quantity not an integer");
7983               orig_type = error_mark_node;
7984             }
7985           exp = integer_zero_node;
7986         }
7987       else
7988         {
7989           tree type = TYPE_MAIN_VARIANT (orig_type);
7990
7991           if (!in_system_header
7992               && (type == long_integer_type_node
7993                   || type == long_unsigned_type_node))
7994             warning (OPT_Wtraditional, "%<long%> switch expression not "
7995                      "converted to %<int%> in ISO C");
7996
7997           exp = c_fully_fold (exp, false, NULL);
7998           exp = default_conversion (exp);
7999
8000           if (warn_sequence_point)
8001             verify_sequence_points (exp);
8002         }
8003     }
8004
8005   /* Add this new SWITCH_EXPR to the stack.  */
8006   cs = XNEW (struct c_switch);
8007   cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
8008   cs->orig_type = orig_type;
8009   cs->cases = splay_tree_new (case_compare, NULL, NULL);
8010   cs->blocked_stmt_expr = 0;
8011   cs->blocked_vm = 0;
8012   cs->next = c_switch_stack;
8013   c_switch_stack = cs;
8014
8015   return add_stmt (cs->switch_expr);
8016 }
8017
8018 /* Process a case label.  */
8019
8020 tree
8021 do_case (tree low_value, tree high_value)
8022 {
8023   tree label = NULL_TREE;
8024
8025   if (low_value && TREE_CODE (low_value) != INTEGER_CST)
8026     {
8027       low_value = c_fully_fold (low_value, false, NULL);
8028       if (TREE_CODE (low_value) == INTEGER_CST)
8029         pedwarn (input_location, OPT_pedantic,
8030                  "case label is not an integer constant expression");
8031     }
8032
8033   if (high_value && TREE_CODE (high_value) != INTEGER_CST)
8034     {
8035       high_value = c_fully_fold (high_value, false, NULL);
8036       if (TREE_CODE (high_value) == INTEGER_CST)
8037         pedwarn (input_location, OPT_pedantic,
8038                  "case label is not an integer constant expression");
8039     }
8040
8041   if (c_switch_stack && !c_switch_stack->blocked_stmt_expr
8042       && !c_switch_stack->blocked_vm)
8043     {
8044       label = c_add_case_label (c_switch_stack->cases,
8045                                 SWITCH_COND (c_switch_stack->switch_expr),
8046                                 c_switch_stack->orig_type,
8047                                 low_value, high_value);
8048       if (label == error_mark_node)
8049         label = NULL_TREE;
8050     }
8051   else if (c_switch_stack && c_switch_stack->blocked_stmt_expr)
8052     {
8053       if (low_value)
8054         error ("case label in statement expression not containing "
8055                "enclosing switch statement");
8056       else
8057         error ("%<default%> label in statement expression not containing "
8058                "enclosing switch statement");
8059     }
8060   else if (c_switch_stack && c_switch_stack->blocked_vm)
8061     {
8062       if (low_value)
8063         error ("case label in scope of identifier with variably modified "
8064                "type not containing enclosing switch statement");
8065       else
8066         error ("%<default%> label in scope of identifier with variably "
8067                "modified type not containing enclosing switch statement");
8068     }
8069   else if (low_value)
8070     error ("case label not within a switch statement");
8071   else
8072     error ("%<default%> label not within a switch statement");
8073
8074   return label;
8075 }
8076
8077 /* Finish the switch statement.  */
8078
8079 void
8080 c_finish_case (tree body)
8081 {
8082   struct c_switch *cs = c_switch_stack;
8083   location_t switch_location;
8084
8085   SWITCH_BODY (cs->switch_expr) = body;
8086
8087   /* We must not be within a statement expression nested in the switch
8088      at this point; we might, however, be within the scope of an
8089      identifier with variably modified type nested in the switch.  */
8090   gcc_assert (!cs->blocked_stmt_expr);
8091
8092   /* Emit warnings as needed.  */
8093   if (EXPR_HAS_LOCATION (cs->switch_expr))
8094     switch_location = EXPR_LOCATION (cs->switch_expr);
8095   else
8096     switch_location = input_location;
8097   c_do_switch_warnings (cs->cases, switch_location,
8098                         TREE_TYPE (cs->switch_expr),
8099                         SWITCH_COND (cs->switch_expr));
8100
8101   /* Pop the stack.  */
8102   c_switch_stack = cs->next;
8103   splay_tree_delete (cs->cases);
8104   XDELETE (cs);
8105 }
8106 \f
8107 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
8108    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8109    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
8110    statement, and was not surrounded with parenthesis.  */
8111
8112 void
8113 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
8114                   tree else_block, bool nested_if)
8115 {
8116   tree stmt;
8117
8118   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
8119   if (warn_parentheses && nested_if && else_block == NULL)
8120     {
8121       tree inner_if = then_block;
8122
8123       /* We know from the grammar productions that there is an IF nested
8124          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
8125          it might not be exactly THEN_BLOCK, but should be the last
8126          non-container statement within.  */
8127       while (1)
8128         switch (TREE_CODE (inner_if))
8129           {
8130           case COND_EXPR:
8131             goto found;
8132           case BIND_EXPR:
8133             inner_if = BIND_EXPR_BODY (inner_if);
8134             break;
8135           case STATEMENT_LIST:
8136             inner_if = expr_last (then_block);
8137             break;
8138           case TRY_FINALLY_EXPR:
8139           case TRY_CATCH_EXPR:
8140             inner_if = TREE_OPERAND (inner_if, 0);
8141             break;
8142           default:
8143             gcc_unreachable ();
8144           }
8145     found:
8146
8147       if (COND_EXPR_ELSE (inner_if))
8148          warning (OPT_Wparentheses,
8149                   "%Hsuggest explicit braces to avoid ambiguous %<else%>",
8150                   &if_locus);
8151     }
8152
8153   stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
8154   SET_EXPR_LOCATION (stmt, if_locus);
8155   add_stmt (stmt);
8156 }
8157
8158 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
8159    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
8160    is false for DO loops.  INCR is the FOR increment expression.  BODY is
8161    the statement controlled by the loop.  BLAB is the break label.  CLAB is
8162    the continue label.  Everything is allowed to be NULL.  */
8163
8164 void
8165 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
8166                tree blab, tree clab, bool cond_is_first)
8167 {
8168   tree entry = NULL, exit = NULL, t;
8169
8170   /* If the condition is zero don't generate a loop construct.  */
8171   if (cond && integer_zerop (cond))
8172     {
8173       if (cond_is_first)
8174         {
8175           t = build_and_jump (&blab);
8176           SET_EXPR_LOCATION (t, start_locus);
8177           add_stmt (t);
8178         }
8179     }
8180   else
8181     {
8182       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
8183
8184       /* If we have an exit condition, then we build an IF with gotos either
8185          out of the loop, or to the top of it.  If there's no exit condition,
8186          then we just build a jump back to the top.  */
8187       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
8188
8189       if (cond && !integer_nonzerop (cond))
8190         {
8191           /* Canonicalize the loop condition to the end.  This means
8192              generating a branch to the loop condition.  Reuse the
8193              continue label, if possible.  */
8194           if (cond_is_first)
8195             {
8196               if (incr || !clab)
8197                 {
8198                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
8199                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
8200                 }
8201               else
8202                 t = build1 (GOTO_EXPR, void_type_node, clab);
8203               SET_EXPR_LOCATION (t, start_locus);
8204               add_stmt (t);
8205             }
8206
8207           t = build_and_jump (&blab);
8208           exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
8209           if (cond_is_first)
8210             SET_EXPR_LOCATION (exit, start_locus);
8211           else
8212             SET_EXPR_LOCATION (exit, input_location);
8213         }
8214
8215       add_stmt (top);
8216     }
8217
8218   if (body)
8219     add_stmt (body);
8220   if (clab)
8221     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
8222   if (incr)
8223     add_stmt (incr);
8224   if (entry)
8225     add_stmt (entry);
8226   if (exit)
8227     add_stmt (exit);
8228   if (blab)
8229     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
8230 }
8231
8232 tree
8233 c_finish_bc_stmt (tree *label_p, bool is_break)
8234 {
8235   bool skip;
8236   tree label = *label_p;
8237
8238   /* In switch statements break is sometimes stylistically used after
8239      a return statement.  This can lead to spurious warnings about
8240      control reaching the end of a non-void function when it is
8241      inlined.  Note that we are calling block_may_fallthru with
8242      language specific tree nodes; this works because
8243      block_may_fallthru returns true when given something it does not
8244      understand.  */
8245   skip = !block_may_fallthru (cur_stmt_list);
8246
8247   if (!label)
8248     {
8249       if (!skip)
8250         *label_p = label = create_artificial_label ();
8251     }
8252   else if (TREE_CODE (label) == LABEL_DECL)
8253     ;
8254   else switch (TREE_INT_CST_LOW (label))
8255     {
8256     case 0:
8257       if (is_break)
8258         error ("break statement not within loop or switch");
8259       else
8260         error ("continue statement not within a loop");
8261       return NULL_TREE;
8262
8263     case 1:
8264       gcc_assert (is_break);
8265       error ("break statement used with OpenMP for loop");
8266       return NULL_TREE;
8267
8268     default:
8269       gcc_unreachable ();
8270     }
8271
8272   if (skip)
8273     return NULL_TREE;
8274
8275   if (!is_break)
8276     add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
8277
8278   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
8279 }
8280
8281 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
8282
8283 static void
8284 emit_side_effect_warnings (tree expr)
8285 {
8286   if (expr == error_mark_node)
8287     ;
8288   else if (!TREE_SIDE_EFFECTS (expr))
8289     {
8290       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
8291         warning (OPT_Wunused_value, "%Hstatement with no effect",
8292                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
8293     }
8294   else
8295     warn_if_unused_value (expr, input_location);
8296 }
8297
8298 /* Process an expression as if it were a complete statement.  Emit
8299    diagnostics, but do not call ADD_STMT.  */
8300
8301 tree
8302 c_process_expr_stmt (tree expr)
8303 {
8304   if (!expr)
8305     return NULL_TREE;
8306
8307   expr = c_fully_fold (expr, false, NULL);
8308
8309   if (warn_sequence_point)
8310     verify_sequence_points (expr);
8311
8312   if (TREE_TYPE (expr) != error_mark_node
8313       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
8314       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
8315     error ("expression statement has incomplete type");
8316
8317   /* If we're not processing a statement expression, warn about unused values.
8318      Warnings for statement expressions will be emitted later, once we figure
8319      out which is the result.  */
8320   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
8321       && warn_unused_value)
8322     emit_side_effect_warnings (expr);
8323
8324   /* If the expression is not of a type to which we cannot assign a line
8325      number, wrap the thing in a no-op NOP_EXPR.  */
8326   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
8327     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
8328
8329   if (CAN_HAVE_LOCATION_P (expr))
8330     SET_EXPR_LOCATION (expr, input_location);
8331
8332   return expr;
8333 }
8334
8335 /* Emit an expression as a statement.  */
8336
8337 tree
8338 c_finish_expr_stmt (tree expr)
8339 {
8340   if (expr)
8341     return add_stmt (c_process_expr_stmt (expr));
8342   else
8343     return NULL;
8344 }
8345
8346 /* Do the opposite and emit a statement as an expression.  To begin,
8347    create a new binding level and return it.  */
8348
8349 tree
8350 c_begin_stmt_expr (void)
8351 {
8352   tree ret;
8353   struct c_label_context_se *nstack;
8354   struct c_label_list *glist;
8355
8356   /* We must force a BLOCK for this level so that, if it is not expanded
8357      later, there is a way to turn off the entire subtree of blocks that
8358      are contained in it.  */
8359   keep_next_level ();
8360   ret = c_begin_compound_stmt (true);
8361   if (c_switch_stack)
8362     {
8363       c_switch_stack->blocked_stmt_expr++;
8364       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
8365     }
8366   for (glist = label_context_stack_se->labels_used;
8367        glist != NULL;
8368        glist = glist->next)
8369     {
8370       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1;
8371     }
8372   nstack = XOBNEW (&parser_obstack, struct c_label_context_se);
8373   nstack->labels_def = NULL;
8374   nstack->labels_used = NULL;
8375   nstack->next = label_context_stack_se;
8376   label_context_stack_se = nstack;
8377
8378   /* Mark the current statement list as belonging to a statement list.  */
8379   STATEMENT_LIST_STMT_EXPR (ret) = 1;
8380
8381   return ret;
8382 }
8383
8384 tree
8385 c_finish_stmt_expr (tree body)
8386 {
8387   tree last, type, tmp, val;
8388   tree *last_p;
8389   struct c_label_list *dlist, *glist, *glist_prev = NULL;
8390
8391   body = c_end_compound_stmt (body, true);
8392   if (c_switch_stack)
8393     {
8394       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
8395       c_switch_stack->blocked_stmt_expr--;
8396     }
8397   /* It is no longer possible to jump to labels defined within this
8398      statement expression.  */
8399   for (dlist = label_context_stack_se->labels_def;
8400        dlist != NULL;
8401        dlist = dlist->next)
8402     {
8403       C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1;
8404     }
8405   /* It is again possible to define labels with a goto just outside
8406      this statement expression.  */
8407   for (glist = label_context_stack_se->next->labels_used;
8408        glist != NULL;
8409        glist = glist->next)
8410     {
8411       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0;
8412       glist_prev = glist;
8413     }
8414   if (glist_prev != NULL)
8415     glist_prev->next = label_context_stack_se->labels_used;
8416   else
8417     label_context_stack_se->next->labels_used
8418       = label_context_stack_se->labels_used;
8419   label_context_stack_se = label_context_stack_se->next;
8420
8421   /* Locate the last statement in BODY.  See c_end_compound_stmt
8422      about always returning a BIND_EXPR.  */
8423   last_p = &BIND_EXPR_BODY (body);
8424   last = BIND_EXPR_BODY (body);
8425
8426  continue_searching:
8427   if (TREE_CODE (last) == STATEMENT_LIST)
8428     {
8429       tree_stmt_iterator i;
8430
8431       /* This can happen with degenerate cases like ({ }).  No value.  */
8432       if (!TREE_SIDE_EFFECTS (last))
8433         return body;
8434
8435       /* If we're supposed to generate side effects warnings, process
8436          all of the statements except the last.  */
8437       if (warn_unused_value)
8438         {
8439           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
8440             emit_side_effect_warnings (tsi_stmt (i));
8441         }
8442       else
8443         i = tsi_last (last);
8444       last_p = tsi_stmt_ptr (i);
8445       last = *last_p;
8446     }
8447
8448   /* If the end of the list is exception related, then the list was split
8449      by a call to push_cleanup.  Continue searching.  */
8450   if (TREE_CODE (last) == TRY_FINALLY_EXPR
8451       || TREE_CODE (last) == TRY_CATCH_EXPR)
8452     {
8453       last_p = &TREE_OPERAND (last, 0);
8454       last = *last_p;
8455       goto continue_searching;
8456     }
8457
8458   /* In the case that the BIND_EXPR is not necessary, return the
8459      expression out from inside it.  */
8460   if (last == error_mark_node
8461       || (last == BIND_EXPR_BODY (body)
8462           && BIND_EXPR_VARS (body) == NULL))
8463     {
8464       /* Even if this looks constant, do not allow it in a constant
8465          expression.  */
8466       last = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (last), NULL_TREE, last);
8467       C_MAYBE_CONST_EXPR_NON_CONST (last) = 1;
8468       /* Do not warn if the return value of a statement expression is
8469          unused.  */
8470       TREE_NO_WARNING (last) = 1;
8471       return last;
8472     }
8473
8474   /* Extract the type of said expression.  */
8475   type = TREE_TYPE (last);
8476
8477   /* If we're not returning a value at all, then the BIND_EXPR that
8478      we already have is a fine expression to return.  */
8479   if (!type || VOID_TYPE_P (type))
8480     return body;
8481
8482   /* Now that we've located the expression containing the value, it seems
8483      silly to make voidify_wrapper_expr repeat the process.  Create a
8484      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
8485   tmp = create_tmp_var_raw (type, NULL);
8486
8487   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
8488      tree_expr_nonnegative_p giving up immediately.  */
8489   val = last;
8490   if (TREE_CODE (val) == NOP_EXPR
8491       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
8492     val = TREE_OPERAND (val, 0);
8493
8494   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
8495   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
8496
8497   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
8498 }
8499
8500 /* Begin the scope of an identifier of variably modified type, scope
8501    number SCOPE.  Jumping from outside this scope to inside it is not
8502    permitted.  */
8503
8504 void
8505 c_begin_vm_scope (unsigned int scope)
8506 {
8507   struct c_label_context_vm *nstack;
8508   struct c_label_list *glist;
8509
8510   gcc_assert (scope > 0);
8511
8512   /* At file_scope, we don't have to do any processing.  */
8513   if (label_context_stack_vm == NULL)
8514     return;
8515
8516   if (c_switch_stack && !c_switch_stack->blocked_vm)
8517     c_switch_stack->blocked_vm = scope;
8518   for (glist = label_context_stack_vm->labels_used;
8519        glist != NULL;
8520        glist = glist->next)
8521     {
8522       C_DECL_UNDEFINABLE_VM (glist->label) = 1;
8523     }
8524   nstack = XOBNEW (&parser_obstack, struct c_label_context_vm);
8525   nstack->labels_def = NULL;
8526   nstack->labels_used = NULL;
8527   nstack->scope = scope;
8528   nstack->next = label_context_stack_vm;
8529   label_context_stack_vm = nstack;
8530 }
8531
8532 /* End a scope which may contain identifiers of variably modified
8533    type, scope number SCOPE.  */
8534
8535 void
8536 c_end_vm_scope (unsigned int scope)
8537 {
8538   if (label_context_stack_vm == NULL)
8539     return;
8540   if (c_switch_stack && c_switch_stack->blocked_vm == scope)
8541     c_switch_stack->blocked_vm = 0;
8542   /* We may have a number of nested scopes of identifiers with
8543      variably modified type, all at this depth.  Pop each in turn.  */
8544   while (label_context_stack_vm->scope == scope)
8545     {
8546       struct c_label_list *dlist, *glist, *glist_prev = NULL;
8547
8548       /* It is no longer possible to jump to labels defined within this
8549          scope.  */
8550       for (dlist = label_context_stack_vm->labels_def;
8551            dlist != NULL;
8552            dlist = dlist->next)
8553         {
8554           C_DECL_UNJUMPABLE_VM (dlist->label) = 1;
8555         }
8556       /* It is again possible to define labels with a goto just outside
8557          this scope.  */
8558       for (glist = label_context_stack_vm->next->labels_used;
8559            glist != NULL;
8560            glist = glist->next)
8561         {
8562           C_DECL_UNDEFINABLE_VM (glist->label) = 0;
8563           glist_prev = glist;
8564         }
8565       if (glist_prev != NULL)
8566         glist_prev->next = label_context_stack_vm->labels_used;
8567       else
8568         label_context_stack_vm->next->labels_used
8569           = label_context_stack_vm->labels_used;
8570       label_context_stack_vm = label_context_stack_vm->next;
8571     }
8572 }
8573 \f
8574 /* Begin and end compound statements.  This is as simple as pushing
8575    and popping new statement lists from the tree.  */
8576
8577 tree
8578 c_begin_compound_stmt (bool do_scope)
8579 {
8580   tree stmt = push_stmt_list ();
8581   if (do_scope)
8582     push_scope ();
8583   return stmt;
8584 }
8585
8586 tree
8587 c_end_compound_stmt (tree stmt, bool do_scope)
8588 {
8589   tree block = NULL;
8590
8591   if (do_scope)
8592     {
8593       if (c_dialect_objc ())
8594         objc_clear_super_receiver ();
8595       block = pop_scope ();
8596     }
8597
8598   stmt = pop_stmt_list (stmt);
8599   stmt = c_build_bind_expr (block, stmt);
8600
8601   /* If this compound statement is nested immediately inside a statement
8602      expression, then force a BIND_EXPR to be created.  Otherwise we'll
8603      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
8604      STATEMENT_LISTs merge, and thus we can lose track of what statement
8605      was really last.  */
8606   if (cur_stmt_list
8607       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
8608       && TREE_CODE (stmt) != BIND_EXPR)
8609     {
8610       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
8611       TREE_SIDE_EFFECTS (stmt) = 1;
8612     }
8613
8614   return stmt;
8615 }
8616
8617 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
8618    when the current scope is exited.  EH_ONLY is true when this is not
8619    meant to apply to normal control flow transfer.  */
8620
8621 void
8622 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
8623 {
8624   enum tree_code code;
8625   tree stmt, list;
8626   bool stmt_expr;
8627
8628   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
8629   stmt = build_stmt (code, NULL, cleanup);
8630   add_stmt (stmt);
8631   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
8632   list = push_stmt_list ();
8633   TREE_OPERAND (stmt, 0) = list;
8634   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
8635 }
8636 \f
8637 /* Build a binary-operation expression without default conversions.
8638    CODE is the kind of expression to build.
8639    LOCATION is the operator's location.
8640    This function differs from `build' in several ways:
8641    the data type of the result is computed and recorded in it,
8642    warnings are generated if arg data types are invalid,
8643    special handling for addition and subtraction of pointers is known,
8644    and some optimization is done (operations on narrow ints
8645    are done in the narrower type when that gives the same result).
8646    Constant folding is also done before the result is returned.
8647
8648    Note that the operands will never have enumeral types, or function
8649    or array types, because either they will have the default conversions
8650    performed or they have both just been converted to some other type in which
8651    the arithmetic is to be done.  */
8652
8653 tree
8654 build_binary_op (location_t location, enum tree_code code,
8655                  tree orig_op0, tree orig_op1, int convert_p)
8656 {
8657   tree type0, type1, orig_type0, orig_type1;
8658   tree eptype;
8659   enum tree_code code0, code1;
8660   tree op0, op1;
8661   tree ret = error_mark_node;
8662   const char *invalid_op_diag;
8663   bool op0_int_operands, op1_int_operands;
8664   bool int_const, int_const_or_overflow, int_operands;
8665
8666   /* Expression code to give to the expression when it is built.
8667      Normally this is CODE, which is what the caller asked for,
8668      but in some special cases we change it.  */
8669   enum tree_code resultcode = code;
8670
8671   /* Data type in which the computation is to be performed.
8672      In the simplest cases this is the common type of the arguments.  */
8673   tree result_type = NULL;
8674
8675   /* When the computation is in excess precision, the type of the
8676      final EXCESS_PRECISION_EXPR.  */
8677   tree real_result_type = NULL;
8678
8679   /* Nonzero means operands have already been type-converted
8680      in whatever way is necessary.
8681      Zero means they need to be converted to RESULT_TYPE.  */
8682   int converted = 0;
8683
8684   /* Nonzero means create the expression with this type, rather than
8685      RESULT_TYPE.  */
8686   tree build_type = 0;
8687
8688   /* Nonzero means after finally constructing the expression
8689      convert it to this type.  */
8690   tree final_type = 0;
8691
8692   /* Nonzero if this is an operation like MIN or MAX which can
8693      safely be computed in short if both args are promoted shorts.
8694      Also implies COMMON.
8695      -1 indicates a bitwise operation; this makes a difference
8696      in the exact conditions for when it is safe to do the operation
8697      in a narrower mode.  */
8698   int shorten = 0;
8699
8700   /* Nonzero if this is a comparison operation;
8701      if both args are promoted shorts, compare the original shorts.
8702      Also implies COMMON.  */
8703   int short_compare = 0;
8704
8705   /* Nonzero if this is a right-shift operation, which can be computed on the
8706      original short and then promoted if the operand is a promoted short.  */
8707   int short_shift = 0;
8708
8709   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
8710   int common = 0;
8711
8712   /* True means types are compatible as far as ObjC is concerned.  */
8713   bool objc_ok;
8714
8715   /* True means this is an arithmetic operation that may need excess
8716      precision.  */
8717   bool may_need_excess_precision;
8718
8719   if (location == UNKNOWN_LOCATION)
8720     location = input_location;
8721
8722   op0 = orig_op0;
8723   op1 = orig_op1;
8724
8725   op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
8726   if (op0_int_operands)
8727     op0 = remove_c_maybe_const_expr (op0);
8728   op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
8729   if (op1_int_operands)
8730     op1 = remove_c_maybe_const_expr (op1);
8731   int_operands = (op0_int_operands && op1_int_operands);
8732   if (int_operands)
8733     {
8734       int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
8735                                && TREE_CODE (orig_op1) == INTEGER_CST);
8736       int_const = (int_const_or_overflow
8737                    && !TREE_OVERFLOW (orig_op0)
8738                    && !TREE_OVERFLOW (orig_op1));
8739     }
8740   else
8741     int_const = int_const_or_overflow = false;
8742
8743   if (convert_p)
8744     {
8745       op0 = default_conversion (op0);
8746       op1 = default_conversion (op1);
8747     }
8748
8749   orig_type0 = type0 = TREE_TYPE (op0);
8750   orig_type1 = type1 = TREE_TYPE (op1);
8751
8752   /* The expression codes of the data types of the arguments tell us
8753      whether the arguments are integers, floating, pointers, etc.  */
8754   code0 = TREE_CODE (type0);
8755   code1 = TREE_CODE (type1);
8756
8757   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
8758   STRIP_TYPE_NOPS (op0);
8759   STRIP_TYPE_NOPS (op1);
8760
8761   /* If an error was already reported for one of the arguments,
8762      avoid reporting another error.  */
8763
8764   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
8765     return error_mark_node;
8766
8767   if ((invalid_op_diag
8768        = targetm.invalid_binary_op (code, type0, type1)))
8769     {
8770       error_at (location, invalid_op_diag);
8771       return error_mark_node;
8772     }
8773
8774   switch (code)
8775     {
8776     case PLUS_EXPR:
8777     case MINUS_EXPR:
8778     case MULT_EXPR:
8779     case TRUNC_DIV_EXPR:
8780     case CEIL_DIV_EXPR:
8781     case FLOOR_DIV_EXPR:
8782     case ROUND_DIV_EXPR:
8783     case EXACT_DIV_EXPR:
8784       may_need_excess_precision = true;
8785       break;
8786     default:
8787       may_need_excess_precision = false;
8788       break;
8789     }
8790   if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
8791     {
8792       op0 = TREE_OPERAND (op0, 0);
8793       type0 = TREE_TYPE (op0);
8794     }
8795   else if (may_need_excess_precision
8796            && (eptype = excess_precision_type (type0)) != NULL_TREE)
8797     {
8798       type0 = eptype;
8799       op0 = convert (eptype, op0);
8800     }
8801   if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
8802     {
8803       op1 = TREE_OPERAND (op1, 0);
8804       type1 = TREE_TYPE (op1);
8805     }
8806   else if (may_need_excess_precision
8807            && (eptype = excess_precision_type (type1)) != NULL_TREE)
8808     {
8809       type1 = eptype;
8810       op1 = convert (eptype, op1);
8811     }
8812
8813   objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
8814
8815   switch (code)
8816     {
8817     case PLUS_EXPR:
8818       /* Handle the pointer + int case.  */
8819       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
8820         {
8821           ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
8822           goto return_build_binary_op;
8823         }
8824       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
8825         {
8826           ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
8827           goto return_build_binary_op;
8828         }
8829       else
8830         common = 1;
8831       break;
8832
8833     case MINUS_EXPR:
8834       /* Subtraction of two similar pointers.
8835          We must subtract them as integers, then divide by object size.  */
8836       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
8837           && comp_target_types (type0, type1))
8838         {
8839           ret = pointer_diff (op0, op1);
8840           goto return_build_binary_op;
8841         }
8842       /* Handle pointer minus int.  Just like pointer plus int.  */
8843       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
8844         {
8845           ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
8846           goto return_build_binary_op;
8847         }
8848       else
8849         common = 1;
8850       break;
8851
8852     case MULT_EXPR:
8853       common = 1;
8854       break;
8855
8856     case TRUNC_DIV_EXPR:
8857     case CEIL_DIV_EXPR:
8858     case FLOOR_DIV_EXPR:
8859     case ROUND_DIV_EXPR:
8860     case EXACT_DIV_EXPR:
8861       warn_for_div_by_zero (location, op1);
8862
8863       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
8864            || code0 == FIXED_POINT_TYPE
8865            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
8866           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
8867               || code1 == FIXED_POINT_TYPE
8868               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
8869         {
8870           enum tree_code tcode0 = code0, tcode1 = code1;
8871
8872           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
8873             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
8874           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
8875             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
8876
8877           if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
8878               || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
8879             resultcode = RDIV_EXPR;
8880           else
8881             /* Although it would be tempting to shorten always here, that
8882                loses on some targets, since the modulo instruction is
8883                undefined if the quotient can't be represented in the
8884                computation mode.  We shorten only if unsigned or if
8885                dividing by something we know != -1.  */
8886             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
8887                        || (TREE_CODE (op1) == INTEGER_CST
8888                            && !integer_all_onesp (op1)));
8889           common = 1;
8890         }
8891       break;
8892
8893     case BIT_AND_EXPR:
8894     case BIT_IOR_EXPR:
8895     case BIT_XOR_EXPR:
8896       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
8897         shorten = -1;
8898       /* Allow vector types which are not floating point types.   */
8899       else if (code0 == VECTOR_TYPE
8900                && code1 == VECTOR_TYPE
8901                && !VECTOR_FLOAT_TYPE_P (type0)
8902                && !VECTOR_FLOAT_TYPE_P (type1))
8903         common = 1;
8904       break;
8905
8906     case TRUNC_MOD_EXPR:
8907     case FLOOR_MOD_EXPR:
8908       warn_for_div_by_zero (location, op1);
8909
8910       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
8911         {
8912           /* Although it would be tempting to shorten always here, that loses
8913              on some targets, since the modulo instruction is undefined if the
8914              quotient can't be represented in the computation mode.  We shorten
8915              only if unsigned or if dividing by something we know != -1.  */
8916           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
8917                      || (TREE_CODE (op1) == INTEGER_CST
8918                          && !integer_all_onesp (op1)));
8919           common = 1;
8920         }
8921       break;
8922
8923     case TRUTH_ANDIF_EXPR:
8924     case TRUTH_ORIF_EXPR:
8925     case TRUTH_AND_EXPR:
8926     case TRUTH_OR_EXPR:
8927     case TRUTH_XOR_EXPR:
8928       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
8929            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
8930            || code0 == FIXED_POINT_TYPE)
8931           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
8932               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
8933               || code1 == FIXED_POINT_TYPE))
8934         {
8935           /* Result of these operations is always an int,
8936              but that does not mean the operands should be
8937              converted to ints!  */
8938           result_type = integer_type_node;
8939           op0 = c_common_truthvalue_conversion (location, op0);
8940           op1 = c_common_truthvalue_conversion (location, op1);
8941           converted = 1;
8942         }
8943       if (code == TRUTH_ANDIF_EXPR)
8944         {
8945           int_const_or_overflow = (int_operands
8946                                    && TREE_CODE (orig_op0) == INTEGER_CST
8947                                    && (op0 == truthvalue_false_node
8948                                        || TREE_CODE (orig_op1) == INTEGER_CST));
8949           int_const = (int_const_or_overflow
8950                        && !TREE_OVERFLOW (orig_op0)
8951                        && (op0 == truthvalue_false_node
8952                            || !TREE_OVERFLOW (orig_op1)));
8953         }
8954       else if (code == TRUTH_ORIF_EXPR)
8955         {
8956           int_const_or_overflow = (int_operands
8957                                    && TREE_CODE (orig_op0) == INTEGER_CST
8958                                    && (op0 == truthvalue_true_node
8959                                        || TREE_CODE (orig_op1) == INTEGER_CST));
8960           int_const = (int_const_or_overflow
8961                        && !TREE_OVERFLOW (orig_op0)
8962                        && (op0 == truthvalue_true_node
8963                            || !TREE_OVERFLOW (orig_op1)));
8964         }
8965       break;
8966
8967       /* Shift operations: result has same type as first operand;
8968          always convert second operand to int.
8969          Also set SHORT_SHIFT if shifting rightward.  */
8970
8971     case RSHIFT_EXPR:
8972       if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
8973           && code1 == INTEGER_TYPE)
8974         {
8975           if (TREE_CODE (op1) == INTEGER_CST)
8976             {
8977               if (tree_int_cst_sgn (op1) < 0)
8978                 {
8979                   int_const = false;
8980                   if (skip_evaluation == 0)
8981                     warning (0, "right shift count is negative");
8982                 }
8983               else
8984                 {
8985                   if (!integer_zerop (op1))
8986                     short_shift = 1;
8987
8988                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
8989                     {
8990                       int_const = false;
8991                       if (skip_evaluation == 0)
8992                         warning (0, "right shift count >= width of type");
8993                     }
8994                 }
8995             }
8996
8997           /* Use the type of the value to be shifted.  */
8998           result_type = type0;
8999           /* Convert the shift-count to an integer, regardless of size
9000              of value being shifted.  */
9001           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9002             op1 = convert (integer_type_node, op1);
9003           /* Avoid converting op1 to result_type later.  */
9004           converted = 1;
9005         }
9006       break;
9007
9008     case LSHIFT_EXPR:
9009       if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9010           && code1 == INTEGER_TYPE)
9011         {
9012           if (TREE_CODE (op1) == INTEGER_CST)
9013             {
9014               if (tree_int_cst_sgn (op1) < 0)
9015                 {
9016                   int_const = false;
9017                   if (skip_evaluation == 0)
9018                     warning (0, "left shift count is negative");
9019                 }
9020
9021               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9022                 {
9023                   int_const = false;
9024                   if (skip_evaluation == 0)
9025                     warning (0, "left shift count >= width of type");
9026                 }
9027             }
9028
9029           /* Use the type of the value to be shifted.  */
9030           result_type = type0;
9031           /* Convert the shift-count to an integer, regardless of size
9032              of value being shifted.  */
9033           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9034             op1 = convert (integer_type_node, op1);
9035           /* Avoid converting op1 to result_type later.  */
9036           converted = 1;
9037         }
9038       break;
9039
9040     case EQ_EXPR:
9041     case NE_EXPR:
9042       if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
9043         warning_at (location,
9044                     OPT_Wfloat_equal,
9045                     "comparing floating point with == or != is unsafe");
9046       /* Result of comparison is always int,
9047          but don't convert the args to int!  */
9048       build_type = integer_type_node;
9049       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9050            || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
9051           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9052               || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
9053         short_compare = 1;
9054       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
9055         {
9056           tree tt0 = TREE_TYPE (type0);
9057           tree tt1 = TREE_TYPE (type1);
9058           /* Anything compares with void *.  void * compares with anything.
9059              Otherwise, the targets must be compatible
9060              and both must be object or both incomplete.  */
9061           if (comp_target_types (type0, type1))
9062             result_type = common_pointer_type (type0, type1);
9063           else if (VOID_TYPE_P (tt0))
9064             {
9065               /* op0 != orig_op0 detects the case of something
9066                  whose value is 0 but which isn't a valid null ptr const.  */
9067               if (pedantic && !null_pointer_constant_p (orig_op0)
9068                   && TREE_CODE (tt1) == FUNCTION_TYPE)
9069                 pedwarn (location, OPT_pedantic, "ISO C forbids "
9070                          "comparison of %<void *%> with function pointer");
9071             }
9072           else if (VOID_TYPE_P (tt1))
9073             {
9074               if (pedantic && !null_pointer_constant_p (orig_op1)
9075                   && TREE_CODE (tt0) == FUNCTION_TYPE)
9076                 pedwarn (location, OPT_pedantic, "ISO C forbids "
9077                          "comparison of %<void *%> with function pointer");
9078             }
9079           else
9080             /* Avoid warning about the volatile ObjC EH puts on decls.  */
9081             if (!objc_ok)
9082               pedwarn (location, 0,
9083                        "comparison of distinct pointer types lacks a cast");
9084
9085           if (result_type == NULL_TREE)
9086             result_type = ptr_type_node;
9087         }
9088       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
9089         {
9090           if (TREE_CODE (op0) == ADDR_EXPR
9091               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
9092             warning_at (location,
9093                         OPT_Waddress, "the address of %qD will never be NULL",
9094                         TREE_OPERAND (op0, 0));
9095           result_type = type0;
9096         }
9097       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
9098         {
9099           if (TREE_CODE (op1) == ADDR_EXPR
9100               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
9101             warning_at (location,
9102                         OPT_Waddress, "the address of %qD will never be NULL",
9103                         TREE_OPERAND (op1, 0));
9104           result_type = type1;
9105         }
9106       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9107         {
9108           result_type = type0;
9109           pedwarn (location, 0, "comparison between pointer and integer");
9110         }
9111       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
9112         {
9113           result_type = type1;
9114           pedwarn (location, 0, "comparison between pointer and integer");
9115         }
9116       break;
9117
9118     case LE_EXPR:
9119     case GE_EXPR:
9120     case LT_EXPR:
9121     case GT_EXPR:
9122       build_type = integer_type_node;
9123       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9124            || code0 == FIXED_POINT_TYPE)
9125           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9126               || code1 == FIXED_POINT_TYPE))
9127         short_compare = 1;
9128       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
9129         {
9130           if (comp_target_types (type0, type1))
9131             {
9132               result_type = common_pointer_type (type0, type1);
9133               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
9134                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
9135                 pedwarn (location, 0,
9136                          "comparison of complete and incomplete pointers");
9137               else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
9138                 pedwarn (location, OPT_pedantic, "ISO C forbids "
9139                          "ordered comparisons of pointers to functions");
9140             }
9141           else
9142             {
9143               result_type = ptr_type_node;
9144               pedwarn (location, 0,
9145                        "comparison of distinct pointer types lacks a cast");
9146             }
9147         }
9148       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
9149         {
9150           result_type = type0;
9151           if (pedantic)
9152             pedwarn (location, OPT_pedantic,
9153                      "ordered comparison of pointer with integer zero");
9154           else if (extra_warnings)
9155             warning_at (location, OPT_Wextra,
9156                      "ordered comparison of pointer with integer zero");
9157         }
9158       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
9159         {
9160           result_type = type1;
9161           pedwarn (location, OPT_pedantic,
9162                    "ordered comparison of pointer with integer zero");
9163         }
9164       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9165         {
9166           result_type = type0;
9167           pedwarn (location, 0, "comparison between pointer and integer");
9168         }
9169       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
9170         {
9171           result_type = type1;
9172           pedwarn (location, 0, "comparison between pointer and integer");
9173         }
9174       break;
9175
9176     default:
9177       gcc_unreachable ();
9178     }
9179
9180   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
9181     return error_mark_node;
9182
9183   if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9184       && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
9185           || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
9186                                                     TREE_TYPE (type1))))
9187     {
9188       binary_op_error (location, code, type0, type1);
9189       return error_mark_node;
9190     }
9191
9192   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
9193        || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
9194       &&
9195       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
9196        || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
9197     {
9198       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
9199
9200       if (shorten || common || short_compare)
9201         {
9202           result_type = c_common_type (type0, type1);
9203           if (result_type == error_mark_node)
9204             return error_mark_node;
9205         }
9206
9207       /* For certain operations (which identify themselves by shorten != 0)
9208          if both args were extended from the same smaller type,
9209          do the arithmetic in that type and then extend.
9210
9211          shorten !=0 and !=1 indicates a bitwise operation.
9212          For them, this optimization is safe only if
9213          both args are zero-extended or both are sign-extended.
9214          Otherwise, we might change the result.
9215          Eg, (short)-1 | (unsigned short)-1 is (int)-1
9216          but calculated in (unsigned short) it would be (unsigned short)-1.  */
9217
9218       if (shorten && none_complex)
9219         {
9220           final_type = result_type;
9221           result_type = shorten_binary_op (result_type, op0, op1,
9222                                            shorten == -1);
9223         }
9224
9225       /* Shifts can be shortened if shifting right.  */
9226
9227       if (short_shift)
9228         {
9229           int unsigned_arg;
9230           tree arg0 = get_narrower (op0, &unsigned_arg);
9231
9232           final_type = result_type;
9233
9234           if (arg0 == op0 && final_type == TREE_TYPE (op0))
9235             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
9236
9237           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
9238               /* We can shorten only if the shift count is less than the
9239                  number of bits in the smaller type size.  */
9240               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
9241               /* We cannot drop an unsigned shift after sign-extension.  */
9242               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
9243             {
9244               /* Do an unsigned shift if the operand was zero-extended.  */
9245               result_type
9246                 = c_common_signed_or_unsigned_type (unsigned_arg,
9247                                                     TREE_TYPE (arg0));
9248               /* Convert value-to-be-shifted to that type.  */
9249               if (TREE_TYPE (op0) != result_type)
9250                 op0 = convert (result_type, op0);
9251               converted = 1;
9252             }
9253         }
9254
9255       /* Comparison operations are shortened too but differently.
9256          They identify themselves by setting short_compare = 1.  */
9257
9258       if (short_compare)
9259         {
9260           /* Don't write &op0, etc., because that would prevent op0
9261              from being kept in a register.
9262              Instead, make copies of the our local variables and
9263              pass the copies by reference, then copy them back afterward.  */
9264           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
9265           enum tree_code xresultcode = resultcode;
9266           tree val
9267             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
9268
9269           if (val != 0)
9270             {
9271               ret = val;
9272               goto return_build_binary_op;
9273             }
9274
9275           op0 = xop0, op1 = xop1;
9276           converted = 1;
9277           resultcode = xresultcode;
9278
9279           if (!skip_evaluation)
9280             {
9281               bool op0_maybe_const = true;
9282               bool op1_maybe_const = true;
9283               tree orig_op0_folded, orig_op1_folded;
9284
9285               if (in_late_binary_op)
9286                 {
9287                   orig_op0_folded = orig_op0;
9288                   orig_op1_folded = orig_op1;
9289                 }
9290               else
9291                 {
9292                   /* Fold for the sake of possible warnings, as in
9293                      build_conditional_expr.  This requires the
9294                      "original" values to be folded, not just op0 and
9295                      op1.  */
9296                   op0 = c_fully_fold (op0, require_constant_value,
9297                                       &op0_maybe_const);
9298                   op1 = c_fully_fold (op1, require_constant_value,
9299                                       &op1_maybe_const);
9300                   orig_op0_folded = c_fully_fold (orig_op0,
9301                                                   require_constant_value,
9302                                                   NULL);
9303                   orig_op1_folded = c_fully_fold (orig_op1,
9304                                                   require_constant_value,
9305                                                   NULL);
9306                 }
9307
9308               if (warn_sign_compare)
9309                 warn_for_sign_compare (location, orig_op0_folded,
9310                                        orig_op1_folded, op0, op1,
9311                                        result_type, resultcode);
9312               if (!in_late_binary_op)
9313                 {
9314                   if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
9315                     {
9316                       op0 = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (op0),
9317                                     NULL, op0);
9318                       C_MAYBE_CONST_EXPR_NON_CONST (op0) = !op0_maybe_const;
9319                     }
9320                   if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
9321                     {
9322                       op1 = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (op1),
9323                                     NULL, op1);
9324                       C_MAYBE_CONST_EXPR_NON_CONST (op1) = !op1_maybe_const;
9325                     }
9326                 }
9327             }
9328         }
9329     }
9330
9331   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
9332      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
9333      Then the expression will be built.
9334      It will be given type FINAL_TYPE if that is nonzero;
9335      otherwise, it will be given type RESULT_TYPE.  */
9336
9337   if (!result_type)
9338     {
9339       binary_op_error (location, code, TREE_TYPE (op0), TREE_TYPE (op1));
9340       return error_mark_node;
9341     }
9342
9343   if (!converted)
9344     {
9345       if (TREE_TYPE (op0) != result_type)
9346         op0 = convert_and_check (result_type, op0);
9347       if (TREE_TYPE (op1) != result_type)
9348         op1 = convert_and_check (result_type, op1);
9349
9350       /* This can happen if one operand has a vector type, and the other
9351          has a different type.  */
9352       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
9353         return error_mark_node;
9354     }
9355
9356   if (build_type == NULL_TREE)
9357     {
9358       build_type = result_type;
9359       if (type0 != orig_type0 || type1 != orig_type1)
9360         {
9361           gcc_assert (may_need_excess_precision && common);
9362           real_result_type = c_common_type (orig_type0, orig_type1);
9363         }
9364     }
9365
9366   /* Treat expressions in initializers specially as they can't trap.  */
9367   if (int_const_or_overflow)
9368     ret = (require_constant_value
9369            ? fold_build2_initializer (resultcode, build_type, op0, op1)
9370            : fold_build2 (resultcode, build_type, op0, op1));
9371   else
9372     ret = build2 (resultcode, build_type, op0, op1);
9373   if (final_type != 0)
9374     ret = convert (final_type, ret);
9375
9376  return_build_binary_op:
9377   gcc_assert (ret != error_mark_node);
9378   if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
9379     ret = (int_operands
9380            ? note_integer_operands (ret)
9381            : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
9382   else if (TREE_CODE (ret) != INTEGER_CST && int_operands
9383            && !in_late_binary_op)
9384     ret = note_integer_operands (ret);
9385   if (real_result_type)
9386     ret = build1 (EXCESS_PRECISION_EXPR, real_result_type, ret);
9387   protected_set_expr_location (ret, location);
9388   return ret;
9389 }
9390
9391
9392 /* Convert EXPR to be a truth-value, validating its type for this
9393    purpose.  LOCATION is the source location for the expression.  */
9394
9395 tree
9396 c_objc_common_truthvalue_conversion (location_t location, tree expr)
9397 {
9398   bool int_const, int_operands;
9399
9400   switch (TREE_CODE (TREE_TYPE (expr)))
9401     {
9402     case ARRAY_TYPE:
9403       error_at (location, "used array that cannot be converted to pointer where scalar is required");
9404       return error_mark_node;
9405
9406     case RECORD_TYPE:
9407       error_at (location, "used struct type value where scalar is required");
9408       return error_mark_node;
9409
9410     case UNION_TYPE:
9411       error_at (location, "used union type value where scalar is required");
9412       return error_mark_node;
9413
9414     case FUNCTION_TYPE:
9415       gcc_unreachable ();
9416
9417     default:
9418       break;
9419     }
9420
9421   int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
9422   int_operands = EXPR_INT_CONST_OPERANDS (expr);
9423   if (int_operands)
9424     expr = remove_c_maybe_const_expr (expr);
9425
9426   /* ??? Should we also give an error for void and vectors rather than
9427      leaving those to give errors later?  */
9428   expr = c_common_truthvalue_conversion (location, expr);
9429
9430   if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
9431     {
9432       if (TREE_OVERFLOW (expr))
9433         return expr;
9434       else
9435         return note_integer_operands (expr);
9436     }
9437   if (TREE_CODE (expr) == INTEGER_CST && !int_const)
9438     return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
9439   return expr;
9440 }
9441 \f
9442
9443 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
9444    required.  */
9445
9446 tree
9447 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
9448 {
9449   if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
9450     {
9451       tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
9452       /* Executing a compound literal inside a function reinitializes
9453          it.  */
9454       if (!TREE_STATIC (decl))
9455         *se = true;
9456       return decl;
9457     }
9458   else
9459     return expr;
9460 }
9461 \f
9462 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
9463
9464 tree
9465 c_begin_omp_parallel (void)
9466 {
9467   tree block;
9468
9469   keep_next_level ();
9470   block = c_begin_compound_stmt (true);
9471
9472   return block;
9473 }
9474
9475 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound statement.  */
9476
9477 tree
9478 c_finish_omp_parallel (tree clauses, tree block)
9479 {
9480   tree stmt;
9481
9482   block = c_end_compound_stmt (block, true);
9483
9484   stmt = make_node (OMP_PARALLEL);
9485   TREE_TYPE (stmt) = void_type_node;
9486   OMP_PARALLEL_CLAUSES (stmt) = clauses;
9487   OMP_PARALLEL_BODY (stmt) = block;
9488
9489   return add_stmt (stmt);
9490 }
9491
9492 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
9493
9494 tree
9495 c_begin_omp_task (void)
9496 {
9497   tree block;
9498
9499   keep_next_level ();
9500   block = c_begin_compound_stmt (true);
9501
9502   return block;
9503 }
9504
9505 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound statement.  */
9506
9507 tree
9508 c_finish_omp_task (tree clauses, tree block)
9509 {
9510   tree stmt;
9511
9512   block = c_end_compound_stmt (block, true);
9513
9514   stmt = make_node (OMP_TASK);
9515   TREE_TYPE (stmt) = void_type_node;
9516   OMP_TASK_CLAUSES (stmt) = clauses;
9517   OMP_TASK_BODY (stmt) = block;
9518
9519   return add_stmt (stmt);
9520 }
9521
9522 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
9523    Remove any elements from the list that are invalid.  */
9524
9525 tree
9526 c_finish_omp_clauses (tree clauses)
9527 {
9528   bitmap_head generic_head, firstprivate_head, lastprivate_head;
9529   tree c, t, *pc = &clauses;
9530   const char *name;
9531
9532   bitmap_obstack_initialize (NULL);
9533   bitmap_initialize (&generic_head, &bitmap_default_obstack);
9534   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
9535   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
9536
9537   for (pc = &clauses, c = clauses; c ; c = *pc)
9538     {
9539       bool remove = false;
9540       bool need_complete = false;
9541       bool need_implicitly_determined = false;
9542
9543       switch (OMP_CLAUSE_CODE (c))
9544         {
9545         case OMP_CLAUSE_SHARED:
9546           name = "shared";
9547           need_implicitly_determined = true;
9548           goto check_dup_generic;
9549
9550         case OMP_CLAUSE_PRIVATE:
9551           name = "private";
9552           need_complete = true;
9553           need_implicitly_determined = true;
9554           goto check_dup_generic;
9555
9556         case OMP_CLAUSE_REDUCTION:
9557           name = "reduction";
9558           need_implicitly_determined = true;
9559           t = OMP_CLAUSE_DECL (c);
9560           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
9561               || POINTER_TYPE_P (TREE_TYPE (t)))
9562             {
9563               error ("%qE has invalid type for %<reduction%>", t);
9564               remove = true;
9565             }
9566           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
9567             {
9568               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
9569               const char *r_name = NULL;
9570
9571               switch (r_code)
9572                 {
9573                 case PLUS_EXPR:
9574                 case MULT_EXPR:
9575                 case MINUS_EXPR:
9576                   break;
9577                 case BIT_AND_EXPR:
9578                   r_name = "&";
9579                   break;
9580                 case BIT_XOR_EXPR:
9581                   r_name = "^";
9582                   break;
9583                 case BIT_IOR_EXPR:
9584                   r_name = "|";
9585                   break;
9586                 case TRUTH_ANDIF_EXPR:
9587                   r_name = "&&";
9588                   break;
9589                 case TRUTH_ORIF_EXPR:
9590                   r_name = "||";
9591                   break;
9592                 default:
9593                   gcc_unreachable ();
9594                 }
9595               if (r_name)
9596                 {
9597                   error ("%qE has invalid type for %<reduction(%s)%>",
9598                          t, r_name);
9599                   remove = true;
9600                 }
9601             }
9602           goto check_dup_generic;
9603
9604         case OMP_CLAUSE_COPYPRIVATE:
9605           name = "copyprivate";
9606           goto check_dup_generic;
9607
9608         case OMP_CLAUSE_COPYIN:
9609           name = "copyin";
9610           t = OMP_CLAUSE_DECL (c);
9611           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
9612             {
9613               error ("%qE must be %<threadprivate%> for %<copyin%>", t);
9614               remove = true;
9615             }
9616           goto check_dup_generic;
9617
9618         check_dup_generic:
9619           t = OMP_CLAUSE_DECL (c);
9620           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9621             {
9622               error ("%qE is not a variable in clause %qs", t, name);
9623               remove = true;
9624             }
9625           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
9626                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
9627                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
9628             {
9629               error ("%qE appears more than once in data clauses", t);
9630               remove = true;
9631             }
9632           else
9633             bitmap_set_bit (&generic_head, DECL_UID (t));
9634           break;
9635
9636         case OMP_CLAUSE_FIRSTPRIVATE:
9637           name = "firstprivate";
9638           t = OMP_CLAUSE_DECL (c);
9639           need_complete = true;
9640           need_implicitly_determined = true;
9641           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9642             {
9643               error ("%qE is not a variable in clause %<firstprivate%>", t);
9644               remove = true;
9645             }
9646           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
9647                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
9648             {
9649               error ("%qE appears more than once in data clauses", t);
9650               remove = true;
9651             }
9652           else
9653             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
9654           break;
9655
9656         case OMP_CLAUSE_LASTPRIVATE:
9657           name = "lastprivate";
9658           t = OMP_CLAUSE_DECL (c);
9659           need_complete = true;
9660           need_implicitly_determined = true;
9661           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9662             {
9663               error ("%qE is not a variable in clause %<lastprivate%>", t);
9664               remove = true;
9665             }
9666           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
9667                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
9668             {
9669               error ("%qE appears more than once in data clauses", t);
9670               remove = true;
9671             }
9672           else
9673             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
9674           break;
9675
9676         case OMP_CLAUSE_IF:
9677         case OMP_CLAUSE_NUM_THREADS:
9678         case OMP_CLAUSE_SCHEDULE:
9679         case OMP_CLAUSE_NOWAIT:
9680         case OMP_CLAUSE_ORDERED:
9681         case OMP_CLAUSE_DEFAULT:
9682         case OMP_CLAUSE_UNTIED:
9683         case OMP_CLAUSE_COLLAPSE:
9684           pc = &OMP_CLAUSE_CHAIN (c);
9685           continue;
9686
9687         default:
9688           gcc_unreachable ();
9689         }
9690
9691       if (!remove)
9692         {
9693           t = OMP_CLAUSE_DECL (c);
9694
9695           if (need_complete)
9696             {
9697               t = require_complete_type (t);
9698               if (t == error_mark_node)
9699                 remove = true;
9700             }
9701
9702           if (need_implicitly_determined)
9703             {
9704               const char *share_name = NULL;
9705
9706               if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
9707                 share_name = "threadprivate";
9708               else switch (c_omp_predetermined_sharing (t))
9709                 {
9710                 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
9711                   break;
9712                 case OMP_CLAUSE_DEFAULT_SHARED:
9713                   share_name = "shared";
9714                   break;
9715                 case OMP_CLAUSE_DEFAULT_PRIVATE:
9716                   share_name = "private";
9717                   break;
9718                 default:
9719                   gcc_unreachable ();
9720                 }
9721               if (share_name)
9722                 {
9723                   error ("%qE is predetermined %qs for %qs",
9724                          t, share_name, name);
9725                   remove = true;
9726                 }
9727             }
9728         }
9729
9730       if (remove)
9731         *pc = OMP_CLAUSE_CHAIN (c);
9732       else
9733         pc = &OMP_CLAUSE_CHAIN (c);
9734     }
9735
9736   bitmap_obstack_release (NULL);
9737   return clauses;
9738 }
9739
9740 /* Make a variant type in the proper way for C/C++, propagating qualifiers
9741    down to the element type of an array.  */
9742
9743 tree
9744 c_build_qualified_type (tree type, int type_quals)
9745 {
9746   if (type == error_mark_node)
9747     return type;
9748
9749   if (TREE_CODE (type) == ARRAY_TYPE)
9750     {
9751       tree t;
9752       tree element_type = c_build_qualified_type (TREE_TYPE (type),
9753                                                   type_quals);
9754
9755       /* See if we already have an identically qualified type.  */
9756       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
9757         {
9758           if (TYPE_QUALS (strip_array_types (t)) == type_quals
9759               && TYPE_NAME (t) == TYPE_NAME (type)
9760               && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
9761               && attribute_list_equal (TYPE_ATTRIBUTES (t),
9762                                        TYPE_ATTRIBUTES (type)))
9763             break;
9764         }
9765       if (!t)
9766         {
9767           tree domain = TYPE_DOMAIN (type);
9768
9769           t = build_variant_type_copy (type);
9770           TREE_TYPE (t) = element_type;
9771
9772           if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
9773               || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
9774             SET_TYPE_STRUCTURAL_EQUALITY (t);
9775           else if (TYPE_CANONICAL (element_type) != element_type
9776                    || (domain && TYPE_CANONICAL (domain) != domain))
9777             {
9778               tree unqualified_canon
9779                 = build_array_type (TYPE_CANONICAL (element_type),
9780                                     domain? TYPE_CANONICAL (domain)
9781                                           : NULL_TREE);
9782               TYPE_CANONICAL (t)
9783                 = c_build_qualified_type (unqualified_canon, type_quals);
9784             }
9785           else
9786             TYPE_CANONICAL (t) = t;
9787         }
9788       return t;
9789     }
9790
9791   /* A restrict-qualified pointer type must be a pointer to object or
9792      incomplete type.  Note that the use of POINTER_TYPE_P also allows
9793      REFERENCE_TYPEs, which is appropriate for C++.  */
9794   if ((type_quals & TYPE_QUAL_RESTRICT)
9795       && (!POINTER_TYPE_P (type)
9796           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
9797     {
9798       error ("invalid use of %<restrict%>");
9799       type_quals &= ~TYPE_QUAL_RESTRICT;
9800     }
9801
9802   return build_qualified_type (type, type_quals);
9803 }