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    If LHS_ORIGTYPE is not NULL, it is the original type of LHS, which
4296    may differ from TREE_TYPE (LHS) for an enum bitfield.
4297    MODIFYCODE is the code for a binary operator that we use
4298    to combine the old value of LHS with RHS to get the new value.
4299    Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment.
4300    If RHS_ORIGTYPE is not NULL_TREE, it is the original type of RHS,
4301    which may differ from TREE_TYPE (RHS) for an enum value.
4302
4303    LOCATION is the location of the MODIFYCODE operator.  */
4304
4305 tree
4306 build_modify_expr (location_t location, tree lhs, tree lhs_origtype,
4307                    enum tree_code modifycode, tree rhs, tree rhs_origtype)
4308 {
4309   tree result;
4310   tree newrhs;
4311   tree rhs_semantic_type = NULL_TREE;
4312   tree lhstype = TREE_TYPE (lhs);
4313   tree olhstype = lhstype;
4314   bool npc;
4315
4316   /* Types that aren't fully specified cannot be used in assignments.  */
4317   lhs = require_complete_type (lhs);
4318
4319   /* Avoid duplicate error messages from operands that had errors.  */
4320   if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK)
4321     return error_mark_node;
4322
4323   if (!lvalue_or_else (lhs, lv_assign))
4324     return error_mark_node;
4325
4326   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4327     {
4328       rhs_semantic_type = TREE_TYPE (rhs);
4329       rhs = TREE_OPERAND (rhs, 0);
4330     }
4331
4332   newrhs = rhs;
4333
4334   if (TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
4335     {
4336       tree inner = build_modify_expr (location, C_MAYBE_CONST_EXPR_EXPR (lhs),
4337                                       lhs_origtype, modifycode, rhs,
4338                                       rhs_origtype);
4339       if (inner == error_mark_node)
4340         return error_mark_node;
4341       result = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (inner),
4342                        C_MAYBE_CONST_EXPR_PRE (lhs), inner);
4343       gcc_assert (!C_MAYBE_CONST_EXPR_INT_OPERANDS (lhs));
4344       C_MAYBE_CONST_EXPR_NON_CONST (result) = 1;
4345       protected_set_expr_location (result, location);
4346       return result;
4347     }
4348
4349   /* If a binary op has been requested, combine the old LHS value with the RHS
4350      producing the value we should actually store into the LHS.  */
4351
4352   if (modifycode != NOP_EXPR)
4353     {
4354       lhs = c_fully_fold (lhs, false, NULL);
4355       lhs = stabilize_reference (lhs);
4356       newrhs = build_binary_op (location,
4357                                 modifycode, lhs, rhs, 1);
4358
4359       /* The original type of the right hand side is no longer
4360          meaningful.  */
4361       rhs_origtype = NULL_TREE;
4362     }
4363
4364   /* Give an error for storing in something that is 'const'.  */
4365
4366   if (TYPE_READONLY (lhstype)
4367       || ((TREE_CODE (lhstype) == RECORD_TYPE
4368            || TREE_CODE (lhstype) == UNION_TYPE)
4369           && C_TYPE_FIELDS_READONLY (lhstype)))
4370     {
4371       readonly_error (lhs, lv_assign);
4372       return error_mark_node;
4373     }
4374   else if (TREE_READONLY (lhs))
4375     readonly_warning (lhs, lv_assign);
4376
4377   /* If storing into a structure or union member,
4378      it has probably been given type `int'.
4379      Compute the type that would go with
4380      the actual amount of storage the member occupies.  */
4381
4382   if (TREE_CODE (lhs) == COMPONENT_REF
4383       && (TREE_CODE (lhstype) == INTEGER_TYPE
4384           || TREE_CODE (lhstype) == BOOLEAN_TYPE
4385           || TREE_CODE (lhstype) == REAL_TYPE
4386           || TREE_CODE (lhstype) == ENUMERAL_TYPE))
4387     lhstype = TREE_TYPE (get_unwidened (lhs, 0));
4388
4389   /* If storing in a field that is in actuality a short or narrower than one,
4390      we must store in the field in its actual type.  */
4391
4392   if (lhstype != TREE_TYPE (lhs))
4393     {
4394       lhs = copy_node (lhs);
4395       TREE_TYPE (lhs) = lhstype;
4396     }
4397
4398   /* Issue -Wc++-compat warnings about an assignment to an enum type
4399      when LHS does not have its original type.  This happens for,
4400      e.g., an enum bitfield in a struct.  */
4401   if (warn_cxx_compat
4402       && lhs_origtype != NULL_TREE
4403       && lhs_origtype != lhstype
4404       && TREE_CODE (lhs_origtype) == ENUMERAL_TYPE)
4405     {
4406       tree checktype = (rhs_origtype != NULL_TREE
4407                         ? rhs_origtype
4408                         : TREE_TYPE (rhs));
4409       if (checktype != error_mark_node
4410           && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (lhs_origtype))
4411         warning_at (location, OPT_Wc___compat,
4412                     "enum conversion in assignment is invalid in C++");
4413     }
4414
4415   /* Convert new value to destination type.  Fold it first, then
4416      restore any excess precision information, for the sake of
4417      conversion warnings.  */
4418
4419   npc = null_pointer_constant_p (newrhs);
4420   newrhs = c_fully_fold (newrhs, false, NULL);
4421   if (rhs_semantic_type)
4422     newrhs = build1 (EXCESS_PRECISION_EXPR, rhs_semantic_type, newrhs);
4423   newrhs = convert_for_assignment (lhstype, newrhs, rhs_origtype, ic_assign,
4424                                    npc, NULL_TREE, NULL_TREE, 0);
4425   if (TREE_CODE (newrhs) == ERROR_MARK)
4426     return error_mark_node;
4427
4428   /* Emit ObjC write barrier, if necessary.  */
4429   if (c_dialect_objc () && flag_objc_gc)
4430     {
4431       result = objc_generate_write_barrier (lhs, modifycode, newrhs);
4432       if (result)
4433         {
4434           protected_set_expr_location (result, location);
4435           return result;
4436         }
4437     }
4438
4439   /* Scan operands.  */
4440
4441   result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs);
4442   TREE_SIDE_EFFECTS (result) = 1;
4443   protected_set_expr_location (result, location);
4444
4445   /* If we got the LHS in a different type for storing in,
4446      convert the result back to the nominal type of LHS
4447      so that the value we return always has the same type
4448      as the LHS argument.  */
4449
4450   if (olhstype == TREE_TYPE (result))
4451     return result;
4452
4453   result = convert_for_assignment (olhstype, result, rhs_origtype, ic_assign,
4454                                    false, NULL_TREE, NULL_TREE, 0);
4455   protected_set_expr_location (result, location);
4456   return result;
4457 }
4458 \f
4459 /* Convert value RHS to type TYPE as preparation for an assignment to
4460    an lvalue of type TYPE.  If ORIGTYPE is not NULL_TREE, it is the
4461    original type of RHS; this differs from TREE_TYPE (RHS) for enum
4462    types.  NULL_POINTER_CONSTANT says whether RHS was a null pointer
4463    constant before any folding.
4464    The real work of conversion is done by `convert'.
4465    The purpose of this function is to generate error messages
4466    for assignments that are not allowed in C.
4467    ERRTYPE says whether it is argument passing, assignment,
4468    initialization or return.
4469
4470    FUNCTION is a tree for the function being called.
4471    PARMNUM is the number of the argument, for printing in error messages.  */
4472
4473 static tree
4474 convert_for_assignment (tree type, tree rhs, tree origtype,
4475                         enum impl_conv errtype, bool null_pointer_constant,
4476                         tree fundecl, tree function, int parmnum)
4477 {
4478   enum tree_code codel = TREE_CODE (type);
4479   tree orig_rhs = rhs;
4480   tree rhstype;
4481   enum tree_code coder;
4482   tree rname = NULL_TREE;
4483   bool objc_ok = false;
4484
4485   if (errtype == ic_argpass)
4486     {
4487       tree selector;
4488       /* Change pointer to function to the function itself for
4489          diagnostics.  */
4490       if (TREE_CODE (function) == ADDR_EXPR
4491           && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL)
4492         function = TREE_OPERAND (function, 0);
4493
4494       /* Handle an ObjC selector specially for diagnostics.  */
4495       selector = objc_message_selector ();
4496       rname = function;
4497       if (selector && parmnum > 2)
4498         {
4499           rname = selector;
4500           parmnum -= 2;
4501         }
4502     }
4503
4504   /* This macro is used to emit diagnostics to ensure that all format
4505      strings are complete sentences, visible to gettext and checked at
4506      compile time.  */
4507 #define WARN_FOR_ASSIGNMENT(LOCATION, OPT, AR, AS, IN, RE)               \
4508   do {                                                                   \
4509     switch (errtype)                                                     \
4510       {                                                                  \
4511       case ic_argpass:                                                   \
4512         if (pedwarn (LOCATION, OPT, AR, parmnum, rname))                 \
4513           inform ((fundecl && !DECL_IS_BUILTIN (fundecl))                \
4514                   ? DECL_SOURCE_LOCATION (fundecl) : LOCATION,           \
4515                   "expected %qT but argument is of type %qT",            \
4516                   type, rhstype);                                        \
4517         break;                                                           \
4518       case ic_assign:                                                    \
4519         pedwarn (LOCATION, OPT, AS);                                     \
4520         break;                                                           \
4521       case ic_init:                                                      \
4522         pedwarn (LOCATION, OPT, IN);                                     \
4523         break;                                                           \
4524       case ic_return:                                                    \
4525         pedwarn (LOCATION, OPT, RE);                                     \
4526         break;                                                           \
4527       default:                                                           \
4528         gcc_unreachable ();                                              \
4529       }                                                                  \
4530   } while (0)
4531
4532   if (TREE_CODE (rhs) == EXCESS_PRECISION_EXPR)
4533     rhs = TREE_OPERAND (rhs, 0);
4534
4535   rhstype = TREE_TYPE (rhs);
4536   coder = TREE_CODE (rhstype);
4537
4538   if (coder == ERROR_MARK)
4539     return error_mark_node;
4540
4541   if (c_dialect_objc ())
4542     {
4543       int parmno;
4544
4545       switch (errtype)
4546         {
4547         case ic_return:
4548           parmno = 0;
4549           break;
4550
4551         case ic_assign:
4552           parmno = -1;
4553           break;
4554
4555         case ic_init:
4556           parmno = -2;
4557           break;
4558
4559         default:
4560           parmno = parmnum;
4561           break;
4562         }
4563
4564       objc_ok = objc_compare_types (type, rhstype, parmno, rname);
4565     }
4566
4567   if (warn_cxx_compat)
4568     {
4569       tree checktype = origtype != NULL_TREE ? origtype : rhstype;
4570       if (checktype != error_mark_node
4571           && TREE_CODE (type) == ENUMERAL_TYPE
4572           && TYPE_MAIN_VARIANT (checktype) != TYPE_MAIN_VARIANT (type))
4573         {
4574           /* FIXME: Until the gcc source code is converted, we only
4575              warn about assignment and parameter passing.  We will add
4576              the other cases when bootstrap succeeds with them.  */
4577           if (errtype == ic_argpass || errtype == ic_assign)
4578             {
4579               WARN_FOR_ASSIGNMENT (input_location, OPT_Wc___compat,
4580                                    G_("enum conversion when passing argument "
4581                                       "%d of %qE is invalid in C++"),
4582                                    G_("enum conversion in assignment is "
4583                                       "invalid in C++"),
4584                                    G_("enum conversion in initialization is "
4585                                       "invalid in C++"),
4586                                    G_("enum conversion in return is "
4587                                       "invalid in C++"));
4588             }
4589         }
4590     }
4591
4592   if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype))
4593     return rhs;
4594
4595   if (coder == VOID_TYPE)
4596     {
4597       /* Except for passing an argument to an unprototyped function,
4598          this is a constraint violation.  When passing an argument to
4599          an unprototyped function, it is compile-time undefined;
4600          making it a constraint in that case was rejected in
4601          DR#252.  */
4602       error ("void value not ignored as it ought to be");
4603       return error_mark_node;
4604     }
4605   rhs = require_complete_type (rhs);
4606   if (rhs == error_mark_node)
4607     return error_mark_node;
4608   /* A type converts to a reference to it.
4609      This code doesn't fully support references, it's just for the
4610      special case of va_start and va_copy.  */
4611   if (codel == REFERENCE_TYPE
4612       && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1)
4613     {
4614       if (!lvalue_p (rhs))
4615         {
4616           error ("cannot pass rvalue to reference parameter");
4617           return error_mark_node;
4618         }
4619       if (!c_mark_addressable (rhs))
4620         return error_mark_node;
4621       rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs);
4622
4623       /* We already know that these two types are compatible, but they
4624          may not be exactly identical.  In fact, `TREE_TYPE (type)' is
4625          likely to be __builtin_va_list and `TREE_TYPE (rhs)' is
4626          likely to be va_list, a typedef to __builtin_va_list, which
4627          is different enough that it will cause problems later.  */
4628       if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type))
4629         rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs);
4630
4631       rhs = build1 (NOP_EXPR, type, rhs);
4632       return rhs;
4633     }
4634   /* Some types can interconvert without explicit casts.  */
4635   else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE
4636            && vector_types_convertible_p (type, TREE_TYPE (rhs), true))
4637     return convert (type, rhs);
4638   /* Arithmetic types all interconvert, and enum is treated like int.  */
4639   else if ((codel == INTEGER_TYPE || codel == REAL_TYPE
4640             || codel == FIXED_POINT_TYPE
4641             || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE
4642             || codel == BOOLEAN_TYPE)
4643            && (coder == INTEGER_TYPE || coder == REAL_TYPE
4644                || coder == FIXED_POINT_TYPE
4645                || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE
4646                || coder == BOOLEAN_TYPE))
4647     {
4648       tree ret;
4649       bool save = in_late_binary_op;
4650       if (codel == BOOLEAN_TYPE)
4651         in_late_binary_op = true;
4652       ret = convert_and_check (type, orig_rhs);
4653       if (codel == BOOLEAN_TYPE)
4654         in_late_binary_op = save;
4655       return ret;
4656     }
4657
4658   /* Aggregates in different TUs might need conversion.  */
4659   if ((codel == RECORD_TYPE || codel == UNION_TYPE)
4660       && codel == coder
4661       && comptypes (type, rhstype))
4662     return convert_and_check (type, rhs);
4663
4664   /* Conversion to a transparent union from its member types.
4665      This applies only to function arguments.  */
4666   if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type)
4667       && errtype == ic_argpass)
4668     {
4669       tree memb, marginal_memb = NULL_TREE;
4670
4671       for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb))
4672         {
4673           tree memb_type = TREE_TYPE (memb);
4674
4675           if (comptypes (TYPE_MAIN_VARIANT (memb_type),
4676                          TYPE_MAIN_VARIANT (rhstype)))
4677             break;
4678
4679           if (TREE_CODE (memb_type) != POINTER_TYPE)
4680             continue;
4681
4682           if (coder == POINTER_TYPE)
4683             {
4684               tree ttl = TREE_TYPE (memb_type);
4685               tree ttr = TREE_TYPE (rhstype);
4686
4687               /* Any non-function converts to a [const][volatile] void *
4688                  and vice versa; otherwise, targets must be the same.
4689                  Meanwhile, the lhs target must have all the qualifiers of
4690                  the rhs.  */
4691               if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4692                   || comp_target_types (memb_type, rhstype))
4693                 {
4694                   /* If this type won't generate any warnings, use it.  */
4695                   if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr)
4696                       || ((TREE_CODE (ttr) == FUNCTION_TYPE
4697                            && TREE_CODE (ttl) == FUNCTION_TYPE)
4698                           ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4699                              == TYPE_QUALS (ttr))
4700                           : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr))
4701                              == TYPE_QUALS (ttl))))
4702                     break;
4703
4704                   /* Keep looking for a better type, but remember this one.  */
4705                   if (!marginal_memb)
4706                     marginal_memb = memb;
4707                 }
4708             }
4709
4710           /* Can convert integer zero to any pointer type.  */
4711           if (null_pointer_constant)
4712             {
4713               rhs = null_pointer_node;
4714               break;
4715             }
4716         }
4717
4718       if (memb || marginal_memb)
4719         {
4720           if (!memb)
4721             {
4722               /* We have only a marginally acceptable member type;
4723                  it needs a warning.  */
4724               tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb));
4725               tree ttr = TREE_TYPE (rhstype);
4726
4727               /* Const and volatile mean something different for function
4728                  types, so the usual warnings are not appropriate.  */
4729               if (TREE_CODE (ttr) == FUNCTION_TYPE
4730                   && TREE_CODE (ttl) == FUNCTION_TYPE)
4731                 {
4732                   /* Because const and volatile on functions are
4733                      restrictions that say the function will not do
4734                      certain things, it is okay to use a const or volatile
4735                      function where an ordinary one is wanted, but not
4736                      vice-versa.  */
4737                   if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4738                     WARN_FOR_ASSIGNMENT (input_location, 0,
4739                                          G_("passing argument %d of %qE "
4740                                             "makes qualified function "
4741                                             "pointer from unqualified"),
4742                                          G_("assignment makes qualified "
4743                                             "function pointer from "
4744                                             "unqualified"),
4745                                          G_("initialization makes qualified "
4746                                             "function pointer from "
4747                                             "unqualified"),
4748                                          G_("return makes qualified function "
4749                                             "pointer from unqualified"));
4750                 }
4751               else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4752                 WARN_FOR_ASSIGNMENT (input_location, 0,
4753                                      G_("passing argument %d of %qE discards "
4754                                         "qualifiers from pointer target type"),
4755                                      G_("assignment discards qualifiers "
4756                                         "from pointer target type"),
4757                                      G_("initialization discards qualifiers "
4758                                         "from pointer target type"),
4759                                      G_("return discards qualifiers from "
4760                                         "pointer target type"));
4761
4762               memb = marginal_memb;
4763             }
4764
4765           if (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))
4766             pedwarn (input_location, OPT_pedantic,
4767                      "ISO C prohibits argument conversion to union type");
4768
4769           rhs = fold_convert (TREE_TYPE (memb), rhs);
4770           return build_constructor_single (type, memb, rhs);
4771         }
4772     }
4773
4774   /* Conversions among pointers */
4775   else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE)
4776            && (coder == codel))
4777     {
4778       tree ttl = TREE_TYPE (type);
4779       tree ttr = TREE_TYPE (rhstype);
4780       tree mvl = ttl;
4781       tree mvr = ttr;
4782       bool is_opaque_pointer;
4783       int target_cmp = 0;   /* Cache comp_target_types () result.  */
4784
4785       if (TREE_CODE (mvl) != ARRAY_TYPE)
4786         mvl = TYPE_MAIN_VARIANT (mvl);
4787       if (TREE_CODE (mvr) != ARRAY_TYPE)
4788         mvr = TYPE_MAIN_VARIANT (mvr);
4789       /* Opaque pointers are treated like void pointers.  */
4790       is_opaque_pointer = vector_targets_convertible_p (ttl, ttr);
4791
4792       /* C++ does not allow the implicit conversion void* -> T*.  However,
4793          for the purpose of reducing the number of false positives, we
4794          tolerate the special case of
4795
4796                 int *p = NULL;
4797
4798          where NULL is typically defined in C to be '(void *) 0'.  */
4799       if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl))
4800         warning (OPT_Wc___compat, "request for implicit conversion from "
4801                  "%qT to %qT not permitted in C++", rhstype, type);
4802
4803       /* Check if the right-hand side has a format attribute but the
4804          left-hand side doesn't.  */
4805       if (warn_missing_format_attribute
4806           && check_missing_format_attribute (type, rhstype))
4807         {
4808           switch (errtype)
4809           {
4810           case ic_argpass:
4811             warning (OPT_Wmissing_format_attribute,
4812                      "argument %d of %qE might be "
4813                      "a candidate for a format attribute",
4814                      parmnum, rname);
4815             break;
4816           case ic_assign:
4817             warning (OPT_Wmissing_format_attribute,
4818                      "assignment left-hand side might be "
4819                      "a candidate for a format attribute");
4820             break;
4821           case ic_init:
4822             warning (OPT_Wmissing_format_attribute,
4823                      "initialization left-hand side might be "
4824                      "a candidate for a format attribute");
4825             break;
4826           case ic_return:
4827             warning (OPT_Wmissing_format_attribute,
4828                      "return type might be "
4829                      "a candidate for a format attribute");
4830             break;
4831           default:
4832             gcc_unreachable ();
4833           }
4834         }
4835
4836       /* Any non-function converts to a [const][volatile] void *
4837          and vice versa; otherwise, targets must be the same.
4838          Meanwhile, the lhs target must have all the qualifiers of the rhs.  */
4839       if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4840           || (target_cmp = comp_target_types (type, rhstype))
4841           || is_opaque_pointer
4842           || (c_common_unsigned_type (mvl)
4843               == c_common_unsigned_type (mvr)))
4844         {
4845           if (pedantic
4846               && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE)
4847                   ||
4848                   (VOID_TYPE_P (ttr)
4849                    && !null_pointer_constant
4850                    && TREE_CODE (ttl) == FUNCTION_TYPE)))
4851             WARN_FOR_ASSIGNMENT (input_location, OPT_pedantic,
4852                                  G_("ISO C forbids passing argument %d of "
4853                                     "%qE between function pointer "
4854                                     "and %<void *%>"),
4855                                  G_("ISO C forbids assignment between "
4856                                     "function pointer and %<void *%>"),
4857                                  G_("ISO C forbids initialization between "
4858                                     "function pointer and %<void *%>"),
4859                                  G_("ISO C forbids return between function "
4860                                     "pointer and %<void *%>"));
4861           /* Const and volatile mean something different for function types,
4862              so the usual warnings are not appropriate.  */
4863           else if (TREE_CODE (ttr) != FUNCTION_TYPE
4864                    && TREE_CODE (ttl) != FUNCTION_TYPE)
4865             {
4866               if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl))
4867                 {
4868                   /* Types differing only by the presence of the 'volatile'
4869                      qualifier are acceptable if the 'volatile' has been added
4870                      in by the Objective-C EH machinery.  */
4871                   if (!objc_type_quals_match (ttl, ttr))
4872                     WARN_FOR_ASSIGNMENT (input_location, 0,
4873                                          G_("passing argument %d of %qE discards "
4874                                             "qualifiers from pointer target type"),
4875                                          G_("assignment discards qualifiers "
4876                                             "from pointer target type"),
4877                                          G_("initialization discards qualifiers "
4878                                             "from pointer target type"),
4879                                          G_("return discards qualifiers from "
4880                                             "pointer target type"));
4881                 }
4882               /* If this is not a case of ignoring a mismatch in signedness,
4883                  no warning.  */
4884               else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr)
4885                        || target_cmp)
4886                 ;
4887               /* If there is a mismatch, do warn.  */
4888               else if (warn_pointer_sign)
4889                 WARN_FOR_ASSIGNMENT (input_location, OPT_Wpointer_sign,
4890                                      G_("pointer targets in passing argument "
4891                                         "%d of %qE differ in signedness"),
4892                                      G_("pointer targets in assignment "
4893                                         "differ in signedness"),
4894                                      G_("pointer targets in initialization "
4895                                         "differ in signedness"),
4896                                      G_("pointer targets in return differ "
4897                                         "in signedness"));
4898             }
4899           else if (TREE_CODE (ttl) == FUNCTION_TYPE
4900                    && TREE_CODE (ttr) == FUNCTION_TYPE)
4901             {
4902               /* Because const and volatile on functions are restrictions
4903                  that say the function will not do certain things,
4904                  it is okay to use a const or volatile function
4905                  where an ordinary one is wanted, but not vice-versa.  */
4906               if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr))
4907                 WARN_FOR_ASSIGNMENT (input_location, 0,
4908                                      G_("passing argument %d of %qE makes "
4909                                         "qualified function pointer "
4910                                         "from unqualified"),
4911                                      G_("assignment makes qualified function "
4912                                         "pointer from unqualified"),
4913                                      G_("initialization makes qualified "
4914                                         "function pointer from unqualified"),
4915                                      G_("return makes qualified function "
4916                                         "pointer from unqualified"));
4917             }
4918         }
4919       else
4920         /* Avoid warning about the volatile ObjC EH puts on decls.  */
4921         if (!objc_ok)
4922           WARN_FOR_ASSIGNMENT (input_location, 0,
4923                                G_("passing argument %d of %qE from "
4924                                   "incompatible pointer type"),
4925                                G_("assignment from incompatible pointer type"),
4926                                G_("initialization from incompatible "
4927                                   "pointer type"),
4928                                G_("return from incompatible pointer type"));
4929
4930       return convert (type, rhs);
4931     }
4932   else if (codel == POINTER_TYPE && coder == ARRAY_TYPE)
4933     {
4934       /* ??? This should not be an error when inlining calls to
4935          unprototyped functions.  */
4936       error ("invalid use of non-lvalue array");
4937       return error_mark_node;
4938     }
4939   else if (codel == POINTER_TYPE && coder == INTEGER_TYPE)
4940     {
4941       /* An explicit constant 0 can convert to a pointer,
4942          or one that results from arithmetic, even including
4943          a cast to integer type.  */
4944       if (!null_pointer_constant)
4945         WARN_FOR_ASSIGNMENT (input_location, 0,
4946                              G_("passing argument %d of %qE makes "
4947                                 "pointer from integer without a cast"),
4948                              G_("assignment makes pointer from integer "
4949                                 "without a cast"),
4950                              G_("initialization makes pointer from "
4951                                 "integer without a cast"),
4952                              G_("return makes pointer from integer "
4953                                 "without a cast"));
4954
4955       return convert (type, rhs);
4956     }
4957   else if (codel == INTEGER_TYPE && coder == POINTER_TYPE)
4958     {
4959       WARN_FOR_ASSIGNMENT (input_location, 0,
4960                            G_("passing argument %d of %qE makes integer "
4961                               "from pointer without a cast"),
4962                            G_("assignment makes integer from pointer "
4963                               "without a cast"),
4964                            G_("initialization makes integer from pointer "
4965                               "without a cast"),
4966                            G_("return makes integer from pointer "
4967                               "without a cast"));
4968       return convert (type, rhs);
4969     }
4970   else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE)
4971     {
4972       tree ret;
4973       bool save = in_late_binary_op;
4974       in_late_binary_op = true;
4975       ret = convert (type, rhs);
4976       in_late_binary_op = save;
4977       return ret;
4978     }
4979
4980   switch (errtype)
4981     {
4982     case ic_argpass:
4983       error ("incompatible type for argument %d of %qE", parmnum, rname);
4984       inform ((fundecl && !DECL_IS_BUILTIN (fundecl))
4985               ? DECL_SOURCE_LOCATION (fundecl) : input_location,
4986               "expected %qT but argument is of type %qT", type, rhstype);
4987       break;
4988     case ic_assign:
4989       error ("incompatible types when assigning to type %qT from type %qT",
4990              type, rhstype);
4991       break;
4992     case ic_init:
4993       error ("incompatible types when initializing type %qT using type %qT",
4994              type, rhstype);
4995       break;
4996     case ic_return:
4997       error ("incompatible types when returning type %qT but %qT was expected",
4998              rhstype, type);
4999       break;
5000     default:
5001       gcc_unreachable ();
5002     }
5003
5004   return error_mark_node;
5005 }
5006 \f
5007 /* If VALUE is a compound expr all of whose expressions are constant, then
5008    return its value.  Otherwise, return error_mark_node.
5009
5010    This is for handling COMPOUND_EXPRs as initializer elements
5011    which is allowed with a warning when -pedantic is specified.  */
5012
5013 static tree
5014 valid_compound_expr_initializer (tree value, tree endtype)
5015 {
5016   if (TREE_CODE (value) == COMPOUND_EXPR)
5017     {
5018       if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype)
5019           == error_mark_node)
5020         return error_mark_node;
5021       return valid_compound_expr_initializer (TREE_OPERAND (value, 1),
5022                                               endtype);
5023     }
5024   else if (!initializer_constant_valid_p (value, endtype))
5025     return error_mark_node;
5026   else
5027     return value;
5028 }
5029 \f
5030 /* Perform appropriate conversions on the initial value of a variable,
5031    store it in the declaration DECL,
5032    and print any error messages that are appropriate.
5033    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5034    If the init is invalid, store an ERROR_MARK.  */
5035
5036 void
5037 store_init_value (tree decl, tree init, tree origtype)
5038 {
5039   tree value, type;
5040   bool npc = false;
5041
5042   /* If variable's type was invalidly declared, just ignore it.  */
5043
5044   type = TREE_TYPE (decl);
5045   if (TREE_CODE (type) == ERROR_MARK)
5046     return;
5047
5048   /* Digest the specified initializer into an expression.  */
5049
5050   if (init)
5051     npc = null_pointer_constant_p (init);
5052   value = digest_init (type, init, origtype, npc, true, TREE_STATIC (decl));
5053
5054   /* Store the expression if valid; else report error.  */
5055
5056   if (!in_system_header
5057       && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl))
5058     warning (OPT_Wtraditional, "traditional C rejects automatic "
5059              "aggregate initialization");
5060
5061   DECL_INITIAL (decl) = value;
5062
5063   /* ANSI wants warnings about out-of-range constant initializers.  */
5064   STRIP_TYPE_NOPS (value);
5065   if (TREE_STATIC (decl))
5066     constant_expression_warning (value);
5067
5068   /* Check if we need to set array size from compound literal size.  */
5069   if (TREE_CODE (type) == ARRAY_TYPE
5070       && TYPE_DOMAIN (type) == 0
5071       && value != error_mark_node)
5072     {
5073       tree inside_init = init;
5074
5075       STRIP_TYPE_NOPS (inside_init);
5076       inside_init = fold (inside_init);
5077
5078       if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
5079         {
5080           tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
5081
5082           if (TYPE_DOMAIN (TREE_TYPE (cldecl)))
5083             {
5084               /* For int foo[] = (int [3]){1}; we need to set array size
5085                  now since later on array initializer will be just the
5086                  brace enclosed list of the compound literal.  */
5087               type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
5088               TREE_TYPE (decl) = type;
5089               TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl));
5090               layout_type (type);
5091               layout_decl (cldecl, 0);
5092             }
5093         }
5094     }
5095 }
5096 \f
5097 /* Methods for storing and printing names for error messages.  */
5098
5099 /* Implement a spelling stack that allows components of a name to be pushed
5100    and popped.  Each element on the stack is this structure.  */
5101
5102 struct spelling
5103 {
5104   int kind;
5105   union
5106     {
5107       unsigned HOST_WIDE_INT i;
5108       const char *s;
5109     } u;
5110 };
5111
5112 #define SPELLING_STRING 1
5113 #define SPELLING_MEMBER 2
5114 #define SPELLING_BOUNDS 3
5115
5116 static struct spelling *spelling;       /* Next stack element (unused).  */
5117 static struct spelling *spelling_base;  /* Spelling stack base.  */
5118 static int spelling_size;               /* Size of the spelling stack.  */
5119
5120 /* Macros to save and restore the spelling stack around push_... functions.
5121    Alternative to SAVE_SPELLING_STACK.  */
5122
5123 #define SPELLING_DEPTH() (spelling - spelling_base)
5124 #define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH))
5125
5126 /* Push an element on the spelling stack with type KIND and assign VALUE
5127    to MEMBER.  */
5128
5129 #define PUSH_SPELLING(KIND, VALUE, MEMBER)                              \
5130 {                                                                       \
5131   int depth = SPELLING_DEPTH ();                                        \
5132                                                                         \
5133   if (depth >= spelling_size)                                           \
5134     {                                                                   \
5135       spelling_size += 10;                                              \
5136       spelling_base = XRESIZEVEC (struct spelling, spelling_base,       \
5137                                   spelling_size);                       \
5138       RESTORE_SPELLING_DEPTH (depth);                                   \
5139     }                                                                   \
5140                                                                         \
5141   spelling->kind = (KIND);                                              \
5142   spelling->MEMBER = (VALUE);                                           \
5143   spelling++;                                                           \
5144 }
5145
5146 /* Push STRING on the stack.  Printed literally.  */
5147
5148 static void
5149 push_string (const char *string)
5150 {
5151   PUSH_SPELLING (SPELLING_STRING, string, u.s);
5152 }
5153
5154 /* Push a member name on the stack.  Printed as '.' STRING.  */
5155
5156 static void
5157 push_member_name (tree decl)
5158 {
5159   const char *const string
5160     = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>";
5161   PUSH_SPELLING (SPELLING_MEMBER, string, u.s);
5162 }
5163
5164 /* Push an array bounds on the stack.  Printed as [BOUNDS].  */
5165
5166 static void
5167 push_array_bounds (unsigned HOST_WIDE_INT bounds)
5168 {
5169   PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i);
5170 }
5171
5172 /* Compute the maximum size in bytes of the printed spelling.  */
5173
5174 static int
5175 spelling_length (void)
5176 {
5177   int size = 0;
5178   struct spelling *p;
5179
5180   for (p = spelling_base; p < spelling; p++)
5181     {
5182       if (p->kind == SPELLING_BOUNDS)
5183         size += 25;
5184       else
5185         size += strlen (p->u.s) + 1;
5186     }
5187
5188   return size;
5189 }
5190
5191 /* Print the spelling to BUFFER and return it.  */
5192
5193 static char *
5194 print_spelling (char *buffer)
5195 {
5196   char *d = buffer;
5197   struct spelling *p;
5198
5199   for (p = spelling_base; p < spelling; p++)
5200     if (p->kind == SPELLING_BOUNDS)
5201       {
5202         sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i);
5203         d += strlen (d);
5204       }
5205     else
5206       {
5207         const char *s;
5208         if (p->kind == SPELLING_MEMBER)
5209           *d++ = '.';
5210         for (s = p->u.s; (*d = *s++); d++)
5211           ;
5212       }
5213   *d++ = '\0';
5214   return buffer;
5215 }
5216
5217 /* Issue an error message for a bad initializer component.
5218    MSGID identifies the message.
5219    The component name is taken from the spelling stack.  */
5220
5221 void
5222 error_init (const char *msgid)
5223 {
5224   char *ofwhat;
5225
5226   error ("%s", _(msgid));
5227   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
5228   if (*ofwhat)
5229     error ("(near initialization for %qs)", ofwhat);
5230 }
5231
5232 /* Issue a pedantic warning for a bad initializer component.  OPT is
5233    the option OPT_* (from options.h) controlling this warning or 0 if
5234    it is unconditionally given.  MSGID identifies the message.  The
5235    component name is taken from the spelling stack.  */
5236
5237 void
5238 pedwarn_init (location_t location, int opt, const char *msgid)
5239 {
5240   char *ofwhat;
5241
5242   pedwarn (location, opt, "%s", _(msgid));
5243   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
5244   if (*ofwhat)
5245     pedwarn (location, opt, "(near initialization for %qs)", ofwhat);
5246 }
5247
5248 /* Issue a warning for a bad initializer component.
5249
5250    OPT is the OPT_W* value corresponding to the warning option that
5251    controls this warning.  MSGID identifies the message.  The
5252    component name is taken from the spelling stack.  */
5253
5254 static void
5255 warning_init (int opt, const char *msgid)
5256 {
5257   char *ofwhat;
5258
5259   warning (opt, "%s", _(msgid));
5260   ofwhat = print_spelling ((char *) alloca (spelling_length () + 1));
5261   if (*ofwhat)
5262     warning (opt, "(near initialization for %qs)", ofwhat);
5263 }
5264 \f
5265 /* If TYPE is an array type and EXPR is a parenthesized string
5266    constant, warn if pedantic that EXPR is being used to initialize an
5267    object of type TYPE.  */
5268
5269 void
5270 maybe_warn_string_init (tree type, struct c_expr expr)
5271 {
5272   if (pedantic
5273       && TREE_CODE (type) == ARRAY_TYPE
5274       && TREE_CODE (expr.value) == STRING_CST
5275       && expr.original_code != STRING_CST)
5276     pedwarn_init (input_location, OPT_pedantic,
5277                   "array initialized from parenthesized string constant");
5278 }
5279
5280 /* Digest the parser output INIT as an initializer for type TYPE.
5281    Return a C expression of type TYPE to represent the initial value.
5282
5283    If ORIGTYPE is not NULL_TREE, it is the original type of INIT.
5284
5285    NULL_POINTER_CONSTANT is true if INIT is a null pointer constant.
5286
5287    If INIT is a string constant, STRICT_STRING is true if it is
5288    unparenthesized or we should not warn here for it being parenthesized.
5289    For other types of INIT, STRICT_STRING is not used.
5290
5291    REQUIRE_CONSTANT requests an error if non-constant initializers or
5292    elements are seen.  */
5293
5294 static tree
5295 digest_init (tree type, tree init, tree origtype, bool null_pointer_constant,
5296              bool strict_string, int require_constant)
5297 {
5298   enum tree_code code = TREE_CODE (type);
5299   tree inside_init = init;
5300   tree semantic_type = NULL_TREE;
5301   bool maybe_const = true;
5302
5303   if (type == error_mark_node
5304       || !init
5305       || init == error_mark_node
5306       || TREE_TYPE (init) == error_mark_node)
5307     return error_mark_node;
5308
5309   STRIP_TYPE_NOPS (inside_init);
5310
5311   if (TREE_CODE (inside_init) == EXCESS_PRECISION_EXPR)
5312     {
5313       semantic_type = TREE_TYPE (inside_init);
5314       inside_init = TREE_OPERAND (inside_init, 0);
5315     }
5316   inside_init = c_fully_fold (inside_init, require_constant, &maybe_const);
5317   inside_init = decl_constant_value_for_optimization (inside_init);
5318
5319   /* Initialization of an array of chars from a string constant
5320      optionally enclosed in braces.  */
5321
5322   if (code == ARRAY_TYPE && inside_init
5323       && TREE_CODE (inside_init) == STRING_CST)
5324     {
5325       tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type));
5326       /* Note that an array could be both an array of character type
5327          and an array of wchar_t if wchar_t is signed char or unsigned
5328          char.  */
5329       bool char_array = (typ1 == char_type_node
5330                          || typ1 == signed_char_type_node
5331                          || typ1 == unsigned_char_type_node);
5332       bool wchar_array = !!comptypes (typ1, wchar_type_node);
5333       bool char16_array = !!comptypes (typ1, char16_type_node);
5334       bool char32_array = !!comptypes (typ1, char32_type_node);
5335
5336       if (char_array || wchar_array || char16_array || char32_array)
5337         {
5338           struct c_expr expr;
5339           tree typ2 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init)));
5340           expr.value = inside_init;
5341           expr.original_code = (strict_string ? STRING_CST : ERROR_MARK);
5342           expr.original_type = NULL;
5343           maybe_warn_string_init (type, expr);
5344
5345           if (TYPE_DOMAIN (type) && !TYPE_MAX_VALUE (TYPE_DOMAIN (type)))
5346             pedwarn_init (input_location, OPT_pedantic,
5347                           "initialization of a flexible array member");
5348
5349           if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
5350                          TYPE_MAIN_VARIANT (type)))
5351             return inside_init;
5352
5353           if (char_array)
5354             {
5355               if (typ2 != char_type_node)
5356                 {
5357                   error_init ("char-array initialized from wide string");
5358                   return error_mark_node;
5359                 }
5360             }
5361           else
5362             {
5363               if (typ2 == char_type_node)
5364                 {
5365                   error_init ("wide character array initialized from non-wide "
5366                               "string");
5367                   return error_mark_node;
5368                 }
5369               else if (!comptypes(typ1, typ2))
5370                 {
5371                   error_init ("wide character array initialized from "
5372                               "incompatible wide string");
5373                   return error_mark_node;
5374                 }
5375             }
5376
5377           TREE_TYPE (inside_init) = type;
5378           if (TYPE_DOMAIN (type) != 0
5379               && TYPE_SIZE (type) != 0
5380               && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
5381               /* Subtract the size of a single (possibly wide) character
5382                  because it's ok to ignore the terminating null char
5383                  that is counted in the length of the constant.  */
5384               && 0 > compare_tree_int (TYPE_SIZE_UNIT (type),
5385                                        TREE_STRING_LENGTH (inside_init)
5386                                        - (TYPE_PRECISION (typ1)
5387                                           / BITS_PER_UNIT)))
5388             pedwarn_init (input_location, 0,
5389                           "initializer-string for array of chars is too long");
5390
5391           return inside_init;
5392         }
5393       else if (INTEGRAL_TYPE_P (typ1))
5394         {
5395           error_init ("array of inappropriate type initialized "
5396                       "from string constant");
5397           return error_mark_node;
5398         }
5399     }
5400
5401   /* Build a VECTOR_CST from a *constant* vector constructor.  If the
5402      vector constructor is not constant (e.g. {1,2,3,foo()}) then punt
5403      below and handle as a constructor.  */
5404   if (code == VECTOR_TYPE
5405       && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE
5406       && vector_types_convertible_p (TREE_TYPE (inside_init), type, true)
5407       && TREE_CONSTANT (inside_init))
5408     {
5409       if (TREE_CODE (inside_init) == VECTOR_CST
5410           && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
5411                         TYPE_MAIN_VARIANT (type)))
5412         return inside_init;
5413
5414       if (TREE_CODE (inside_init) == CONSTRUCTOR)
5415         {
5416           unsigned HOST_WIDE_INT ix;
5417           tree value;
5418           bool constant_p = true;
5419
5420           /* Iterate through elements and check if all constructor
5421              elements are *_CSTs.  */
5422           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value)
5423             if (!CONSTANT_CLASS_P (value))
5424               {
5425                 constant_p = false;
5426                 break;
5427               }
5428
5429           if (constant_p)
5430             return build_vector_from_ctor (type,
5431                                            CONSTRUCTOR_ELTS (inside_init));
5432         }
5433     }
5434
5435   if (warn_sequence_point)
5436     verify_sequence_points (inside_init);
5437
5438   /* Any type can be initialized
5439      from an expression of the same type, optionally with braces.  */
5440
5441   if (inside_init && TREE_TYPE (inside_init) != 0
5442       && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)),
5443                      TYPE_MAIN_VARIANT (type))
5444           || (code == ARRAY_TYPE
5445               && comptypes (TREE_TYPE (inside_init), type))
5446           || (code == VECTOR_TYPE
5447               && comptypes (TREE_TYPE (inside_init), type))
5448           || (code == POINTER_TYPE
5449               && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE
5450               && comptypes (TREE_TYPE (TREE_TYPE (inside_init)),
5451                             TREE_TYPE (type)))))
5452     {
5453       if (code == POINTER_TYPE)
5454         {
5455           if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE)
5456             {
5457               if (TREE_CODE (inside_init) == STRING_CST
5458                   || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
5459                 inside_init = array_to_pointer_conversion (inside_init);
5460               else
5461                 {
5462                   error_init ("invalid use of non-lvalue array");
5463                   return error_mark_node;
5464                 }
5465             }
5466         }
5467
5468       if (code == VECTOR_TYPE)
5469         /* Although the types are compatible, we may require a
5470            conversion.  */
5471         inside_init = convert (type, inside_init);
5472
5473       if (require_constant
5474           && (code == VECTOR_TYPE || !flag_isoc99)
5475           && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR)
5476         {
5477           /* As an extension, allow initializing objects with static storage
5478              duration with compound literals (which are then treated just as
5479              the brace enclosed list they contain).  Also allow this for
5480              vectors, as we can only assign them with compound literals.  */
5481           tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init);
5482           inside_init = DECL_INITIAL (decl);
5483         }
5484
5485       if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST
5486           && TREE_CODE (inside_init) != CONSTRUCTOR)
5487         {
5488           error_init ("array initialized from non-constant array expression");
5489           return error_mark_node;
5490         }
5491
5492       /* Compound expressions can only occur here if -pedantic or
5493          -pedantic-errors is specified.  In the later case, we always want
5494          an error.  In the former case, we simply want a warning.  */
5495       if (require_constant && pedantic
5496           && TREE_CODE (inside_init) == COMPOUND_EXPR)
5497         {
5498           inside_init
5499             = valid_compound_expr_initializer (inside_init,
5500                                                TREE_TYPE (inside_init));
5501           if (inside_init == error_mark_node)
5502             error_init ("initializer element is not constant");
5503           else
5504             pedwarn_init (input_location, OPT_pedantic,
5505                           "initializer element is not constant");
5506           if (flag_pedantic_errors)
5507             inside_init = error_mark_node;
5508         }
5509       else if (require_constant
5510                && !initializer_constant_valid_p (inside_init,
5511                                                  TREE_TYPE (inside_init)))
5512         {
5513           error_init ("initializer element is not constant");
5514           inside_init = error_mark_node;
5515         }
5516       else if (require_constant && !maybe_const)
5517         pedwarn_init (input_location, 0,
5518                       "initializer element is not a constant expression");
5519
5520       /* Added to enable additional -Wmissing-format-attribute warnings.  */
5521       if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE)
5522         inside_init = convert_for_assignment (type, inside_init, origtype,
5523                                               ic_init, null_pointer_constant,
5524                                               NULL_TREE, NULL_TREE, 0);
5525       return inside_init;
5526     }
5527
5528   /* Handle scalar types, including conversions.  */
5529
5530   if (code == INTEGER_TYPE || code == REAL_TYPE || code == FIXED_POINT_TYPE
5531       || code == POINTER_TYPE || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE
5532       || code == COMPLEX_TYPE || code == VECTOR_TYPE)
5533     {
5534       if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE
5535           && (TREE_CODE (init) == STRING_CST
5536               || TREE_CODE (init) == COMPOUND_LITERAL_EXPR))
5537         inside_init = init = array_to_pointer_conversion (init);
5538       if (semantic_type)
5539         inside_init = build1 (EXCESS_PRECISION_EXPR, semantic_type,
5540                               inside_init);
5541       inside_init
5542         = convert_for_assignment (type, inside_init, origtype, ic_init,
5543                                   null_pointer_constant,
5544                                   NULL_TREE, NULL_TREE, 0);
5545
5546       /* Check to see if we have already given an error message.  */
5547       if (inside_init == error_mark_node)
5548         ;
5549       else if (require_constant && !TREE_CONSTANT (inside_init))
5550         {
5551           error_init ("initializer element is not constant");
5552           inside_init = error_mark_node;
5553         }
5554       else if (require_constant
5555                && !initializer_constant_valid_p (inside_init,
5556                                                  TREE_TYPE (inside_init)))
5557         {
5558           error_init ("initializer element is not computable at load time");
5559           inside_init = error_mark_node;
5560         }
5561       else if (require_constant && !maybe_const)
5562         pedwarn_init (input_location, 0,
5563                       "initializer element is not a constant expression");
5564
5565       return inside_init;
5566     }
5567
5568   /* Come here only for records and arrays.  */
5569
5570   if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5571     {
5572       error_init ("variable-sized object may not be initialized");
5573       return error_mark_node;
5574     }
5575
5576   error_init ("invalid initializer");
5577   return error_mark_node;
5578 }
5579 \f
5580 /* Handle initializers that use braces.  */
5581
5582 /* Type of object we are accumulating a constructor for.
5583    This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE.  */
5584 static tree constructor_type;
5585
5586 /* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields
5587    left to fill.  */
5588 static tree constructor_fields;
5589
5590 /* For an ARRAY_TYPE, this is the specified index
5591    at which to store the next element we get.  */
5592 static tree constructor_index;
5593
5594 /* For an ARRAY_TYPE, this is the maximum index.  */
5595 static tree constructor_max_index;
5596
5597 /* For a RECORD_TYPE, this is the first field not yet written out.  */
5598 static tree constructor_unfilled_fields;
5599
5600 /* For an ARRAY_TYPE, this is the index of the first element
5601    not yet written out.  */
5602 static tree constructor_unfilled_index;
5603
5604 /* In a RECORD_TYPE, the byte index of the next consecutive field.
5605    This is so we can generate gaps between fields, when appropriate.  */
5606 static tree constructor_bit_index;
5607
5608 /* If we are saving up the elements rather than allocating them,
5609    this is the list of elements so far (in reverse order,
5610    most recent first).  */
5611 static VEC(constructor_elt,gc) *constructor_elements;
5612
5613 /* 1 if constructor should be incrementally stored into a constructor chain,
5614    0 if all the elements should be kept in AVL tree.  */
5615 static int constructor_incremental;
5616
5617 /* 1 if so far this constructor's elements are all compile-time constants.  */
5618 static int constructor_constant;
5619
5620 /* 1 if so far this constructor's elements are all valid address constants.  */
5621 static int constructor_simple;
5622
5623 /* 1 if this constructor has an element that cannot be part of a
5624    constant expression.  */
5625 static int constructor_nonconst;
5626
5627 /* 1 if this constructor is erroneous so far.  */
5628 static int constructor_erroneous;
5629
5630 /* Structure for managing pending initializer elements, organized as an
5631    AVL tree.  */
5632
5633 struct init_node
5634 {
5635   struct init_node *left, *right;
5636   struct init_node *parent;
5637   int balance;
5638   tree purpose;
5639   tree value;
5640   tree origtype;
5641 };
5642
5643 /* Tree of pending elements at this constructor level.
5644    These are elements encountered out of order
5645    which belong at places we haven't reached yet in actually
5646    writing the output.
5647    Will never hold tree nodes across GC runs.  */
5648 static struct init_node *constructor_pending_elts;
5649
5650 /* The SPELLING_DEPTH of this constructor.  */
5651 static int constructor_depth;
5652
5653 /* DECL node for which an initializer is being read.
5654    0 means we are reading a constructor expression
5655    such as (struct foo) {...}.  */
5656 static tree constructor_decl;
5657
5658 /* Nonzero if this is an initializer for a top-level decl.  */
5659 static int constructor_top_level;
5660
5661 /* Nonzero if there were any member designators in this initializer.  */
5662 static int constructor_designated;
5663
5664 /* Nesting depth of designator list.  */
5665 static int designator_depth;
5666
5667 /* Nonzero if there were diagnosed errors in this designator list.  */
5668 static int designator_erroneous;
5669
5670 \f
5671 /* This stack has a level for each implicit or explicit level of
5672    structuring in the initializer, including the outermost one.  It
5673    saves the values of most of the variables above.  */
5674
5675 struct constructor_range_stack;
5676
5677 struct constructor_stack
5678 {
5679   struct constructor_stack *next;
5680   tree type;
5681   tree fields;
5682   tree index;
5683   tree max_index;
5684   tree unfilled_index;
5685   tree unfilled_fields;
5686   tree bit_index;
5687   VEC(constructor_elt,gc) *elements;
5688   struct init_node *pending_elts;
5689   int offset;
5690   int depth;
5691   /* If value nonzero, this value should replace the entire
5692      constructor at this level.  */
5693   struct c_expr replacement_value;
5694   struct constructor_range_stack *range_stack;
5695   char constant;
5696   char simple;
5697   char nonconst;
5698   char implicit;
5699   char erroneous;
5700   char outer;
5701   char incremental;
5702   char designated;
5703 };
5704
5705 static struct constructor_stack *constructor_stack;
5706
5707 /* This stack represents designators from some range designator up to
5708    the last designator in the list.  */
5709
5710 struct constructor_range_stack
5711 {
5712   struct constructor_range_stack *next, *prev;
5713   struct constructor_stack *stack;
5714   tree range_start;
5715   tree index;
5716   tree range_end;
5717   tree fields;
5718 };
5719
5720 static struct constructor_range_stack *constructor_range_stack;
5721
5722 /* This stack records separate initializers that are nested.
5723    Nested initializers can't happen in ANSI C, but GNU C allows them
5724    in cases like { ... (struct foo) { ... } ... }.  */
5725
5726 struct initializer_stack
5727 {
5728   struct initializer_stack *next;
5729   tree decl;
5730   struct constructor_stack *constructor_stack;
5731   struct constructor_range_stack *constructor_range_stack;
5732   VEC(constructor_elt,gc) *elements;
5733   struct spelling *spelling;
5734   struct spelling *spelling_base;
5735   int spelling_size;
5736   char top_level;
5737   char require_constant_value;
5738   char require_constant_elements;
5739 };
5740
5741 static struct initializer_stack *initializer_stack;
5742 \f
5743 /* Prepare to parse and output the initializer for variable DECL.  */
5744
5745 void
5746 start_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level)
5747 {
5748   const char *locus;
5749   struct initializer_stack *p = XNEW (struct initializer_stack);
5750
5751   p->decl = constructor_decl;
5752   p->require_constant_value = require_constant_value;
5753   p->require_constant_elements = require_constant_elements;
5754   p->constructor_stack = constructor_stack;
5755   p->constructor_range_stack = constructor_range_stack;
5756   p->elements = constructor_elements;
5757   p->spelling = spelling;
5758   p->spelling_base = spelling_base;
5759   p->spelling_size = spelling_size;
5760   p->top_level = constructor_top_level;
5761   p->next = initializer_stack;
5762   initializer_stack = p;
5763
5764   constructor_decl = decl;
5765   constructor_designated = 0;
5766   constructor_top_level = top_level;
5767
5768   if (decl != 0 && decl != error_mark_node)
5769     {
5770       require_constant_value = TREE_STATIC (decl);
5771       require_constant_elements
5772         = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99))
5773            /* For a scalar, you can always use any value to initialize,
5774               even within braces.  */
5775            && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
5776                || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
5777                || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
5778                || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE));
5779       locus = IDENTIFIER_POINTER (DECL_NAME (decl));
5780     }
5781   else
5782     {
5783       require_constant_value = 0;
5784       require_constant_elements = 0;
5785       locus = "(anonymous)";
5786     }
5787
5788   constructor_stack = 0;
5789   constructor_range_stack = 0;
5790
5791   missing_braces_mentioned = 0;
5792
5793   spelling_base = 0;
5794   spelling_size = 0;
5795   RESTORE_SPELLING_DEPTH (0);
5796
5797   if (locus)
5798     push_string (locus);
5799 }
5800
5801 void
5802 finish_init (void)
5803 {
5804   struct initializer_stack *p = initializer_stack;
5805
5806   /* Free the whole constructor stack of this initializer.  */
5807   while (constructor_stack)
5808     {
5809       struct constructor_stack *q = constructor_stack;
5810       constructor_stack = q->next;
5811       free (q);
5812     }
5813
5814   gcc_assert (!constructor_range_stack);
5815
5816   /* Pop back to the data of the outer initializer (if any).  */
5817   free (spelling_base);
5818
5819   constructor_decl = p->decl;
5820   require_constant_value = p->require_constant_value;
5821   require_constant_elements = p->require_constant_elements;
5822   constructor_stack = p->constructor_stack;
5823   constructor_range_stack = p->constructor_range_stack;
5824   constructor_elements = p->elements;
5825   spelling = p->spelling;
5826   spelling_base = p->spelling_base;
5827   spelling_size = p->spelling_size;
5828   constructor_top_level = p->top_level;
5829   initializer_stack = p->next;
5830   free (p);
5831 }
5832 \f
5833 /* Call here when we see the initializer is surrounded by braces.
5834    This is instead of a call to push_init_level;
5835    it is matched by a call to pop_init_level.
5836
5837    TYPE is the type to initialize, for a constructor expression.
5838    For an initializer for a decl, TYPE is zero.  */
5839
5840 void
5841 really_start_incremental_init (tree type)
5842 {
5843   struct constructor_stack *p = XNEW (struct constructor_stack);
5844
5845   if (type == 0)
5846     type = TREE_TYPE (constructor_decl);
5847
5848   if (TREE_CODE (type) == VECTOR_TYPE
5849       && TYPE_VECTOR_OPAQUE (type))
5850     error ("opaque vector types cannot be initialized");
5851
5852   p->type = constructor_type;
5853   p->fields = constructor_fields;
5854   p->index = constructor_index;
5855   p->max_index = constructor_max_index;
5856   p->unfilled_index = constructor_unfilled_index;
5857   p->unfilled_fields = constructor_unfilled_fields;
5858   p->bit_index = constructor_bit_index;
5859   p->elements = constructor_elements;
5860   p->constant = constructor_constant;
5861   p->simple = constructor_simple;
5862   p->nonconst = constructor_nonconst;
5863   p->erroneous = constructor_erroneous;
5864   p->pending_elts = constructor_pending_elts;
5865   p->depth = constructor_depth;
5866   p->replacement_value.value = 0;
5867   p->replacement_value.original_code = ERROR_MARK;
5868   p->replacement_value.original_type = NULL;
5869   p->implicit = 0;
5870   p->range_stack = 0;
5871   p->outer = 0;
5872   p->incremental = constructor_incremental;
5873   p->designated = constructor_designated;
5874   p->next = 0;
5875   constructor_stack = p;
5876
5877   constructor_constant = 1;
5878   constructor_simple = 1;
5879   constructor_nonconst = 0;
5880   constructor_depth = SPELLING_DEPTH ();
5881   constructor_elements = 0;
5882   constructor_pending_elts = 0;
5883   constructor_type = type;
5884   constructor_incremental = 1;
5885   constructor_designated = 0;
5886   designator_depth = 0;
5887   designator_erroneous = 0;
5888
5889   if (TREE_CODE (constructor_type) == RECORD_TYPE
5890       || TREE_CODE (constructor_type) == UNION_TYPE)
5891     {
5892       constructor_fields = TYPE_FIELDS (constructor_type);
5893       /* Skip any nameless bit fields at the beginning.  */
5894       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
5895              && DECL_NAME (constructor_fields) == 0)
5896         constructor_fields = TREE_CHAIN (constructor_fields);
5897
5898       constructor_unfilled_fields = constructor_fields;
5899       constructor_bit_index = bitsize_zero_node;
5900     }
5901   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5902     {
5903       if (TYPE_DOMAIN (constructor_type))
5904         {
5905           constructor_max_index
5906             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
5907
5908           /* Detect non-empty initializations of zero-length arrays.  */
5909           if (constructor_max_index == NULL_TREE
5910               && TYPE_SIZE (constructor_type))
5911             constructor_max_index = build_int_cst (NULL_TREE, -1);
5912
5913           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
5914              to initialize VLAs will cause a proper error; avoid tree
5915              checking errors as well by setting a safe value.  */
5916           if (constructor_max_index
5917               && TREE_CODE (constructor_max_index) != INTEGER_CST)
5918             constructor_max_index = build_int_cst (NULL_TREE, -1);
5919
5920           constructor_index
5921             = convert (bitsizetype,
5922                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
5923         }
5924       else
5925         {
5926           constructor_index = bitsize_zero_node;
5927           constructor_max_index = NULL_TREE;
5928         }
5929
5930       constructor_unfilled_index = constructor_index;
5931     }
5932   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
5933     {
5934       /* Vectors are like simple fixed-size arrays.  */
5935       constructor_max_index =
5936         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
5937       constructor_index = bitsize_zero_node;
5938       constructor_unfilled_index = constructor_index;
5939     }
5940   else
5941     {
5942       /* Handle the case of int x = {5}; */
5943       constructor_fields = constructor_type;
5944       constructor_unfilled_fields = constructor_type;
5945     }
5946 }
5947 \f
5948 /* Push down into a subobject, for initialization.
5949    If this is for an explicit set of braces, IMPLICIT is 0.
5950    If it is because the next element belongs at a lower level,
5951    IMPLICIT is 1 (or 2 if the push is because of designator list).  */
5952
5953 void
5954 push_init_level (int implicit)
5955 {
5956   struct constructor_stack *p;
5957   tree value = NULL_TREE;
5958
5959   /* If we've exhausted any levels that didn't have braces,
5960      pop them now.  If implicit == 1, this will have been done in
5961      process_init_element; do not repeat it here because in the case
5962      of excess initializers for an empty aggregate this leads to an
5963      infinite cycle of popping a level and immediately recreating
5964      it.  */
5965   if (implicit != 1)
5966     {
5967       while (constructor_stack->implicit)
5968         {
5969           if ((TREE_CODE (constructor_type) == RECORD_TYPE
5970                || TREE_CODE (constructor_type) == UNION_TYPE)
5971               && constructor_fields == 0)
5972             process_init_element (pop_init_level (1), true);
5973           else if (TREE_CODE (constructor_type) == ARRAY_TYPE
5974                    && constructor_max_index
5975                    && tree_int_cst_lt (constructor_max_index,
5976                                        constructor_index))
5977             process_init_element (pop_init_level (1), true);
5978           else
5979             break;
5980         }
5981     }
5982
5983   /* Unless this is an explicit brace, we need to preserve previous
5984      content if any.  */
5985   if (implicit)
5986     {
5987       if ((TREE_CODE (constructor_type) == RECORD_TYPE
5988            || TREE_CODE (constructor_type) == UNION_TYPE)
5989           && constructor_fields)
5990         value = find_init_member (constructor_fields);
5991       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
5992         value = find_init_member (constructor_index);
5993     }
5994
5995   p = XNEW (struct constructor_stack);
5996   p->type = constructor_type;
5997   p->fields = constructor_fields;
5998   p->index = constructor_index;
5999   p->max_index = constructor_max_index;
6000   p->unfilled_index = constructor_unfilled_index;
6001   p->unfilled_fields = constructor_unfilled_fields;
6002   p->bit_index = constructor_bit_index;
6003   p->elements = constructor_elements;
6004   p->constant = constructor_constant;
6005   p->simple = constructor_simple;
6006   p->nonconst = constructor_nonconst;
6007   p->erroneous = constructor_erroneous;
6008   p->pending_elts = constructor_pending_elts;
6009   p->depth = constructor_depth;
6010   p->replacement_value.value = 0;
6011   p->replacement_value.original_code = ERROR_MARK;
6012   p->replacement_value.original_type = NULL;
6013   p->implicit = implicit;
6014   p->outer = 0;
6015   p->incremental = constructor_incremental;
6016   p->designated = constructor_designated;
6017   p->next = constructor_stack;
6018   p->range_stack = 0;
6019   constructor_stack = p;
6020
6021   constructor_constant = 1;
6022   constructor_simple = 1;
6023   constructor_nonconst = 0;
6024   constructor_depth = SPELLING_DEPTH ();
6025   constructor_elements = 0;
6026   constructor_incremental = 1;
6027   constructor_designated = 0;
6028   constructor_pending_elts = 0;
6029   if (!implicit)
6030     {
6031       p->range_stack = constructor_range_stack;
6032       constructor_range_stack = 0;
6033       designator_depth = 0;
6034       designator_erroneous = 0;
6035     }
6036
6037   /* Don't die if an entire brace-pair level is superfluous
6038      in the containing level.  */
6039   if (constructor_type == 0)
6040     ;
6041   else if (TREE_CODE (constructor_type) == RECORD_TYPE
6042            || TREE_CODE (constructor_type) == UNION_TYPE)
6043     {
6044       /* Don't die if there are extra init elts at the end.  */
6045       if (constructor_fields == 0)
6046         constructor_type = 0;
6047       else
6048         {
6049           constructor_type = TREE_TYPE (constructor_fields);
6050           push_member_name (constructor_fields);
6051           constructor_depth++;
6052         }
6053     }
6054   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6055     {
6056       constructor_type = TREE_TYPE (constructor_type);
6057       push_array_bounds (tree_low_cst (constructor_index, 1));
6058       constructor_depth++;
6059     }
6060
6061   if (constructor_type == 0)
6062     {
6063       error_init ("extra brace group at end of initializer");
6064       constructor_fields = 0;
6065       constructor_unfilled_fields = 0;
6066       return;
6067     }
6068
6069   if (value && TREE_CODE (value) == CONSTRUCTOR)
6070     {
6071       constructor_constant = TREE_CONSTANT (value);
6072       constructor_simple = TREE_STATIC (value);
6073       constructor_nonconst = CONSTRUCTOR_NON_CONST (value);
6074       constructor_elements = CONSTRUCTOR_ELTS (value);
6075       if (!VEC_empty (constructor_elt, constructor_elements)
6076           && (TREE_CODE (constructor_type) == RECORD_TYPE
6077               || TREE_CODE (constructor_type) == ARRAY_TYPE))
6078         set_nonincremental_init ();
6079     }
6080
6081   if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned)
6082     {
6083       missing_braces_mentioned = 1;
6084       warning_init (OPT_Wmissing_braces, "missing braces around initializer");
6085     }
6086
6087   if (TREE_CODE (constructor_type) == RECORD_TYPE
6088            || TREE_CODE (constructor_type) == UNION_TYPE)
6089     {
6090       constructor_fields = TYPE_FIELDS (constructor_type);
6091       /* Skip any nameless bit fields at the beginning.  */
6092       while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields)
6093              && DECL_NAME (constructor_fields) == 0)
6094         constructor_fields = TREE_CHAIN (constructor_fields);
6095
6096       constructor_unfilled_fields = constructor_fields;
6097       constructor_bit_index = bitsize_zero_node;
6098     }
6099   else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
6100     {
6101       /* Vectors are like simple fixed-size arrays.  */
6102       constructor_max_index =
6103         build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1);
6104       constructor_index = convert (bitsizetype, integer_zero_node);
6105       constructor_unfilled_index = constructor_index;
6106     }
6107   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6108     {
6109       if (TYPE_DOMAIN (constructor_type))
6110         {
6111           constructor_max_index
6112             = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type));
6113
6114           /* Detect non-empty initializations of zero-length arrays.  */
6115           if (constructor_max_index == NULL_TREE
6116               && TYPE_SIZE (constructor_type))
6117             constructor_max_index = build_int_cst (NULL_TREE, -1);
6118
6119           /* constructor_max_index needs to be an INTEGER_CST.  Attempts
6120              to initialize VLAs will cause a proper error; avoid tree
6121              checking errors as well by setting a safe value.  */
6122           if (constructor_max_index
6123               && TREE_CODE (constructor_max_index) != INTEGER_CST)
6124             constructor_max_index = build_int_cst (NULL_TREE, -1);
6125
6126           constructor_index
6127             = convert (bitsizetype,
6128                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6129         }
6130       else
6131         constructor_index = bitsize_zero_node;
6132
6133       constructor_unfilled_index = constructor_index;
6134       if (value && TREE_CODE (value) == STRING_CST)
6135         {
6136           /* We need to split the char/wchar array into individual
6137              characters, so that we don't have to special case it
6138              everywhere.  */
6139           set_nonincremental_init_from_string (value);
6140         }
6141     }
6142   else
6143     {
6144       if (constructor_type != error_mark_node)
6145         warning_init (0, "braces around scalar initializer");
6146       constructor_fields = constructor_type;
6147       constructor_unfilled_fields = constructor_type;
6148     }
6149 }
6150
6151 /* At the end of an implicit or explicit brace level,
6152    finish up that level of constructor.  If a single expression
6153    with redundant braces initialized that level, return the
6154    c_expr structure for that expression.  Otherwise, the original_code
6155    element is set to ERROR_MARK.
6156    If we were outputting the elements as they are read, return 0 as the value
6157    from inner levels (process_init_element ignores that),
6158    but return error_mark_node as the value from the outermost level
6159    (that's what we want to put in DECL_INITIAL).
6160    Otherwise, return a CONSTRUCTOR expression as the value.  */
6161
6162 struct c_expr
6163 pop_init_level (int implicit)
6164 {
6165   struct constructor_stack *p;
6166   struct c_expr ret;
6167   ret.value = 0;
6168   ret.original_code = ERROR_MARK;
6169   ret.original_type = NULL;
6170
6171   if (implicit == 0)
6172     {
6173       /* When we come to an explicit close brace,
6174          pop any inner levels that didn't have explicit braces.  */
6175       while (constructor_stack->implicit)
6176         process_init_element (pop_init_level (1), true);
6177
6178       gcc_assert (!constructor_range_stack);
6179     }
6180
6181   /* Now output all pending elements.  */
6182   constructor_incremental = 1;
6183   output_pending_init_elements (1);
6184
6185   p = constructor_stack;
6186
6187   /* Error for initializing a flexible array member, or a zero-length
6188      array member in an inappropriate context.  */
6189   if (constructor_type && constructor_fields
6190       && TREE_CODE (constructor_type) == ARRAY_TYPE
6191       && TYPE_DOMAIN (constructor_type)
6192       && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)))
6193     {
6194       /* Silently discard empty initializations.  The parser will
6195          already have pedwarned for empty brackets.  */
6196       if (integer_zerop (constructor_unfilled_index))
6197         constructor_type = NULL_TREE;
6198       else
6199         {
6200           gcc_assert (!TYPE_SIZE (constructor_type));
6201
6202           if (constructor_depth > 2)
6203             error_init ("initialization of flexible array member in a nested context");
6204           else
6205             pedwarn_init (input_location, OPT_pedantic,
6206                           "initialization of a flexible array member");
6207
6208           /* We have already issued an error message for the existence
6209              of a flexible array member not at the end of the structure.
6210              Discard the initializer so that we do not die later.  */
6211           if (TREE_CHAIN (constructor_fields) != NULL_TREE)
6212             constructor_type = NULL_TREE;
6213         }
6214     }
6215
6216   /* Warn when some struct elements are implicitly initialized to zero.  */
6217   if (warn_missing_field_initializers
6218       && constructor_type
6219       && TREE_CODE (constructor_type) == RECORD_TYPE
6220       && constructor_unfilled_fields)
6221     {
6222         /* Do not warn for flexible array members or zero-length arrays.  */
6223         while (constructor_unfilled_fields
6224                && (!DECL_SIZE (constructor_unfilled_fields)
6225                    || integer_zerop (DECL_SIZE (constructor_unfilled_fields))))
6226           constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6227
6228         /* Do not warn if this level of the initializer uses member
6229            designators; it is likely to be deliberate.  */
6230         if (constructor_unfilled_fields && !constructor_designated)
6231           {
6232             push_member_name (constructor_unfilled_fields);
6233             warning_init (OPT_Wmissing_field_initializers,
6234                           "missing initializer");
6235             RESTORE_SPELLING_DEPTH (constructor_depth);
6236           }
6237     }
6238
6239   /* Pad out the end of the structure.  */
6240   if (p->replacement_value.value)
6241     /* If this closes a superfluous brace pair,
6242        just pass out the element between them.  */
6243     ret = p->replacement_value;
6244   else if (constructor_type == 0)
6245     ;
6246   else if (TREE_CODE (constructor_type) != RECORD_TYPE
6247            && TREE_CODE (constructor_type) != UNION_TYPE
6248            && TREE_CODE (constructor_type) != ARRAY_TYPE
6249            && TREE_CODE (constructor_type) != VECTOR_TYPE)
6250     {
6251       /* A nonincremental scalar initializer--just return
6252          the element, after verifying there is just one.  */
6253       if (VEC_empty (constructor_elt,constructor_elements))
6254         {
6255           if (!constructor_erroneous)
6256             error_init ("empty scalar initializer");
6257           ret.value = error_mark_node;
6258         }
6259       else if (VEC_length (constructor_elt,constructor_elements) != 1)
6260         {
6261           error_init ("extra elements in scalar initializer");
6262           ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
6263         }
6264       else
6265         ret.value = VEC_index (constructor_elt,constructor_elements,0)->value;
6266     }
6267   else
6268     {
6269       if (constructor_erroneous)
6270         ret.value = error_mark_node;
6271       else
6272         {
6273           ret.value = build_constructor (constructor_type,
6274                                          constructor_elements);
6275           if (constructor_constant)
6276             TREE_CONSTANT (ret.value) = 1;
6277           if (constructor_constant && constructor_simple)
6278             TREE_STATIC (ret.value) = 1;
6279           if (constructor_nonconst)
6280             CONSTRUCTOR_NON_CONST (ret.value) = 1;
6281         }
6282     }
6283
6284   if (ret.value && TREE_CODE (ret.value) != CONSTRUCTOR)
6285     {
6286       if (constructor_nonconst)
6287         ret.original_code = C_MAYBE_CONST_EXPR;
6288       else if (ret.original_code == C_MAYBE_CONST_EXPR)
6289         ret.original_code = ERROR_MARK;
6290     }
6291
6292   constructor_type = p->type;
6293   constructor_fields = p->fields;
6294   constructor_index = p->index;
6295   constructor_max_index = p->max_index;
6296   constructor_unfilled_index = p->unfilled_index;
6297   constructor_unfilled_fields = p->unfilled_fields;
6298   constructor_bit_index = p->bit_index;
6299   constructor_elements = p->elements;
6300   constructor_constant = p->constant;
6301   constructor_simple = p->simple;
6302   constructor_nonconst = p->nonconst;
6303   constructor_erroneous = p->erroneous;
6304   constructor_incremental = p->incremental;
6305   constructor_designated = p->designated;
6306   constructor_pending_elts = p->pending_elts;
6307   constructor_depth = p->depth;
6308   if (!p->implicit)
6309     constructor_range_stack = p->range_stack;
6310   RESTORE_SPELLING_DEPTH (constructor_depth);
6311
6312   constructor_stack = p->next;
6313   free (p);
6314
6315   if (ret.value == 0 && constructor_stack == 0)
6316     ret.value = error_mark_node;
6317   return ret;
6318 }
6319
6320 /* Common handling for both array range and field name designators.
6321    ARRAY argument is nonzero for array ranges.  Returns zero for success.  */
6322
6323 static int
6324 set_designator (int array)
6325 {
6326   tree subtype;
6327   enum tree_code subcode;
6328
6329   /* Don't die if an entire brace-pair level is superfluous
6330      in the containing level.  */
6331   if (constructor_type == 0)
6332     return 1;
6333
6334   /* If there were errors in this designator list already, bail out
6335      silently.  */
6336   if (designator_erroneous)
6337     return 1;
6338
6339   if (!designator_depth)
6340     {
6341       gcc_assert (!constructor_range_stack);
6342
6343       /* Designator list starts at the level of closest explicit
6344          braces.  */
6345       while (constructor_stack->implicit)
6346         process_init_element (pop_init_level (1), true);
6347       constructor_designated = 1;
6348       return 0;
6349     }
6350
6351   switch (TREE_CODE (constructor_type))
6352     {
6353     case  RECORD_TYPE:
6354     case  UNION_TYPE:
6355       subtype = TREE_TYPE (constructor_fields);
6356       if (subtype != error_mark_node)
6357         subtype = TYPE_MAIN_VARIANT (subtype);
6358       break;
6359     case ARRAY_TYPE:
6360       subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
6361       break;
6362     default:
6363       gcc_unreachable ();
6364     }
6365
6366   subcode = TREE_CODE (subtype);
6367   if (array && subcode != ARRAY_TYPE)
6368     {
6369       error_init ("array index in non-array initializer");
6370       return 1;
6371     }
6372   else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE)
6373     {
6374       error_init ("field name not in record or union initializer");
6375       return 1;
6376     }
6377
6378   constructor_designated = 1;
6379   push_init_level (2);
6380   return 0;
6381 }
6382
6383 /* If there are range designators in designator list, push a new designator
6384    to constructor_range_stack.  RANGE_END is end of such stack range or
6385    NULL_TREE if there is no range designator at this level.  */
6386
6387 static void
6388 push_range_stack (tree range_end)
6389 {
6390   struct constructor_range_stack *p;
6391
6392   p = GGC_NEW (struct constructor_range_stack);
6393   p->prev = constructor_range_stack;
6394   p->next = 0;
6395   p->fields = constructor_fields;
6396   p->range_start = constructor_index;
6397   p->index = constructor_index;
6398   p->stack = constructor_stack;
6399   p->range_end = range_end;
6400   if (constructor_range_stack)
6401     constructor_range_stack->next = p;
6402   constructor_range_stack = p;
6403 }
6404
6405 /* Within an array initializer, specify the next index to be initialized.
6406    FIRST is that index.  If LAST is nonzero, then initialize a range
6407    of indices, running from FIRST through LAST.  */
6408
6409 void
6410 set_init_index (tree first, tree last)
6411 {
6412   if (set_designator (1))
6413     return;
6414
6415   designator_erroneous = 1;
6416
6417   if (!INTEGRAL_TYPE_P (TREE_TYPE (first))
6418       || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last))))
6419     {
6420       error_init ("array index in initializer not of integer type");
6421       return;
6422     }
6423
6424   if (TREE_CODE (first) != INTEGER_CST)
6425     error_init ("nonconstant array index in initializer");
6426   else if (last != 0 && TREE_CODE (last) != INTEGER_CST)
6427     error_init ("nonconstant array index in initializer");
6428   else if (TREE_CODE (constructor_type) != ARRAY_TYPE)
6429     error_init ("array index in non-array initializer");
6430   else if (tree_int_cst_sgn (first) == -1)
6431     error_init ("array index in initializer exceeds array bounds");
6432   else if (constructor_max_index
6433            && tree_int_cst_lt (constructor_max_index, first))
6434     error_init ("array index in initializer exceeds array bounds");
6435   else
6436     {
6437       constant_expression_warning (first);
6438       if (last)
6439         constant_expression_warning (last);
6440       constructor_index = convert (bitsizetype, first);
6441
6442       if (last)
6443         {
6444           if (tree_int_cst_equal (first, last))
6445             last = 0;
6446           else if (tree_int_cst_lt (last, first))
6447             {
6448               error_init ("empty index range in initializer");
6449               last = 0;
6450             }
6451           else
6452             {
6453               last = convert (bitsizetype, last);
6454               if (constructor_max_index != 0
6455                   && tree_int_cst_lt (constructor_max_index, last))
6456                 {
6457                   error_init ("array index range in initializer exceeds array bounds");
6458                   last = 0;
6459                 }
6460             }
6461         }
6462
6463       designator_depth++;
6464       designator_erroneous = 0;
6465       if (constructor_range_stack || last)
6466         push_range_stack (last);
6467     }
6468 }
6469
6470 /* Within a struct initializer, specify the next field to be initialized.  */
6471
6472 void
6473 set_init_label (tree fieldname)
6474 {
6475   tree tail;
6476
6477   if (set_designator (0))
6478     return;
6479
6480   designator_erroneous = 1;
6481
6482   if (TREE_CODE (constructor_type) != RECORD_TYPE
6483       && TREE_CODE (constructor_type) != UNION_TYPE)
6484     {
6485       error_init ("field name not in record or union initializer");
6486       return;
6487     }
6488
6489   for (tail = TYPE_FIELDS (constructor_type); tail;
6490        tail = TREE_CHAIN (tail))
6491     {
6492       if (DECL_NAME (tail) == fieldname)
6493         break;
6494     }
6495
6496   if (tail == 0)
6497     error ("unknown field %qE specified in initializer", fieldname);
6498   else
6499     {
6500       constructor_fields = tail;
6501       designator_depth++;
6502       designator_erroneous = 0;
6503       if (constructor_range_stack)
6504         push_range_stack (NULL_TREE);
6505     }
6506 }
6507 \f
6508 /* Add a new initializer to the tree of pending initializers.  PURPOSE
6509    identifies the initializer, either array index or field in a structure.
6510    VALUE is the value of that index or field.  If ORIGTYPE is not
6511    NULL_TREE, it is the original type of VALUE.
6512
6513    IMPLICIT is true if value comes from pop_init_level (1),
6514    the new initializer has been merged with the existing one
6515    and thus no warnings should be emitted about overriding an
6516    existing initializer.  */
6517
6518 static void
6519 add_pending_init (tree purpose, tree value, tree origtype, bool implicit)
6520 {
6521   struct init_node *p, **q, *r;
6522
6523   q = &constructor_pending_elts;
6524   p = 0;
6525
6526   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6527     {
6528       while (*q != 0)
6529         {
6530           p = *q;
6531           if (tree_int_cst_lt (purpose, p->purpose))
6532             q = &p->left;
6533           else if (tree_int_cst_lt (p->purpose, purpose))
6534             q = &p->right;
6535           else
6536             {
6537               if (!implicit)
6538                 {
6539                   if (TREE_SIDE_EFFECTS (p->value))
6540                     warning_init (0, "initialized field with side-effects overwritten");
6541                   else if (warn_override_init)
6542                     warning_init (OPT_Woverride_init, "initialized field overwritten");
6543                 }
6544               p->value = value;
6545               p->origtype = origtype;
6546               return;
6547             }
6548         }
6549     }
6550   else
6551     {
6552       tree bitpos;
6553
6554       bitpos = bit_position (purpose);
6555       while (*q != NULL)
6556         {
6557           p = *q;
6558           if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6559             q = &p->left;
6560           else if (p->purpose != purpose)
6561             q = &p->right;
6562           else
6563             {
6564               if (!implicit)
6565                 {
6566                   if (TREE_SIDE_EFFECTS (p->value))
6567                     warning_init (0, "initialized field with side-effects overwritten");
6568                   else if (warn_override_init)
6569                     warning_init (OPT_Woverride_init, "initialized field overwritten");
6570                 }
6571               p->value = value;
6572               p->origtype = origtype;
6573               return;
6574             }
6575         }
6576     }
6577
6578   r = GGC_NEW (struct init_node);
6579   r->purpose = purpose;
6580   r->value = value;
6581   r->origtype = origtype;
6582
6583   *q = r;
6584   r->parent = p;
6585   r->left = 0;
6586   r->right = 0;
6587   r->balance = 0;
6588
6589   while (p)
6590     {
6591       struct init_node *s;
6592
6593       if (r == p->left)
6594         {
6595           if (p->balance == 0)
6596             p->balance = -1;
6597           else if (p->balance < 0)
6598             {
6599               if (r->balance < 0)
6600                 {
6601                   /* L rotation.  */
6602                   p->left = r->right;
6603                   if (p->left)
6604                     p->left->parent = p;
6605                   r->right = p;
6606
6607                   p->balance = 0;
6608                   r->balance = 0;
6609
6610                   s = p->parent;
6611                   p->parent = r;
6612                   r->parent = s;
6613                   if (s)
6614                     {
6615                       if (s->left == p)
6616                         s->left = r;
6617                       else
6618                         s->right = r;
6619                     }
6620                   else
6621                     constructor_pending_elts = r;
6622                 }
6623               else
6624                 {
6625                   /* LR rotation.  */
6626                   struct init_node *t = r->right;
6627
6628                   r->right = t->left;
6629                   if (r->right)
6630                     r->right->parent = r;
6631                   t->left = r;
6632
6633                   p->left = t->right;
6634                   if (p->left)
6635                     p->left->parent = p;
6636                   t->right = p;
6637
6638                   p->balance = t->balance < 0;
6639                   r->balance = -(t->balance > 0);
6640                   t->balance = 0;
6641
6642                   s = p->parent;
6643                   p->parent = t;
6644                   r->parent = t;
6645                   t->parent = s;
6646                   if (s)
6647                     {
6648                       if (s->left == p)
6649                         s->left = t;
6650                       else
6651                         s->right = t;
6652                     }
6653                   else
6654                     constructor_pending_elts = t;
6655                 }
6656               break;
6657             }
6658           else
6659             {
6660               /* p->balance == +1; growth of left side balances the node.  */
6661               p->balance = 0;
6662               break;
6663             }
6664         }
6665       else /* r == p->right */
6666         {
6667           if (p->balance == 0)
6668             /* Growth propagation from right side.  */
6669             p->balance++;
6670           else if (p->balance > 0)
6671             {
6672               if (r->balance > 0)
6673                 {
6674                   /* R rotation.  */
6675                   p->right = r->left;
6676                   if (p->right)
6677                     p->right->parent = p;
6678                   r->left = p;
6679
6680                   p->balance = 0;
6681                   r->balance = 0;
6682
6683                   s = p->parent;
6684                   p->parent = r;
6685                   r->parent = s;
6686                   if (s)
6687                     {
6688                       if (s->left == p)
6689                         s->left = r;
6690                       else
6691                         s->right = r;
6692                     }
6693                   else
6694                     constructor_pending_elts = r;
6695                 }
6696               else /* r->balance == -1 */
6697                 {
6698                   /* RL rotation */
6699                   struct init_node *t = r->left;
6700
6701                   r->left = t->right;
6702                   if (r->left)
6703                     r->left->parent = r;
6704                   t->right = r;
6705
6706                   p->right = t->left;
6707                   if (p->right)
6708                     p->right->parent = p;
6709                   t->left = p;
6710
6711                   r->balance = (t->balance < 0);
6712                   p->balance = -(t->balance > 0);
6713                   t->balance = 0;
6714
6715                   s = p->parent;
6716                   p->parent = t;
6717                   r->parent = t;
6718                   t->parent = s;
6719                   if (s)
6720                     {
6721                       if (s->left == p)
6722                         s->left = t;
6723                       else
6724                         s->right = t;
6725                     }
6726                   else
6727                     constructor_pending_elts = t;
6728                 }
6729               break;
6730             }
6731           else
6732             {
6733               /* p->balance == -1; growth of right side balances the node.  */
6734               p->balance = 0;
6735               break;
6736             }
6737         }
6738
6739       r = p;
6740       p = p->parent;
6741     }
6742 }
6743
6744 /* Build AVL tree from a sorted chain.  */
6745
6746 static void
6747 set_nonincremental_init (void)
6748 {
6749   unsigned HOST_WIDE_INT ix;
6750   tree index, value;
6751
6752   if (TREE_CODE (constructor_type) != RECORD_TYPE
6753       && TREE_CODE (constructor_type) != ARRAY_TYPE)
6754     return;
6755
6756   FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value)
6757     add_pending_init (index, value, NULL_TREE, false);
6758   constructor_elements = 0;
6759   if (TREE_CODE (constructor_type) == RECORD_TYPE)
6760     {
6761       constructor_unfilled_fields = TYPE_FIELDS (constructor_type);
6762       /* Skip any nameless bit fields at the beginning.  */
6763       while (constructor_unfilled_fields != 0
6764              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
6765              && DECL_NAME (constructor_unfilled_fields) == 0)
6766         constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields);
6767
6768     }
6769   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6770     {
6771       if (TYPE_DOMAIN (constructor_type))
6772         constructor_unfilled_index
6773             = convert (bitsizetype,
6774                        TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type)));
6775       else
6776         constructor_unfilled_index = bitsize_zero_node;
6777     }
6778   constructor_incremental = 0;
6779 }
6780
6781 /* Build AVL tree from a string constant.  */
6782
6783 static void
6784 set_nonincremental_init_from_string (tree str)
6785 {
6786   tree value, purpose, type;
6787   HOST_WIDE_INT val[2];
6788   const char *p, *end;
6789   int byte, wchar_bytes, charwidth, bitpos;
6790
6791   gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE);
6792
6793   wchar_bytes = TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) / BITS_PER_UNIT;
6794   charwidth = TYPE_PRECISION (char_type_node);
6795   type = TREE_TYPE (constructor_type);
6796   p = TREE_STRING_POINTER (str);
6797   end = p + TREE_STRING_LENGTH (str);
6798
6799   for (purpose = bitsize_zero_node;
6800        p < end && !tree_int_cst_lt (constructor_max_index, purpose);
6801        purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node))
6802     {
6803       if (wchar_bytes == 1)
6804         {
6805           val[1] = (unsigned char) *p++;
6806           val[0] = 0;
6807         }
6808       else
6809         {
6810           val[0] = 0;
6811           val[1] = 0;
6812           for (byte = 0; byte < wchar_bytes; byte++)
6813             {
6814               if (BYTES_BIG_ENDIAN)
6815                 bitpos = (wchar_bytes - byte - 1) * charwidth;
6816               else
6817                 bitpos = byte * charwidth;
6818               val[bitpos < HOST_BITS_PER_WIDE_INT]
6819                 |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++))
6820                    << (bitpos % HOST_BITS_PER_WIDE_INT);
6821             }
6822         }
6823
6824       if (!TYPE_UNSIGNED (type))
6825         {
6826           bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR;
6827           if (bitpos < HOST_BITS_PER_WIDE_INT)
6828             {
6829               if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1)))
6830                 {
6831                   val[1] |= ((HOST_WIDE_INT) -1) << bitpos;
6832                   val[0] = -1;
6833                 }
6834             }
6835           else if (bitpos == HOST_BITS_PER_WIDE_INT)
6836             {
6837               if (val[1] < 0)
6838                 val[0] = -1;
6839             }
6840           else if (val[0] & (((HOST_WIDE_INT) 1)
6841                              << (bitpos - 1 - HOST_BITS_PER_WIDE_INT)))
6842             val[0] |= ((HOST_WIDE_INT) -1)
6843                       << (bitpos - HOST_BITS_PER_WIDE_INT);
6844         }
6845
6846       value = build_int_cst_wide (type, val[1], val[0]);
6847       add_pending_init (purpose, value, NULL_TREE, false);
6848     }
6849
6850   constructor_incremental = 0;
6851 }
6852
6853 /* Return value of FIELD in pending initializer or zero if the field was
6854    not initialized yet.  */
6855
6856 static tree
6857 find_init_member (tree field)
6858 {
6859   struct init_node *p;
6860
6861   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
6862     {
6863       if (constructor_incremental
6864           && tree_int_cst_lt (field, constructor_unfilled_index))
6865         set_nonincremental_init ();
6866
6867       p = constructor_pending_elts;
6868       while (p)
6869         {
6870           if (tree_int_cst_lt (field, p->purpose))
6871             p = p->left;
6872           else if (tree_int_cst_lt (p->purpose, field))
6873             p = p->right;
6874           else
6875             return p->value;
6876         }
6877     }
6878   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
6879     {
6880       tree bitpos = bit_position (field);
6881
6882       if (constructor_incremental
6883           && (!constructor_unfilled_fields
6884               || tree_int_cst_lt (bitpos,
6885                                   bit_position (constructor_unfilled_fields))))
6886         set_nonincremental_init ();
6887
6888       p = constructor_pending_elts;
6889       while (p)
6890         {
6891           if (field == p->purpose)
6892             return p->value;
6893           else if (tree_int_cst_lt (bitpos, bit_position (p->purpose)))
6894             p = p->left;
6895           else
6896             p = p->right;
6897         }
6898     }
6899   else if (TREE_CODE (constructor_type) == UNION_TYPE)
6900     {
6901       if (!VEC_empty (constructor_elt, constructor_elements)
6902           && (VEC_last (constructor_elt, constructor_elements)->index
6903               == field))
6904         return VEC_last (constructor_elt, constructor_elements)->value;
6905     }
6906   return 0;
6907 }
6908
6909 /* "Output" the next constructor element.
6910    At top level, really output it to assembler code now.
6911    Otherwise, collect it in a list from which we will make a CONSTRUCTOR.
6912    If ORIGTYPE is not NULL_TREE, it is the original type of VALUE.
6913    TYPE is the data type that the containing data type wants here.
6914    FIELD is the field (a FIELD_DECL) or the index that this element fills.
6915    If VALUE is a string constant, STRICT_STRING is true if it is
6916    unparenthesized or we should not warn here for it being parenthesized.
6917    For other types of VALUE, STRICT_STRING is not used.
6918
6919    PENDING if non-nil means output pending elements that belong
6920    right after this element.  (PENDING is normally 1;
6921    it is 0 while outputting pending elements, to avoid recursion.)
6922
6923    IMPLICIT is true if value comes from pop_init_level (1),
6924    the new initializer has been merged with the existing one
6925    and thus no warnings should be emitted about overriding an
6926    existing initializer.  */
6927
6928 static void
6929 output_init_element (tree value, tree origtype, bool strict_string, tree type,
6930                      tree field, int pending, bool implicit)
6931 {
6932   tree semantic_type = NULL_TREE;
6933   constructor_elt *celt;
6934   bool maybe_const = true;
6935   bool npc;
6936
6937   if (type == error_mark_node || value == error_mark_node)
6938     {
6939       constructor_erroneous = 1;
6940       return;
6941     }
6942   if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE
6943       && (TREE_CODE (value) == STRING_CST
6944           || TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
6945       && !(TREE_CODE (value) == STRING_CST
6946            && TREE_CODE (type) == ARRAY_TYPE
6947            && INTEGRAL_TYPE_P (TREE_TYPE (type)))
6948       && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)),
6949                      TYPE_MAIN_VARIANT (type)))
6950     value = array_to_pointer_conversion (value);
6951
6952   if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR
6953       && require_constant_value && !flag_isoc99 && pending)
6954     {
6955       /* As an extension, allow initializing objects with static storage
6956          duration with compound literals (which are then treated just as
6957          the brace enclosed list they contain).  */
6958       tree decl = COMPOUND_LITERAL_EXPR_DECL (value);
6959       value = DECL_INITIAL (decl);
6960     }
6961
6962   npc = null_pointer_constant_p (value);
6963   if (TREE_CODE (value) == EXCESS_PRECISION_EXPR)
6964     {
6965       semantic_type = TREE_TYPE (value);
6966       value = TREE_OPERAND (value, 0);
6967     }
6968   value = c_fully_fold (value, require_constant_value, &maybe_const);
6969
6970   if (value == error_mark_node)
6971     constructor_erroneous = 1;
6972   else if (!TREE_CONSTANT (value))
6973     constructor_constant = 0;
6974   else if (!initializer_constant_valid_p (value, TREE_TYPE (value))
6975            || ((TREE_CODE (constructor_type) == RECORD_TYPE
6976                 || TREE_CODE (constructor_type) == UNION_TYPE)
6977                && DECL_C_BIT_FIELD (field)
6978                && TREE_CODE (value) != INTEGER_CST))
6979     constructor_simple = 0;
6980   if (!maybe_const)
6981     constructor_nonconst = 1;
6982
6983   if (!initializer_constant_valid_p (value, TREE_TYPE (value)))
6984     {
6985       if (require_constant_value)
6986         {
6987           error_init ("initializer element is not constant");
6988           value = error_mark_node;
6989         }
6990       else if (require_constant_elements)
6991         pedwarn (input_location, 0,
6992                  "initializer element is not computable at load time");
6993     }
6994   else if (!maybe_const
6995            && (require_constant_value || require_constant_elements))
6996     pedwarn_init (input_location, 0,
6997                   "initializer element is not a constant expression");
6998
6999   /* If this field is empty (and not at the end of structure),
7000      don't do anything other than checking the initializer.  */
7001   if (field
7002       && (TREE_TYPE (field) == error_mark_node
7003           || (COMPLETE_TYPE_P (TREE_TYPE (field))
7004               && integer_zerop (TYPE_SIZE (TREE_TYPE (field)))
7005               && (TREE_CODE (constructor_type) == ARRAY_TYPE
7006                   || TREE_CHAIN (field)))))
7007     return;
7008
7009   if (semantic_type)
7010     value = build1 (EXCESS_PRECISION_EXPR, semantic_type, value);
7011   value = digest_init (type, value, origtype, npc, strict_string,
7012                        require_constant_value);
7013   if (value == error_mark_node)
7014     {
7015       constructor_erroneous = 1;
7016       return;
7017     }
7018   if (require_constant_value || require_constant_elements)
7019     constant_expression_warning (value);
7020
7021   /* If this element doesn't come next in sequence,
7022      put it on constructor_pending_elts.  */
7023   if (TREE_CODE (constructor_type) == ARRAY_TYPE
7024       && (!constructor_incremental
7025           || !tree_int_cst_equal (field, constructor_unfilled_index)))
7026     {
7027       if (constructor_incremental
7028           && tree_int_cst_lt (field, constructor_unfilled_index))
7029         set_nonincremental_init ();
7030
7031       add_pending_init (field, value, origtype, implicit);
7032       return;
7033     }
7034   else if (TREE_CODE (constructor_type) == RECORD_TYPE
7035            && (!constructor_incremental
7036                || field != constructor_unfilled_fields))
7037     {
7038       /* We do this for records but not for unions.  In a union,
7039          no matter which field is specified, it can be initialized
7040          right away since it starts at the beginning of the union.  */
7041       if (constructor_incremental)
7042         {
7043           if (!constructor_unfilled_fields)
7044             set_nonincremental_init ();
7045           else
7046             {
7047               tree bitpos, unfillpos;
7048
7049               bitpos = bit_position (field);
7050               unfillpos = bit_position (constructor_unfilled_fields);
7051
7052               if (tree_int_cst_lt (bitpos, unfillpos))
7053                 set_nonincremental_init ();
7054             }
7055         }
7056
7057       add_pending_init (field, value, origtype, implicit);
7058       return;
7059     }
7060   else if (TREE_CODE (constructor_type) == UNION_TYPE
7061            && !VEC_empty (constructor_elt, constructor_elements))
7062     {
7063       if (!implicit)
7064         {
7065           if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt,
7066                                            constructor_elements)->value))
7067             warning_init (0,
7068                           "initialized field with side-effects overwritten");
7069           else if (warn_override_init)
7070             warning_init (OPT_Woverride_init, "initialized field overwritten");
7071         }
7072
7073       /* We can have just one union field set.  */
7074       constructor_elements = 0;
7075     }
7076
7077   /* Otherwise, output this element either to
7078      constructor_elements or to the assembler file.  */
7079
7080   celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL);
7081   celt->index = field;
7082   celt->value = value;
7083
7084   /* Advance the variable that indicates sequential elements output.  */
7085   if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7086     constructor_unfilled_index
7087       = size_binop (PLUS_EXPR, constructor_unfilled_index,
7088                     bitsize_one_node);
7089   else if (TREE_CODE (constructor_type) == RECORD_TYPE)
7090     {
7091       constructor_unfilled_fields
7092         = TREE_CHAIN (constructor_unfilled_fields);
7093
7094       /* Skip any nameless bit fields.  */
7095       while (constructor_unfilled_fields != 0
7096              && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7097              && DECL_NAME (constructor_unfilled_fields) == 0)
7098         constructor_unfilled_fields =
7099           TREE_CHAIN (constructor_unfilled_fields);
7100     }
7101   else if (TREE_CODE (constructor_type) == UNION_TYPE)
7102     constructor_unfilled_fields = 0;
7103
7104   /* Now output any pending elements which have become next.  */
7105   if (pending)
7106     output_pending_init_elements (0);
7107 }
7108
7109 /* Output any pending elements which have become next.
7110    As we output elements, constructor_unfilled_{fields,index}
7111    advances, which may cause other elements to become next;
7112    if so, they too are output.
7113
7114    If ALL is 0, we return when there are
7115    no more pending elements to output now.
7116
7117    If ALL is 1, we output space as necessary so that
7118    we can output all the pending elements.  */
7119
7120 static void
7121 output_pending_init_elements (int all)
7122 {
7123   struct init_node *elt = constructor_pending_elts;
7124   tree next;
7125
7126  retry:
7127
7128   /* Look through the whole pending tree.
7129      If we find an element that should be output now,
7130      output it.  Otherwise, set NEXT to the element
7131      that comes first among those still pending.  */
7132
7133   next = 0;
7134   while (elt)
7135     {
7136       if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7137         {
7138           if (tree_int_cst_equal (elt->purpose,
7139                                   constructor_unfilled_index))
7140             output_init_element (elt->value, elt->origtype, true,
7141                                  TREE_TYPE (constructor_type),
7142                                  constructor_unfilled_index, 0, false);
7143           else if (tree_int_cst_lt (constructor_unfilled_index,
7144                                     elt->purpose))
7145             {
7146               /* Advance to the next smaller node.  */
7147               if (elt->left)
7148                 elt = elt->left;
7149               else
7150                 {
7151                   /* We have reached the smallest node bigger than the
7152                      current unfilled index.  Fill the space first.  */
7153                   next = elt->purpose;
7154                   break;
7155                 }
7156             }
7157           else
7158             {
7159               /* Advance to the next bigger node.  */
7160               if (elt->right)
7161                 elt = elt->right;
7162               else
7163                 {
7164                   /* We have reached the biggest node in a subtree.  Find
7165                      the parent of it, which is the next bigger node.  */
7166                   while (elt->parent && elt->parent->right == elt)
7167                     elt = elt->parent;
7168                   elt = elt->parent;
7169                   if (elt && tree_int_cst_lt (constructor_unfilled_index,
7170                                               elt->purpose))
7171                     {
7172                       next = elt->purpose;
7173                       break;
7174                     }
7175                 }
7176             }
7177         }
7178       else if (TREE_CODE (constructor_type) == RECORD_TYPE
7179                || TREE_CODE (constructor_type) == UNION_TYPE)
7180         {
7181           tree ctor_unfilled_bitpos, elt_bitpos;
7182
7183           /* If the current record is complete we are done.  */
7184           if (constructor_unfilled_fields == 0)
7185             break;
7186
7187           ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields);
7188           elt_bitpos = bit_position (elt->purpose);
7189           /* We can't compare fields here because there might be empty
7190              fields in between.  */
7191           if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos))
7192             {
7193               constructor_unfilled_fields = elt->purpose;
7194               output_init_element (elt->value, elt->origtype, true,
7195                                    TREE_TYPE (elt->purpose),
7196                                    elt->purpose, 0, false);
7197             }
7198           else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos))
7199             {
7200               /* Advance to the next smaller node.  */
7201               if (elt->left)
7202                 elt = elt->left;
7203               else
7204                 {
7205                   /* We have reached the smallest node bigger than the
7206                      current unfilled field.  Fill the space first.  */
7207                   next = elt->purpose;
7208                   break;
7209                 }
7210             }
7211           else
7212             {
7213               /* Advance to the next bigger node.  */
7214               if (elt->right)
7215                 elt = elt->right;
7216               else
7217                 {
7218                   /* We have reached the biggest node in a subtree.  Find
7219                      the parent of it, which is the next bigger node.  */
7220                   while (elt->parent && elt->parent->right == elt)
7221                     elt = elt->parent;
7222                   elt = elt->parent;
7223                   if (elt
7224                       && (tree_int_cst_lt (ctor_unfilled_bitpos,
7225                                            bit_position (elt->purpose))))
7226                     {
7227                       next = elt->purpose;
7228                       break;
7229                     }
7230                 }
7231             }
7232         }
7233     }
7234
7235   /* Ordinarily return, but not if we want to output all
7236      and there are elements left.  */
7237   if (!(all && next != 0))
7238     return;
7239
7240   /* If it's not incremental, just skip over the gap, so that after
7241      jumping to retry we will output the next successive element.  */
7242   if (TREE_CODE (constructor_type) == RECORD_TYPE
7243       || TREE_CODE (constructor_type) == UNION_TYPE)
7244     constructor_unfilled_fields = next;
7245   else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7246     constructor_unfilled_index = next;
7247
7248   /* ELT now points to the node in the pending tree with the next
7249      initializer to output.  */
7250   goto retry;
7251 }
7252 \f
7253 /* Add one non-braced element to the current constructor level.
7254    This adjusts the current position within the constructor's type.
7255    This may also start or terminate implicit levels
7256    to handle a partly-braced initializer.
7257
7258    Once this has found the correct level for the new element,
7259    it calls output_init_element.
7260
7261    IMPLICIT is true if value comes from pop_init_level (1),
7262    the new initializer has been merged with the existing one
7263    and thus no warnings should be emitted about overriding an
7264    existing initializer.  */
7265
7266 void
7267 process_init_element (struct c_expr value, bool implicit)
7268 {
7269   tree orig_value = value.value;
7270   int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST;
7271   bool strict_string = value.original_code == STRING_CST;
7272
7273   designator_depth = 0;
7274   designator_erroneous = 0;
7275
7276   /* Handle superfluous braces around string cst as in
7277      char x[] = {"foo"}; */
7278   if (string_flag
7279       && constructor_type
7280       && TREE_CODE (constructor_type) == ARRAY_TYPE
7281       && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type))
7282       && integer_zerop (constructor_unfilled_index))
7283     {
7284       if (constructor_stack->replacement_value.value)
7285         error_init ("excess elements in char array initializer");
7286       constructor_stack->replacement_value = value;
7287       return;
7288     }
7289
7290   if (constructor_stack->replacement_value.value != 0)
7291     {
7292       error_init ("excess elements in struct initializer");
7293       return;
7294     }
7295
7296   /* Ignore elements of a brace group if it is entirely superfluous
7297      and has already been diagnosed.  */
7298   if (constructor_type == 0)
7299     return;
7300
7301   /* If we've exhausted any levels that didn't have braces,
7302      pop them now.  */
7303   while (constructor_stack->implicit)
7304     {
7305       if ((TREE_CODE (constructor_type) == RECORD_TYPE
7306            || TREE_CODE (constructor_type) == UNION_TYPE)
7307           && constructor_fields == 0)
7308         process_init_element (pop_init_level (1), true);
7309       else if ((TREE_CODE (constructor_type) == ARRAY_TYPE
7310                 || TREE_CODE (constructor_type) == VECTOR_TYPE)
7311                && (constructor_max_index == 0
7312                    || tree_int_cst_lt (constructor_max_index,
7313                                        constructor_index)))
7314         process_init_element (pop_init_level (1), true);
7315       else
7316         break;
7317     }
7318
7319   /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once.  */
7320   if (constructor_range_stack)
7321     {
7322       /* If value is a compound literal and we'll be just using its
7323          content, don't put it into a SAVE_EXPR.  */
7324       if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR
7325           || !require_constant_value
7326           || flag_isoc99)
7327         {
7328           tree semantic_type = NULL_TREE;
7329           if (TREE_CODE (value.value) == EXCESS_PRECISION_EXPR)
7330             {
7331               semantic_type = TREE_TYPE (value.value);
7332               value.value = TREE_OPERAND (value.value, 0);
7333             }
7334           value.value = c_save_expr (value.value);
7335           if (semantic_type)
7336             value.value = build1 (EXCESS_PRECISION_EXPR, semantic_type,
7337                                   value.value);
7338         }
7339     }
7340
7341   while (1)
7342     {
7343       if (TREE_CODE (constructor_type) == RECORD_TYPE)
7344         {
7345           tree fieldtype;
7346           enum tree_code fieldcode;
7347
7348           if (constructor_fields == 0)
7349             {
7350               pedwarn_init (input_location, 0,
7351                             "excess elements in struct initializer");
7352               break;
7353             }
7354
7355           fieldtype = TREE_TYPE (constructor_fields);
7356           if (fieldtype != error_mark_node)
7357             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
7358           fieldcode = TREE_CODE (fieldtype);
7359
7360           /* Error for non-static initialization of a flexible array member.  */
7361           if (fieldcode == ARRAY_TYPE
7362               && !require_constant_value
7363               && TYPE_SIZE (fieldtype) == NULL_TREE
7364               && TREE_CHAIN (constructor_fields) == NULL_TREE)
7365             {
7366               error_init ("non-static initialization of a flexible array member");
7367               break;
7368             }
7369
7370           /* Accept a string constant to initialize a subarray.  */
7371           if (value.value != 0
7372               && fieldcode == ARRAY_TYPE
7373               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
7374               && string_flag)
7375             value.value = orig_value;
7376           /* Otherwise, if we have come to a subaggregate,
7377              and we don't have an element of its type, push into it.  */
7378           else if (value.value != 0
7379                    && value.value != error_mark_node
7380                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
7381                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
7382                        || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
7383             {
7384               push_init_level (1);
7385               continue;
7386             }
7387
7388           if (value.value)
7389             {
7390               push_member_name (constructor_fields);
7391               output_init_element (value.value, value.original_type,
7392                                    strict_string, fieldtype,
7393                                    constructor_fields, 1, implicit);
7394               RESTORE_SPELLING_DEPTH (constructor_depth);
7395             }
7396           else
7397             /* Do the bookkeeping for an element that was
7398                directly output as a constructor.  */
7399             {
7400               /* For a record, keep track of end position of last field.  */
7401               if (DECL_SIZE (constructor_fields))
7402                 constructor_bit_index
7403                   = size_binop (PLUS_EXPR,
7404                                 bit_position (constructor_fields),
7405                                 DECL_SIZE (constructor_fields));
7406
7407               /* If the current field was the first one not yet written out,
7408                  it isn't now, so update.  */
7409               if (constructor_unfilled_fields == constructor_fields)
7410                 {
7411                   constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
7412                   /* Skip any nameless bit fields.  */
7413                   while (constructor_unfilled_fields != 0
7414                          && DECL_C_BIT_FIELD (constructor_unfilled_fields)
7415                          && DECL_NAME (constructor_unfilled_fields) == 0)
7416                     constructor_unfilled_fields =
7417                       TREE_CHAIN (constructor_unfilled_fields);
7418                 }
7419             }
7420
7421           constructor_fields = TREE_CHAIN (constructor_fields);
7422           /* Skip any nameless bit fields at the beginning.  */
7423           while (constructor_fields != 0
7424                  && DECL_C_BIT_FIELD (constructor_fields)
7425                  && DECL_NAME (constructor_fields) == 0)
7426             constructor_fields = TREE_CHAIN (constructor_fields);
7427         }
7428       else if (TREE_CODE (constructor_type) == UNION_TYPE)
7429         {
7430           tree fieldtype;
7431           enum tree_code fieldcode;
7432
7433           if (constructor_fields == 0)
7434             {
7435               pedwarn_init (input_location, 0,
7436                             "excess elements in union initializer");
7437               break;
7438             }
7439
7440           fieldtype = TREE_TYPE (constructor_fields);
7441           if (fieldtype != error_mark_node)
7442             fieldtype = TYPE_MAIN_VARIANT (fieldtype);
7443           fieldcode = TREE_CODE (fieldtype);
7444
7445           /* Warn that traditional C rejects initialization of unions.
7446              We skip the warning if the value is zero.  This is done
7447              under the assumption that the zero initializer in user
7448              code appears conditioned on e.g. __STDC__ to avoid
7449              "missing initializer" warnings and relies on default
7450              initialization to zero in the traditional C case.
7451              We also skip the warning if the initializer is designated,
7452              again on the assumption that this must be conditional on
7453              __STDC__ anyway (and we've already complained about the
7454              member-designator already).  */
7455           if (!in_system_header && !constructor_designated
7456               && !(value.value && (integer_zerop (value.value)
7457                                    || real_zerop (value.value))))
7458             warning (OPT_Wtraditional, "traditional C rejects initialization "
7459                      "of unions");
7460
7461           /* Accept a string constant to initialize a subarray.  */
7462           if (value.value != 0
7463               && fieldcode == ARRAY_TYPE
7464               && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype))
7465               && string_flag)
7466             value.value = orig_value;
7467           /* Otherwise, if we have come to a subaggregate,
7468              and we don't have an element of its type, push into it.  */
7469           else if (value.value != 0
7470                    && value.value != error_mark_node
7471                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype
7472                    && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE
7473                        || fieldcode == UNION_TYPE || fieldcode == VECTOR_TYPE))
7474             {
7475               push_init_level (1);
7476               continue;
7477             }
7478
7479           if (value.value)
7480             {
7481               push_member_name (constructor_fields);
7482               output_init_element (value.value, value.original_type,
7483                                    strict_string, fieldtype,
7484                                    constructor_fields, 1, implicit);
7485               RESTORE_SPELLING_DEPTH (constructor_depth);
7486             }
7487           else
7488             /* Do the bookkeeping for an element that was
7489                directly output as a constructor.  */
7490             {
7491               constructor_bit_index = DECL_SIZE (constructor_fields);
7492               constructor_unfilled_fields = TREE_CHAIN (constructor_fields);
7493             }
7494
7495           constructor_fields = 0;
7496         }
7497       else if (TREE_CODE (constructor_type) == ARRAY_TYPE)
7498         {
7499           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7500           enum tree_code eltcode = TREE_CODE (elttype);
7501
7502           /* Accept a string constant to initialize a subarray.  */
7503           if (value.value != 0
7504               && eltcode == ARRAY_TYPE
7505               && INTEGRAL_TYPE_P (TREE_TYPE (elttype))
7506               && string_flag)
7507             value.value = orig_value;
7508           /* Otherwise, if we have come to a subaggregate,
7509              and we don't have an element of its type, push into it.  */
7510           else if (value.value != 0
7511                    && value.value != error_mark_node
7512                    && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype
7513                    && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE
7514                        || eltcode == UNION_TYPE || eltcode == VECTOR_TYPE))
7515             {
7516               push_init_level (1);
7517               continue;
7518             }
7519
7520           if (constructor_max_index != 0
7521               && (tree_int_cst_lt (constructor_max_index, constructor_index)
7522                   || integer_all_onesp (constructor_max_index)))
7523             {
7524               pedwarn_init (input_location, 0,
7525                             "excess elements in array initializer");
7526               break;
7527             }
7528
7529           /* Now output the actual element.  */
7530           if (value.value)
7531             {
7532               push_array_bounds (tree_low_cst (constructor_index, 1));
7533               output_init_element (value.value, value.original_type,
7534                                    strict_string, elttype,
7535                                    constructor_index, 1, implicit);
7536               RESTORE_SPELLING_DEPTH (constructor_depth);
7537             }
7538
7539           constructor_index
7540             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
7541
7542           if (!value.value)
7543             /* If we are doing the bookkeeping for an element that was
7544                directly output as a constructor, we must update
7545                constructor_unfilled_index.  */
7546             constructor_unfilled_index = constructor_index;
7547         }
7548       else if (TREE_CODE (constructor_type) == VECTOR_TYPE)
7549         {
7550           tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type));
7551
7552          /* Do a basic check of initializer size.  Note that vectors
7553             always have a fixed size derived from their type.  */
7554           if (tree_int_cst_lt (constructor_max_index, constructor_index))
7555             {
7556               pedwarn_init (input_location, 0,
7557                             "excess elements in vector initializer");
7558               break;
7559             }
7560
7561           /* Now output the actual element.  */
7562           if (value.value)
7563             {
7564               if (TREE_CODE (value.value) == VECTOR_CST)
7565                 elttype = TYPE_MAIN_VARIANT (constructor_type);
7566               output_init_element (value.value, value.original_type,
7567                                    strict_string, elttype,
7568                                    constructor_index, 1, implicit);
7569             }
7570
7571           constructor_index
7572             = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node);
7573
7574           if (!value.value)
7575             /* If we are doing the bookkeeping for an element that was
7576                directly output as a constructor, we must update
7577                constructor_unfilled_index.  */
7578             constructor_unfilled_index = constructor_index;
7579         }
7580
7581       /* Handle the sole element allowed in a braced initializer
7582          for a scalar variable.  */
7583       else if (constructor_type != error_mark_node
7584                && constructor_fields == 0)
7585         {
7586           pedwarn_init (input_location, 0,
7587                         "excess elements in scalar initializer");
7588           break;
7589         }
7590       else
7591         {
7592           if (value.value)
7593             output_init_element (value.value, value.original_type,
7594                                  strict_string, constructor_type,
7595                                  NULL_TREE, 1, implicit);
7596           constructor_fields = 0;
7597         }
7598
7599       /* Handle range initializers either at this level or anywhere higher
7600          in the designator stack.  */
7601       if (constructor_range_stack)
7602         {
7603           struct constructor_range_stack *p, *range_stack;
7604           int finish = 0;
7605
7606           range_stack = constructor_range_stack;
7607           constructor_range_stack = 0;
7608           while (constructor_stack != range_stack->stack)
7609             {
7610               gcc_assert (constructor_stack->implicit);
7611               process_init_element (pop_init_level (1), true);
7612             }
7613           for (p = range_stack;
7614                !p->range_end || tree_int_cst_equal (p->index, p->range_end);
7615                p = p->prev)
7616             {
7617               gcc_assert (constructor_stack->implicit);
7618               process_init_element (pop_init_level (1), true);
7619             }
7620
7621           p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node);
7622           if (tree_int_cst_equal (p->index, p->range_end) && !p->prev)
7623             finish = 1;
7624
7625           while (1)
7626             {
7627               constructor_index = p->index;
7628               constructor_fields = p->fields;
7629               if (finish && p->range_end && p->index == p->range_start)
7630                 {
7631                   finish = 0;
7632                   p->prev = 0;
7633                 }
7634               p = p->next;
7635               if (!p)
7636                 break;
7637               push_init_level (2);
7638               p->stack = constructor_stack;
7639               if (p->range_end && tree_int_cst_equal (p->index, p->range_end))
7640                 p->index = p->range_start;
7641             }
7642
7643           if (!finish)
7644             constructor_range_stack = range_stack;
7645           continue;
7646         }
7647
7648       break;
7649     }
7650
7651   constructor_range_stack = 0;
7652 }
7653 \f
7654 /* Build a complete asm-statement, whose components are a CV_QUALIFIER
7655    (guaranteed to be 'volatile' or null) and ARGS (represented using
7656    an ASM_EXPR node).  */
7657 tree
7658 build_asm_stmt (tree cv_qualifier, tree args)
7659 {
7660   if (!ASM_VOLATILE_P (args) && cv_qualifier)
7661     ASM_VOLATILE_P (args) = 1;
7662   return add_stmt (args);
7663 }
7664
7665 /* Build an asm-expr, whose components are a STRING, some OUTPUTS,
7666    some INPUTS, and some CLOBBERS.  The latter three may be NULL.
7667    SIMPLE indicates whether there was anything at all after the
7668    string in the asm expression -- asm("blah") and asm("blah" : )
7669    are subtly different.  We use a ASM_EXPR node to represent this.  */
7670 tree
7671 build_asm_expr (tree string, tree outputs, tree inputs, tree clobbers,
7672                 bool simple)
7673 {
7674   tree tail;
7675   tree args;
7676   int i;
7677   const char *constraint;
7678   const char **oconstraints;
7679   bool allows_mem, allows_reg, is_inout;
7680   int ninputs, noutputs;
7681
7682   ninputs = list_length (inputs);
7683   noutputs = list_length (outputs);
7684   oconstraints = (const char **) alloca (noutputs * sizeof (const char *));
7685
7686   string = resolve_asm_operand_names (string, outputs, inputs);
7687
7688   /* Remove output conversions that change the type but not the mode.  */
7689   for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail))
7690     {
7691       tree output = TREE_VALUE (tail);
7692
7693       /* ??? Really, this should not be here.  Users should be using a
7694          proper lvalue, dammit.  But there's a long history of using casts
7695          in the output operands.  In cases like longlong.h, this becomes a
7696          primitive form of typechecking -- if the cast can be removed, then
7697          the output operand had a type of the proper width; otherwise we'll
7698          get an error.  Gross, but ...  */
7699       STRIP_NOPS (output);
7700
7701       if (!lvalue_or_else (output, lv_asm))
7702         output = error_mark_node;
7703
7704       if (output != error_mark_node
7705           && (TREE_READONLY (output)
7706               || TYPE_READONLY (TREE_TYPE (output))
7707               || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE
7708                    || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE)
7709                   && C_TYPE_FIELDS_READONLY (TREE_TYPE (output)))))
7710         readonly_error (output, lv_asm);
7711
7712       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
7713       oconstraints[i] = constraint;
7714
7715       if (parse_output_constraint (&constraint, i, ninputs, noutputs,
7716                                    &allows_mem, &allows_reg, &is_inout))
7717         {
7718           /* If the operand is going to end up in memory,
7719              mark it addressable.  */
7720           if (!allows_reg && !c_mark_addressable (output))
7721             output = error_mark_node;
7722         }
7723       else
7724         output = error_mark_node;
7725
7726       TREE_VALUE (tail) = output;
7727     }
7728
7729   for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail))
7730     {
7731       tree input;
7732
7733       constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail)));
7734       input = TREE_VALUE (tail);
7735
7736       if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0,
7737                                   oconstraints, &allows_mem, &allows_reg))
7738         {
7739           /* If the operand is going to end up in memory,
7740              mark it addressable.  */
7741           if (!allows_reg && allows_mem)
7742             {
7743               /* Strip the nops as we allow this case.  FIXME, this really
7744                  should be rejected or made deprecated.  */
7745               STRIP_NOPS (input);
7746               if (!c_mark_addressable (input))
7747                 input = error_mark_node;
7748           }
7749         }
7750       else
7751         input = error_mark_node;
7752
7753       TREE_VALUE (tail) = input;
7754     }
7755
7756   args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers);
7757
7758   /* asm statements without outputs, including simple ones, are treated
7759      as volatile.  */
7760   ASM_INPUT_P (args) = simple;
7761   ASM_VOLATILE_P (args) = (noutputs == 0);
7762
7763   return args;
7764 }
7765 \f
7766 /* Generate a goto statement to LABEL.  */
7767
7768 tree
7769 c_finish_goto_label (tree label)
7770 {
7771   tree decl = lookup_label (label);
7772   if (!decl)
7773     return NULL_TREE;
7774
7775   if (C_DECL_UNJUMPABLE_STMT_EXPR (decl))
7776     {
7777       error ("jump into statement expression");
7778       return NULL_TREE;
7779     }
7780
7781   if (C_DECL_UNJUMPABLE_VM (decl))
7782     {
7783       error ("jump into scope of identifier with variably modified type");
7784       return NULL_TREE;
7785     }
7786
7787   if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl))
7788     {
7789       /* No jump from outside this statement expression context, so
7790          record that there is a jump from within this context.  */
7791       struct c_label_list *nlist;
7792       nlist = XOBNEW (&parser_obstack, struct c_label_list);
7793       nlist->next = label_context_stack_se->labels_used;
7794       nlist->label = decl;
7795       label_context_stack_se->labels_used = nlist;
7796     }
7797
7798   if (!C_DECL_UNDEFINABLE_VM (decl))
7799     {
7800       /* No jump from outside this context context of identifiers with
7801          variably modified type, so record that there is a jump from
7802          within this context.  */
7803       struct c_label_list *nlist;
7804       nlist = XOBNEW (&parser_obstack, struct c_label_list);
7805       nlist->next = label_context_stack_vm->labels_used;
7806       nlist->label = decl;
7807       label_context_stack_vm->labels_used = nlist;
7808     }
7809
7810   TREE_USED (decl) = 1;
7811   return add_stmt (build1 (GOTO_EXPR, void_type_node, decl));
7812 }
7813
7814 /* Generate a computed goto statement to EXPR.  */
7815
7816 tree
7817 c_finish_goto_ptr (tree expr)
7818 {
7819   pedwarn (input_location, OPT_pedantic, "ISO C forbids %<goto *expr;%>");
7820   expr = c_fully_fold (expr, false, NULL);
7821   expr = convert (ptr_type_node, expr);
7822   return add_stmt (build1 (GOTO_EXPR, void_type_node, expr));
7823 }
7824
7825 /* Generate a C `return' statement.  RETVAL is the expression for what
7826    to return, or a null pointer for `return;' with no value.  If
7827    ORIGTYPE is not NULL_TREE, it is the original type of RETVAL.  */
7828
7829 tree
7830 c_finish_return (tree retval, tree origtype)
7831 {
7832   tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt;
7833   bool no_warning = false;
7834   bool npc = false;
7835
7836   if (TREE_THIS_VOLATILE (current_function_decl))
7837     warning (0, "function declared %<noreturn%> has a %<return%> statement");
7838
7839   if (retval)
7840     {
7841       tree semantic_type = NULL_TREE;
7842       npc = null_pointer_constant_p (retval);
7843       if (TREE_CODE (retval) == EXCESS_PRECISION_EXPR)
7844         {
7845           semantic_type = TREE_TYPE (retval);
7846           retval = TREE_OPERAND (retval, 0);
7847         }
7848       retval = c_fully_fold (retval, false, NULL);
7849       if (semantic_type)
7850         retval = build1 (EXCESS_PRECISION_EXPR, semantic_type, retval);
7851     }
7852
7853   if (!retval)
7854     {
7855       current_function_returns_null = 1;
7856       if ((warn_return_type || flag_isoc99)
7857           && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE)
7858         {
7859           pedwarn_c99 (input_location, flag_isoc99 ? 0 : OPT_Wreturn_type,
7860                        "%<return%> with no value, in "
7861                        "function returning non-void");
7862           no_warning = true;
7863         }
7864     }
7865   else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE)
7866     {
7867       current_function_returns_null = 1;
7868       if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
7869         pedwarn (input_location, 0,
7870                  "%<return%> with a value, in function returning void");
7871       else
7872         pedwarn (input_location, OPT_pedantic, "ISO C forbids "
7873                  "%<return%> with expression, in function returning void");
7874     }
7875   else
7876     {
7877       tree t = convert_for_assignment (valtype, retval, origtype, ic_return,
7878                                        npc, NULL_TREE, NULL_TREE, 0);
7879       tree res = DECL_RESULT (current_function_decl);
7880       tree inner;
7881
7882       current_function_returns_value = 1;
7883       if (t == error_mark_node)
7884         return NULL_TREE;
7885
7886       inner = t = convert (TREE_TYPE (res), t);
7887
7888       /* Strip any conversions, additions, and subtractions, and see if
7889          we are returning the address of a local variable.  Warn if so.  */
7890       while (1)
7891         {
7892           switch (TREE_CODE (inner))
7893             {
7894             CASE_CONVERT:
7895             case NON_LVALUE_EXPR:
7896             case PLUS_EXPR:
7897             case POINTER_PLUS_EXPR:
7898               inner = TREE_OPERAND (inner, 0);
7899               continue;
7900
7901             case MINUS_EXPR:
7902               /* If the second operand of the MINUS_EXPR has a pointer
7903                  type (or is converted from it), this may be valid, so
7904                  don't give a warning.  */
7905               {
7906                 tree op1 = TREE_OPERAND (inner, 1);
7907
7908                 while (!POINTER_TYPE_P (TREE_TYPE (op1))
7909                        && (CONVERT_EXPR_P (op1)
7910                            || TREE_CODE (op1) == NON_LVALUE_EXPR))
7911                   op1 = TREE_OPERAND (op1, 0);
7912
7913                 if (POINTER_TYPE_P (TREE_TYPE (op1)))
7914                   break;
7915
7916                 inner = TREE_OPERAND (inner, 0);
7917                 continue;
7918               }
7919
7920             case ADDR_EXPR:
7921               inner = TREE_OPERAND (inner, 0);
7922
7923               while (REFERENCE_CLASS_P (inner)
7924                      && TREE_CODE (inner) != INDIRECT_REF)
7925                 inner = TREE_OPERAND (inner, 0);
7926
7927               if (DECL_P (inner)
7928                   && !DECL_EXTERNAL (inner)
7929                   && !TREE_STATIC (inner)
7930                   && DECL_CONTEXT (inner) == current_function_decl)
7931                 warning (0, "function returns address of local variable");
7932               break;
7933
7934             default:
7935               break;
7936             }
7937
7938           break;
7939         }
7940
7941       retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t);
7942
7943       if (warn_sequence_point)
7944         verify_sequence_points (retval);
7945     }
7946
7947   ret_stmt = build_stmt (RETURN_EXPR, retval);
7948   TREE_NO_WARNING (ret_stmt) |= no_warning;
7949   return add_stmt (ret_stmt);
7950 }
7951 \f
7952 struct c_switch {
7953   /* The SWITCH_EXPR being built.  */
7954   tree switch_expr;
7955
7956   /* The original type of the testing expression, i.e. before the
7957      default conversion is applied.  */
7958   tree orig_type;
7959
7960   /* A splay-tree mapping the low element of a case range to the high
7961      element, or NULL_TREE if there is no high element.  Used to
7962      determine whether or not a new case label duplicates an old case
7963      label.  We need a tree, rather than simply a hash table, because
7964      of the GNU case range extension.  */
7965   splay_tree cases;
7966
7967   /* Number of nested statement expressions within this switch
7968      statement; if nonzero, case and default labels may not
7969      appear.  */
7970   unsigned int blocked_stmt_expr;
7971
7972   /* Scope of outermost declarations of identifiers with variably
7973      modified type within this switch statement; if nonzero, case and
7974      default labels may not appear.  */
7975   unsigned int blocked_vm;
7976
7977   /* The next node on the stack.  */
7978   struct c_switch *next;
7979 };
7980
7981 /* A stack of the currently active switch statements.  The innermost
7982    switch statement is on the top of the stack.  There is no need to
7983    mark the stack for garbage collection because it is only active
7984    during the processing of the body of a function, and we never
7985    collect at that point.  */
7986
7987 struct c_switch *c_switch_stack;
7988
7989 /* Start a C switch statement, testing expression EXP.  Return the new
7990    SWITCH_EXPR.  */
7991
7992 tree
7993 c_start_case (tree exp)
7994 {
7995   tree orig_type = error_mark_node;
7996   struct c_switch *cs;
7997
7998   if (exp != error_mark_node)
7999     {
8000       orig_type = TREE_TYPE (exp);
8001
8002       if (!INTEGRAL_TYPE_P (orig_type))
8003         {
8004           if (orig_type != error_mark_node)
8005             {
8006               error ("switch quantity not an integer");
8007               orig_type = error_mark_node;
8008             }
8009           exp = integer_zero_node;
8010         }
8011       else
8012         {
8013           tree type = TYPE_MAIN_VARIANT (orig_type);
8014
8015           if (!in_system_header
8016               && (type == long_integer_type_node
8017                   || type == long_unsigned_type_node))
8018             warning (OPT_Wtraditional, "%<long%> switch expression not "
8019                      "converted to %<int%> in ISO C");
8020
8021           exp = c_fully_fold (exp, false, NULL);
8022           exp = default_conversion (exp);
8023
8024           if (warn_sequence_point)
8025             verify_sequence_points (exp);
8026         }
8027     }
8028
8029   /* Add this new SWITCH_EXPR to the stack.  */
8030   cs = XNEW (struct c_switch);
8031   cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE);
8032   cs->orig_type = orig_type;
8033   cs->cases = splay_tree_new (case_compare, NULL, NULL);
8034   cs->blocked_stmt_expr = 0;
8035   cs->blocked_vm = 0;
8036   cs->next = c_switch_stack;
8037   c_switch_stack = cs;
8038
8039   return add_stmt (cs->switch_expr);
8040 }
8041
8042 /* Process a case label.  */
8043
8044 tree
8045 do_case (tree low_value, tree high_value)
8046 {
8047   tree label = NULL_TREE;
8048
8049   if (low_value && TREE_CODE (low_value) != INTEGER_CST)
8050     {
8051       low_value = c_fully_fold (low_value, false, NULL);
8052       if (TREE_CODE (low_value) == INTEGER_CST)
8053         pedwarn (input_location, OPT_pedantic,
8054                  "case label is not an integer constant expression");
8055     }
8056
8057   if (high_value && TREE_CODE (high_value) != INTEGER_CST)
8058     {
8059       high_value = c_fully_fold (high_value, false, NULL);
8060       if (TREE_CODE (high_value) == INTEGER_CST)
8061         pedwarn (input_location, OPT_pedantic,
8062                  "case label is not an integer constant expression");
8063     }
8064
8065   if (c_switch_stack && !c_switch_stack->blocked_stmt_expr
8066       && !c_switch_stack->blocked_vm)
8067     {
8068       label = c_add_case_label (c_switch_stack->cases,
8069                                 SWITCH_COND (c_switch_stack->switch_expr),
8070                                 c_switch_stack->orig_type,
8071                                 low_value, high_value);
8072       if (label == error_mark_node)
8073         label = NULL_TREE;
8074     }
8075   else if (c_switch_stack && c_switch_stack->blocked_stmt_expr)
8076     {
8077       if (low_value)
8078         error ("case label in statement expression not containing "
8079                "enclosing switch statement");
8080       else
8081         error ("%<default%> label in statement expression not containing "
8082                "enclosing switch statement");
8083     }
8084   else if (c_switch_stack && c_switch_stack->blocked_vm)
8085     {
8086       if (low_value)
8087         error ("case label in scope of identifier with variably modified "
8088                "type not containing enclosing switch statement");
8089       else
8090         error ("%<default%> label in scope of identifier with variably "
8091                "modified type not containing enclosing switch statement");
8092     }
8093   else if (low_value)
8094     error ("case label not within a switch statement");
8095   else
8096     error ("%<default%> label not within a switch statement");
8097
8098   return label;
8099 }
8100
8101 /* Finish the switch statement.  */
8102
8103 void
8104 c_finish_case (tree body)
8105 {
8106   struct c_switch *cs = c_switch_stack;
8107   location_t switch_location;
8108
8109   SWITCH_BODY (cs->switch_expr) = body;
8110
8111   /* We must not be within a statement expression nested in the switch
8112      at this point; we might, however, be within the scope of an
8113      identifier with variably modified type nested in the switch.  */
8114   gcc_assert (!cs->blocked_stmt_expr);
8115
8116   /* Emit warnings as needed.  */
8117   if (EXPR_HAS_LOCATION (cs->switch_expr))
8118     switch_location = EXPR_LOCATION (cs->switch_expr);
8119   else
8120     switch_location = input_location;
8121   c_do_switch_warnings (cs->cases, switch_location,
8122                         TREE_TYPE (cs->switch_expr),
8123                         SWITCH_COND (cs->switch_expr));
8124
8125   /* Pop the stack.  */
8126   c_switch_stack = cs->next;
8127   splay_tree_delete (cs->cases);
8128   XDELETE (cs);
8129 }
8130 \f
8131 /* Emit an if statement.  IF_LOCUS is the location of the 'if'.  COND,
8132    THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK
8133    may be null.  NESTED_IF is true if THEN_BLOCK contains another IF
8134    statement, and was not surrounded with parenthesis.  */
8135
8136 void
8137 c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
8138                   tree else_block, bool nested_if)
8139 {
8140   tree stmt;
8141
8142   /* Diagnose an ambiguous else if if-then-else is nested inside if-then.  */
8143   if (warn_parentheses && nested_if && else_block == NULL)
8144     {
8145       tree inner_if = then_block;
8146
8147       /* We know from the grammar productions that there is an IF nested
8148          within THEN_BLOCK.  Due to labels and c99 conditional declarations,
8149          it might not be exactly THEN_BLOCK, but should be the last
8150          non-container statement within.  */
8151       while (1)
8152         switch (TREE_CODE (inner_if))
8153           {
8154           case COND_EXPR:
8155             goto found;
8156           case BIND_EXPR:
8157             inner_if = BIND_EXPR_BODY (inner_if);
8158             break;
8159           case STATEMENT_LIST:
8160             inner_if = expr_last (then_block);
8161             break;
8162           case TRY_FINALLY_EXPR:
8163           case TRY_CATCH_EXPR:
8164             inner_if = TREE_OPERAND (inner_if, 0);
8165             break;
8166           default:
8167             gcc_unreachable ();
8168           }
8169     found:
8170
8171       if (COND_EXPR_ELSE (inner_if))
8172          warning (OPT_Wparentheses,
8173                   "%Hsuggest explicit braces to avoid ambiguous %<else%>",
8174                   &if_locus);
8175     }
8176
8177   stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block);
8178   SET_EXPR_LOCATION (stmt, if_locus);
8179   add_stmt (stmt);
8180 }
8181
8182 /* Emit a general-purpose loop construct.  START_LOCUS is the location of
8183    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
8184    is false for DO loops.  INCR is the FOR increment expression.  BODY is
8185    the statement controlled by the loop.  BLAB is the break label.  CLAB is
8186    the continue label.  Everything is allowed to be NULL.  */
8187
8188 void
8189 c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
8190                tree blab, tree clab, bool cond_is_first)
8191 {
8192   tree entry = NULL, exit = NULL, t;
8193
8194   /* If the condition is zero don't generate a loop construct.  */
8195   if (cond && integer_zerop (cond))
8196     {
8197       if (cond_is_first)
8198         {
8199           t = build_and_jump (&blab);
8200           SET_EXPR_LOCATION (t, start_locus);
8201           add_stmt (t);
8202         }
8203     }
8204   else
8205     {
8206       tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
8207
8208       /* If we have an exit condition, then we build an IF with gotos either
8209          out of the loop, or to the top of it.  If there's no exit condition,
8210          then we just build a jump back to the top.  */
8211       exit = build_and_jump (&LABEL_EXPR_LABEL (top));
8212
8213       if (cond && !integer_nonzerop (cond))
8214         {
8215           /* Canonicalize the loop condition to the end.  This means
8216              generating a branch to the loop condition.  Reuse the
8217              continue label, if possible.  */
8218           if (cond_is_first)
8219             {
8220               if (incr || !clab)
8221                 {
8222                   entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
8223                   t = build_and_jump (&LABEL_EXPR_LABEL (entry));
8224                 }
8225               else
8226                 t = build1 (GOTO_EXPR, void_type_node, clab);
8227               SET_EXPR_LOCATION (t, start_locus);
8228               add_stmt (t);
8229             }
8230
8231           t = build_and_jump (&blab);
8232           exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t);
8233           if (cond_is_first)
8234             SET_EXPR_LOCATION (exit, start_locus);
8235           else
8236             SET_EXPR_LOCATION (exit, input_location);
8237         }
8238
8239       add_stmt (top);
8240     }
8241
8242   if (body)
8243     add_stmt (body);
8244   if (clab)
8245     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
8246   if (incr)
8247     add_stmt (incr);
8248   if (entry)
8249     add_stmt (entry);
8250   if (exit)
8251     add_stmt (exit);
8252   if (blab)
8253     add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
8254 }
8255
8256 tree
8257 c_finish_bc_stmt (tree *label_p, bool is_break)
8258 {
8259   bool skip;
8260   tree label = *label_p;
8261
8262   /* In switch statements break is sometimes stylistically used after
8263      a return statement.  This can lead to spurious warnings about
8264      control reaching the end of a non-void function when it is
8265      inlined.  Note that we are calling block_may_fallthru with
8266      language specific tree nodes; this works because
8267      block_may_fallthru returns true when given something it does not
8268      understand.  */
8269   skip = !block_may_fallthru (cur_stmt_list);
8270
8271   if (!label)
8272     {
8273       if (!skip)
8274         *label_p = label = create_artificial_label ();
8275     }
8276   else if (TREE_CODE (label) == LABEL_DECL)
8277     ;
8278   else switch (TREE_INT_CST_LOW (label))
8279     {
8280     case 0:
8281       if (is_break)
8282         error ("break statement not within loop or switch");
8283       else
8284         error ("continue statement not within a loop");
8285       return NULL_TREE;
8286
8287     case 1:
8288       gcc_assert (is_break);
8289       error ("break statement used with OpenMP for loop");
8290       return NULL_TREE;
8291
8292     default:
8293       gcc_unreachable ();
8294     }
8295
8296   if (skip)
8297     return NULL_TREE;
8298
8299   if (!is_break)
8300     add_stmt (build_predict_expr (PRED_CONTINUE, NOT_TAKEN));
8301
8302   return add_stmt (build1 (GOTO_EXPR, void_type_node, label));
8303 }
8304
8305 /* A helper routine for c_process_expr_stmt and c_finish_stmt_expr.  */
8306
8307 static void
8308 emit_side_effect_warnings (tree expr)
8309 {
8310   if (expr == error_mark_node)
8311     ;
8312   else if (!TREE_SIDE_EFFECTS (expr))
8313     {
8314       if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr))
8315         warning (OPT_Wunused_value, "%Hstatement with no effect",
8316                  EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location);
8317     }
8318   else
8319     warn_if_unused_value (expr, input_location);
8320 }
8321
8322 /* Process an expression as if it were a complete statement.  Emit
8323    diagnostics, but do not call ADD_STMT.  */
8324
8325 tree
8326 c_process_expr_stmt (tree expr)
8327 {
8328   if (!expr)
8329     return NULL_TREE;
8330
8331   expr = c_fully_fold (expr, false, NULL);
8332
8333   if (warn_sequence_point)
8334     verify_sequence_points (expr);
8335
8336   if (TREE_TYPE (expr) != error_mark_node
8337       && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
8338       && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
8339     error ("expression statement has incomplete type");
8340
8341   /* If we're not processing a statement expression, warn about unused values.
8342      Warnings for statement expressions will be emitted later, once we figure
8343      out which is the result.  */
8344   if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
8345       && warn_unused_value)
8346     emit_side_effect_warnings (expr);
8347
8348   /* If the expression is not of a type to which we cannot assign a line
8349      number, wrap the thing in a no-op NOP_EXPR.  */
8350   if (DECL_P (expr) || CONSTANT_CLASS_P (expr))
8351     expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr);
8352
8353   if (CAN_HAVE_LOCATION_P (expr))
8354     SET_EXPR_LOCATION (expr, input_location);
8355
8356   return expr;
8357 }
8358
8359 /* Emit an expression as a statement.  */
8360
8361 tree
8362 c_finish_expr_stmt (tree expr)
8363 {
8364   if (expr)
8365     return add_stmt (c_process_expr_stmt (expr));
8366   else
8367     return NULL;
8368 }
8369
8370 /* Do the opposite and emit a statement as an expression.  To begin,
8371    create a new binding level and return it.  */
8372
8373 tree
8374 c_begin_stmt_expr (void)
8375 {
8376   tree ret;
8377   struct c_label_context_se *nstack;
8378   struct c_label_list *glist;
8379
8380   /* We must force a BLOCK for this level so that, if it is not expanded
8381      later, there is a way to turn off the entire subtree of blocks that
8382      are contained in it.  */
8383   keep_next_level ();
8384   ret = c_begin_compound_stmt (true);
8385   if (c_switch_stack)
8386     {
8387       c_switch_stack->blocked_stmt_expr++;
8388       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
8389     }
8390   for (glist = label_context_stack_se->labels_used;
8391        glist != NULL;
8392        glist = glist->next)
8393     {
8394       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1;
8395     }
8396   nstack = XOBNEW (&parser_obstack, struct c_label_context_se);
8397   nstack->labels_def = NULL;
8398   nstack->labels_used = NULL;
8399   nstack->next = label_context_stack_se;
8400   label_context_stack_se = nstack;
8401
8402   /* Mark the current statement list as belonging to a statement list.  */
8403   STATEMENT_LIST_STMT_EXPR (ret) = 1;
8404
8405   return ret;
8406 }
8407
8408 tree
8409 c_finish_stmt_expr (tree body)
8410 {
8411   tree last, type, tmp, val;
8412   tree *last_p;
8413   struct c_label_list *dlist, *glist, *glist_prev = NULL;
8414
8415   body = c_end_compound_stmt (body, true);
8416   if (c_switch_stack)
8417     {
8418       gcc_assert (c_switch_stack->blocked_stmt_expr != 0);
8419       c_switch_stack->blocked_stmt_expr--;
8420     }
8421   /* It is no longer possible to jump to labels defined within this
8422      statement expression.  */
8423   for (dlist = label_context_stack_se->labels_def;
8424        dlist != NULL;
8425        dlist = dlist->next)
8426     {
8427       C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1;
8428     }
8429   /* It is again possible to define labels with a goto just outside
8430      this statement expression.  */
8431   for (glist = label_context_stack_se->next->labels_used;
8432        glist != NULL;
8433        glist = glist->next)
8434     {
8435       C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0;
8436       glist_prev = glist;
8437     }
8438   if (glist_prev != NULL)
8439     glist_prev->next = label_context_stack_se->labels_used;
8440   else
8441     label_context_stack_se->next->labels_used
8442       = label_context_stack_se->labels_used;
8443   label_context_stack_se = label_context_stack_se->next;
8444
8445   /* Locate the last statement in BODY.  See c_end_compound_stmt
8446      about always returning a BIND_EXPR.  */
8447   last_p = &BIND_EXPR_BODY (body);
8448   last = BIND_EXPR_BODY (body);
8449
8450  continue_searching:
8451   if (TREE_CODE (last) == STATEMENT_LIST)
8452     {
8453       tree_stmt_iterator i;
8454
8455       /* This can happen with degenerate cases like ({ }).  No value.  */
8456       if (!TREE_SIDE_EFFECTS (last))
8457         return body;
8458
8459       /* If we're supposed to generate side effects warnings, process
8460          all of the statements except the last.  */
8461       if (warn_unused_value)
8462         {
8463           for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i))
8464             emit_side_effect_warnings (tsi_stmt (i));
8465         }
8466       else
8467         i = tsi_last (last);
8468       last_p = tsi_stmt_ptr (i);
8469       last = *last_p;
8470     }
8471
8472   /* If the end of the list is exception related, then the list was split
8473      by a call to push_cleanup.  Continue searching.  */
8474   if (TREE_CODE (last) == TRY_FINALLY_EXPR
8475       || TREE_CODE (last) == TRY_CATCH_EXPR)
8476     {
8477       last_p = &TREE_OPERAND (last, 0);
8478       last = *last_p;
8479       goto continue_searching;
8480     }
8481
8482   /* In the case that the BIND_EXPR is not necessary, return the
8483      expression out from inside it.  */
8484   if (last == error_mark_node
8485       || (last == BIND_EXPR_BODY (body)
8486           && BIND_EXPR_VARS (body) == NULL))
8487     {
8488       /* Even if this looks constant, do not allow it in a constant
8489          expression.  */
8490       last = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (last), NULL_TREE, last);
8491       C_MAYBE_CONST_EXPR_NON_CONST (last) = 1;
8492       /* Do not warn if the return value of a statement expression is
8493          unused.  */
8494       TREE_NO_WARNING (last) = 1;
8495       return last;
8496     }
8497
8498   /* Extract the type of said expression.  */
8499   type = TREE_TYPE (last);
8500
8501   /* If we're not returning a value at all, then the BIND_EXPR that
8502      we already have is a fine expression to return.  */
8503   if (!type || VOID_TYPE_P (type))
8504     return body;
8505
8506   /* Now that we've located the expression containing the value, it seems
8507      silly to make voidify_wrapper_expr repeat the process.  Create a
8508      temporary of the appropriate type and stick it in a TARGET_EXPR.  */
8509   tmp = create_tmp_var_raw (type, NULL);
8510
8511   /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt.  This avoids
8512      tree_expr_nonnegative_p giving up immediately.  */
8513   val = last;
8514   if (TREE_CODE (val) == NOP_EXPR
8515       && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0)))
8516     val = TREE_OPERAND (val, 0);
8517
8518   *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val);
8519   SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last));
8520
8521   return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE);
8522 }
8523
8524 /* Begin the scope of an identifier of variably modified type, scope
8525    number SCOPE.  Jumping from outside this scope to inside it is not
8526    permitted.  */
8527
8528 void
8529 c_begin_vm_scope (unsigned int scope)
8530 {
8531   struct c_label_context_vm *nstack;
8532   struct c_label_list *glist;
8533
8534   gcc_assert (scope > 0);
8535
8536   /* At file_scope, we don't have to do any processing.  */
8537   if (label_context_stack_vm == NULL)
8538     return;
8539
8540   if (c_switch_stack && !c_switch_stack->blocked_vm)
8541     c_switch_stack->blocked_vm = scope;
8542   for (glist = label_context_stack_vm->labels_used;
8543        glist != NULL;
8544        glist = glist->next)
8545     {
8546       C_DECL_UNDEFINABLE_VM (glist->label) = 1;
8547     }
8548   nstack = XOBNEW (&parser_obstack, struct c_label_context_vm);
8549   nstack->labels_def = NULL;
8550   nstack->labels_used = NULL;
8551   nstack->scope = scope;
8552   nstack->next = label_context_stack_vm;
8553   label_context_stack_vm = nstack;
8554 }
8555
8556 /* End a scope which may contain identifiers of variably modified
8557    type, scope number SCOPE.  */
8558
8559 void
8560 c_end_vm_scope (unsigned int scope)
8561 {
8562   if (label_context_stack_vm == NULL)
8563     return;
8564   if (c_switch_stack && c_switch_stack->blocked_vm == scope)
8565     c_switch_stack->blocked_vm = 0;
8566   /* We may have a number of nested scopes of identifiers with
8567      variably modified type, all at this depth.  Pop each in turn.  */
8568   while (label_context_stack_vm->scope == scope)
8569     {
8570       struct c_label_list *dlist, *glist, *glist_prev = NULL;
8571
8572       /* It is no longer possible to jump to labels defined within this
8573          scope.  */
8574       for (dlist = label_context_stack_vm->labels_def;
8575            dlist != NULL;
8576            dlist = dlist->next)
8577         {
8578           C_DECL_UNJUMPABLE_VM (dlist->label) = 1;
8579         }
8580       /* It is again possible to define labels with a goto just outside
8581          this scope.  */
8582       for (glist = label_context_stack_vm->next->labels_used;
8583            glist != NULL;
8584            glist = glist->next)
8585         {
8586           C_DECL_UNDEFINABLE_VM (glist->label) = 0;
8587           glist_prev = glist;
8588         }
8589       if (glist_prev != NULL)
8590         glist_prev->next = label_context_stack_vm->labels_used;
8591       else
8592         label_context_stack_vm->next->labels_used
8593           = label_context_stack_vm->labels_used;
8594       label_context_stack_vm = label_context_stack_vm->next;
8595     }
8596 }
8597 \f
8598 /* Begin and end compound statements.  This is as simple as pushing
8599    and popping new statement lists from the tree.  */
8600
8601 tree
8602 c_begin_compound_stmt (bool do_scope)
8603 {
8604   tree stmt = push_stmt_list ();
8605   if (do_scope)
8606     push_scope ();
8607   return stmt;
8608 }
8609
8610 tree
8611 c_end_compound_stmt (tree stmt, bool do_scope)
8612 {
8613   tree block = NULL;
8614
8615   if (do_scope)
8616     {
8617       if (c_dialect_objc ())
8618         objc_clear_super_receiver ();
8619       block = pop_scope ();
8620     }
8621
8622   stmt = pop_stmt_list (stmt);
8623   stmt = c_build_bind_expr (block, stmt);
8624
8625   /* If this compound statement is nested immediately inside a statement
8626      expression, then force a BIND_EXPR to be created.  Otherwise we'll
8627      do the wrong thing for ({ { 1; } }) or ({ 1; { } }).  In particular,
8628      STATEMENT_LISTs merge, and thus we can lose track of what statement
8629      was really last.  */
8630   if (cur_stmt_list
8631       && STATEMENT_LIST_STMT_EXPR (cur_stmt_list)
8632       && TREE_CODE (stmt) != BIND_EXPR)
8633     {
8634       stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL);
8635       TREE_SIDE_EFFECTS (stmt) = 1;
8636     }
8637
8638   return stmt;
8639 }
8640
8641 /* Queue a cleanup.  CLEANUP is an expression/statement to be executed
8642    when the current scope is exited.  EH_ONLY is true when this is not
8643    meant to apply to normal control flow transfer.  */
8644
8645 void
8646 push_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only)
8647 {
8648   enum tree_code code;
8649   tree stmt, list;
8650   bool stmt_expr;
8651
8652   code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR;
8653   stmt = build_stmt (code, NULL, cleanup);
8654   add_stmt (stmt);
8655   stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list);
8656   list = push_stmt_list ();
8657   TREE_OPERAND (stmt, 0) = list;
8658   STATEMENT_LIST_STMT_EXPR (list) = stmt_expr;
8659 }
8660 \f
8661 /* Build a binary-operation expression without default conversions.
8662    CODE is the kind of expression to build.
8663    LOCATION is the operator's location.
8664    This function differs from `build' in several ways:
8665    the data type of the result is computed and recorded in it,
8666    warnings are generated if arg data types are invalid,
8667    special handling for addition and subtraction of pointers is known,
8668    and some optimization is done (operations on narrow ints
8669    are done in the narrower type when that gives the same result).
8670    Constant folding is also done before the result is returned.
8671
8672    Note that the operands will never have enumeral types, or function
8673    or array types, because either they will have the default conversions
8674    performed or they have both just been converted to some other type in which
8675    the arithmetic is to be done.  */
8676
8677 tree
8678 build_binary_op (location_t location, enum tree_code code,
8679                  tree orig_op0, tree orig_op1, int convert_p)
8680 {
8681   tree type0, type1, orig_type0, orig_type1;
8682   tree eptype;
8683   enum tree_code code0, code1;
8684   tree op0, op1;
8685   tree ret = error_mark_node;
8686   const char *invalid_op_diag;
8687   bool op0_int_operands, op1_int_operands;
8688   bool int_const, int_const_or_overflow, int_operands;
8689
8690   /* Expression code to give to the expression when it is built.
8691      Normally this is CODE, which is what the caller asked for,
8692      but in some special cases we change it.  */
8693   enum tree_code resultcode = code;
8694
8695   /* Data type in which the computation is to be performed.
8696      In the simplest cases this is the common type of the arguments.  */
8697   tree result_type = NULL;
8698
8699   /* When the computation is in excess precision, the type of the
8700      final EXCESS_PRECISION_EXPR.  */
8701   tree real_result_type = NULL;
8702
8703   /* Nonzero means operands have already been type-converted
8704      in whatever way is necessary.
8705      Zero means they need to be converted to RESULT_TYPE.  */
8706   int converted = 0;
8707
8708   /* Nonzero means create the expression with this type, rather than
8709      RESULT_TYPE.  */
8710   tree build_type = 0;
8711
8712   /* Nonzero means after finally constructing the expression
8713      convert it to this type.  */
8714   tree final_type = 0;
8715
8716   /* Nonzero if this is an operation like MIN or MAX which can
8717      safely be computed in short if both args are promoted shorts.
8718      Also implies COMMON.
8719      -1 indicates a bitwise operation; this makes a difference
8720      in the exact conditions for when it is safe to do the operation
8721      in a narrower mode.  */
8722   int shorten = 0;
8723
8724   /* Nonzero if this is a comparison operation;
8725      if both args are promoted shorts, compare the original shorts.
8726      Also implies COMMON.  */
8727   int short_compare = 0;
8728
8729   /* Nonzero if this is a right-shift operation, which can be computed on the
8730      original short and then promoted if the operand is a promoted short.  */
8731   int short_shift = 0;
8732
8733   /* Nonzero means set RESULT_TYPE to the common type of the args.  */
8734   int common = 0;
8735
8736   /* True means types are compatible as far as ObjC is concerned.  */
8737   bool objc_ok;
8738
8739   /* True means this is an arithmetic operation that may need excess
8740      precision.  */
8741   bool may_need_excess_precision;
8742
8743   if (location == UNKNOWN_LOCATION)
8744     location = input_location;
8745
8746   op0 = orig_op0;
8747   op1 = orig_op1;
8748
8749   op0_int_operands = EXPR_INT_CONST_OPERANDS (orig_op0);
8750   if (op0_int_operands)
8751     op0 = remove_c_maybe_const_expr (op0);
8752   op1_int_operands = EXPR_INT_CONST_OPERANDS (orig_op1);
8753   if (op1_int_operands)
8754     op1 = remove_c_maybe_const_expr (op1);
8755   int_operands = (op0_int_operands && op1_int_operands);
8756   if (int_operands)
8757     {
8758       int_const_or_overflow = (TREE_CODE (orig_op0) == INTEGER_CST
8759                                && TREE_CODE (orig_op1) == INTEGER_CST);
8760       int_const = (int_const_or_overflow
8761                    && !TREE_OVERFLOW (orig_op0)
8762                    && !TREE_OVERFLOW (orig_op1));
8763     }
8764   else
8765     int_const = int_const_or_overflow = false;
8766
8767   if (convert_p)
8768     {
8769       op0 = default_conversion (op0);
8770       op1 = default_conversion (op1);
8771     }
8772
8773   orig_type0 = type0 = TREE_TYPE (op0);
8774   orig_type1 = type1 = TREE_TYPE (op1);
8775
8776   /* The expression codes of the data types of the arguments tell us
8777      whether the arguments are integers, floating, pointers, etc.  */
8778   code0 = TREE_CODE (type0);
8779   code1 = TREE_CODE (type1);
8780
8781   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
8782   STRIP_TYPE_NOPS (op0);
8783   STRIP_TYPE_NOPS (op1);
8784
8785   /* If an error was already reported for one of the arguments,
8786      avoid reporting another error.  */
8787
8788   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
8789     return error_mark_node;
8790
8791   if ((invalid_op_diag
8792        = targetm.invalid_binary_op (code, type0, type1)))
8793     {
8794       error_at (location, invalid_op_diag);
8795       return error_mark_node;
8796     }
8797
8798   switch (code)
8799     {
8800     case PLUS_EXPR:
8801     case MINUS_EXPR:
8802     case MULT_EXPR:
8803     case TRUNC_DIV_EXPR:
8804     case CEIL_DIV_EXPR:
8805     case FLOOR_DIV_EXPR:
8806     case ROUND_DIV_EXPR:
8807     case EXACT_DIV_EXPR:
8808       may_need_excess_precision = true;
8809       break;
8810     default:
8811       may_need_excess_precision = false;
8812       break;
8813     }
8814   if (TREE_CODE (op0) == EXCESS_PRECISION_EXPR)
8815     {
8816       op0 = TREE_OPERAND (op0, 0);
8817       type0 = TREE_TYPE (op0);
8818     }
8819   else if (may_need_excess_precision
8820            && (eptype = excess_precision_type (type0)) != NULL_TREE)
8821     {
8822       type0 = eptype;
8823       op0 = convert (eptype, op0);
8824     }
8825   if (TREE_CODE (op1) == EXCESS_PRECISION_EXPR)
8826     {
8827       op1 = TREE_OPERAND (op1, 0);
8828       type1 = TREE_TYPE (op1);
8829     }
8830   else if (may_need_excess_precision
8831            && (eptype = excess_precision_type (type1)) != NULL_TREE)
8832     {
8833       type1 = eptype;
8834       op1 = convert (eptype, op1);
8835     }
8836
8837   objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE);
8838
8839   switch (code)
8840     {
8841     case PLUS_EXPR:
8842       /* Handle the pointer + int case.  */
8843       if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
8844         {
8845           ret = pointer_int_sum (location, PLUS_EXPR, op0, op1);
8846           goto return_build_binary_op;
8847         }
8848       else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE)
8849         {
8850           ret = pointer_int_sum (location, PLUS_EXPR, op1, op0);
8851           goto return_build_binary_op;
8852         }
8853       else
8854         common = 1;
8855       break;
8856
8857     case MINUS_EXPR:
8858       /* Subtraction of two similar pointers.
8859          We must subtract them as integers, then divide by object size.  */
8860       if (code0 == POINTER_TYPE && code1 == POINTER_TYPE
8861           && comp_target_types (type0, type1))
8862         {
8863           ret = pointer_diff (op0, op1);
8864           goto return_build_binary_op;
8865         }
8866       /* Handle pointer minus int.  Just like pointer plus int.  */
8867       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
8868         {
8869           ret = pointer_int_sum (location, MINUS_EXPR, op0, op1);
8870           goto return_build_binary_op;
8871         }
8872       else
8873         common = 1;
8874       break;
8875
8876     case MULT_EXPR:
8877       common = 1;
8878       break;
8879
8880     case TRUNC_DIV_EXPR:
8881     case CEIL_DIV_EXPR:
8882     case FLOOR_DIV_EXPR:
8883     case ROUND_DIV_EXPR:
8884     case EXACT_DIV_EXPR:
8885       warn_for_div_by_zero (location, op1);
8886
8887       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
8888            || code0 == FIXED_POINT_TYPE
8889            || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
8890           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
8891               || code1 == FIXED_POINT_TYPE
8892               || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE))
8893         {
8894           enum tree_code tcode0 = code0, tcode1 = code1;
8895
8896           if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE)
8897             tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0)));
8898           if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)
8899             tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1)));
8900
8901           if (!((tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)
8902               || (tcode0 == FIXED_POINT_TYPE && tcode1 == FIXED_POINT_TYPE)))
8903             resultcode = RDIV_EXPR;
8904           else
8905             /* Although it would be tempting to shorten always here, that
8906                loses on some targets, since the modulo instruction is
8907                undefined if the quotient can't be represented in the
8908                computation mode.  We shorten only if unsigned or if
8909                dividing by something we know != -1.  */
8910             shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
8911                        || (TREE_CODE (op1) == INTEGER_CST
8912                            && !integer_all_onesp (op1)));
8913           common = 1;
8914         }
8915       break;
8916
8917     case BIT_AND_EXPR:
8918     case BIT_IOR_EXPR:
8919     case BIT_XOR_EXPR:
8920       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
8921         shorten = -1;
8922       /* Allow vector types which are not floating point types.   */
8923       else if (code0 == VECTOR_TYPE
8924                && code1 == VECTOR_TYPE
8925                && !VECTOR_FLOAT_TYPE_P (type0)
8926                && !VECTOR_FLOAT_TYPE_P (type1))
8927         common = 1;
8928       break;
8929
8930     case TRUNC_MOD_EXPR:
8931     case FLOOR_MOD_EXPR:
8932       warn_for_div_by_zero (location, op1);
8933
8934       if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE)
8935         {
8936           /* Although it would be tempting to shorten always here, that loses
8937              on some targets, since the modulo instruction is undefined if the
8938              quotient can't be represented in the computation mode.  We shorten
8939              only if unsigned or if dividing by something we know != -1.  */
8940           shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0))
8941                      || (TREE_CODE (op1) == INTEGER_CST
8942                          && !integer_all_onesp (op1)));
8943           common = 1;
8944         }
8945       break;
8946
8947     case TRUTH_ANDIF_EXPR:
8948     case TRUTH_ORIF_EXPR:
8949     case TRUTH_AND_EXPR:
8950     case TRUTH_OR_EXPR:
8951     case TRUTH_XOR_EXPR:
8952       if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE
8953            || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
8954            || code0 == FIXED_POINT_TYPE)
8955           && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE
8956               || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
8957               || code1 == FIXED_POINT_TYPE))
8958         {
8959           /* Result of these operations is always an int,
8960              but that does not mean the operands should be
8961              converted to ints!  */
8962           result_type = integer_type_node;
8963           op0 = c_common_truthvalue_conversion (location, op0);
8964           op1 = c_common_truthvalue_conversion (location, op1);
8965           converted = 1;
8966         }
8967       if (code == TRUTH_ANDIF_EXPR)
8968         {
8969           int_const_or_overflow = (int_operands
8970                                    && TREE_CODE (orig_op0) == INTEGER_CST
8971                                    && (op0 == truthvalue_false_node
8972                                        || TREE_CODE (orig_op1) == INTEGER_CST));
8973           int_const = (int_const_or_overflow
8974                        && !TREE_OVERFLOW (orig_op0)
8975                        && (op0 == truthvalue_false_node
8976                            || !TREE_OVERFLOW (orig_op1)));
8977         }
8978       else if (code == TRUTH_ORIF_EXPR)
8979         {
8980           int_const_or_overflow = (int_operands
8981                                    && TREE_CODE (orig_op0) == INTEGER_CST
8982                                    && (op0 == truthvalue_true_node
8983                                        || TREE_CODE (orig_op1) == INTEGER_CST));
8984           int_const = (int_const_or_overflow
8985                        && !TREE_OVERFLOW (orig_op0)
8986                        && (op0 == truthvalue_true_node
8987                            || !TREE_OVERFLOW (orig_op1)));
8988         }
8989       break;
8990
8991       /* Shift operations: result has same type as first operand;
8992          always convert second operand to int.
8993          Also set SHORT_SHIFT if shifting rightward.  */
8994
8995     case RSHIFT_EXPR:
8996       if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
8997           && code1 == INTEGER_TYPE)
8998         {
8999           if (TREE_CODE (op1) == INTEGER_CST)
9000             {
9001               if (tree_int_cst_sgn (op1) < 0)
9002                 {
9003                   int_const = false;
9004                   if (skip_evaluation == 0)
9005                     warning (0, "right shift count is negative");
9006                 }
9007               else
9008                 {
9009                   if (!integer_zerop (op1))
9010                     short_shift = 1;
9011
9012                   if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9013                     {
9014                       int_const = false;
9015                       if (skip_evaluation == 0)
9016                         warning (0, "right shift count >= width of type");
9017                     }
9018                 }
9019             }
9020
9021           /* Use the type of the value to be shifted.  */
9022           result_type = type0;
9023           /* Convert the shift-count to an integer, regardless of size
9024              of value being shifted.  */
9025           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9026             op1 = convert (integer_type_node, op1);
9027           /* Avoid converting op1 to result_type later.  */
9028           converted = 1;
9029         }
9030       break;
9031
9032     case LSHIFT_EXPR:
9033       if ((code0 == INTEGER_TYPE || code0 == FIXED_POINT_TYPE)
9034           && code1 == INTEGER_TYPE)
9035         {
9036           if (TREE_CODE (op1) == INTEGER_CST)
9037             {
9038               if (tree_int_cst_sgn (op1) < 0)
9039                 {
9040                   int_const = false;
9041                   if (skip_evaluation == 0)
9042                     warning (0, "left shift count is negative");
9043                 }
9044
9045               else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0)
9046                 {
9047                   int_const = false;
9048                   if (skip_evaluation == 0)
9049                     warning (0, "left shift count >= width of type");
9050                 }
9051             }
9052
9053           /* Use the type of the value to be shifted.  */
9054           result_type = type0;
9055           /* Convert the shift-count to an integer, regardless of size
9056              of value being shifted.  */
9057           if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node)
9058             op1 = convert (integer_type_node, op1);
9059           /* Avoid converting op1 to result_type later.  */
9060           converted = 1;
9061         }
9062       break;
9063
9064     case EQ_EXPR:
9065     case NE_EXPR:
9066       if (FLOAT_TYPE_P (type0) || FLOAT_TYPE_P (type1))
9067         warning_at (location,
9068                     OPT_Wfloat_equal,
9069                     "comparing floating point with == or != is unsafe");
9070       /* Result of comparison is always int,
9071          but don't convert the args to int!  */
9072       build_type = integer_type_node;
9073       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9074            || code0 == FIXED_POINT_TYPE || code0 == COMPLEX_TYPE)
9075           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9076               || code1 == FIXED_POINT_TYPE || code1 == COMPLEX_TYPE))
9077         short_compare = 1;
9078       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
9079         {
9080           tree tt0 = TREE_TYPE (type0);
9081           tree tt1 = TREE_TYPE (type1);
9082           /* Anything compares with void *.  void * compares with anything.
9083              Otherwise, the targets must be compatible
9084              and both must be object or both incomplete.  */
9085           if (comp_target_types (type0, type1))
9086             result_type = common_pointer_type (type0, type1);
9087           else if (VOID_TYPE_P (tt0))
9088             {
9089               /* op0 != orig_op0 detects the case of something
9090                  whose value is 0 but which isn't a valid null ptr const.  */
9091               if (pedantic && !null_pointer_constant_p (orig_op0)
9092                   && TREE_CODE (tt1) == FUNCTION_TYPE)
9093                 pedwarn (location, OPT_pedantic, "ISO C forbids "
9094                          "comparison of %<void *%> with function pointer");
9095             }
9096           else if (VOID_TYPE_P (tt1))
9097             {
9098               if (pedantic && !null_pointer_constant_p (orig_op1)
9099                   && TREE_CODE (tt0) == FUNCTION_TYPE)
9100                 pedwarn (location, OPT_pedantic, "ISO C forbids "
9101                          "comparison of %<void *%> with function pointer");
9102             }
9103           else
9104             /* Avoid warning about the volatile ObjC EH puts on decls.  */
9105             if (!objc_ok)
9106               pedwarn (location, 0,
9107                        "comparison of distinct pointer types lacks a cast");
9108
9109           if (result_type == NULL_TREE)
9110             result_type = ptr_type_node;
9111         }
9112       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
9113         {
9114           if (TREE_CODE (op0) == ADDR_EXPR
9115               && decl_with_nonnull_addr_p (TREE_OPERAND (op0, 0)))
9116             warning_at (location,
9117                         OPT_Waddress, "the address of %qD will never be NULL",
9118                         TREE_OPERAND (op0, 0));
9119           result_type = type0;
9120         }
9121       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
9122         {
9123           if (TREE_CODE (op1) == ADDR_EXPR
9124               && decl_with_nonnull_addr_p (TREE_OPERAND (op1, 0)))
9125             warning_at (location,
9126                         OPT_Waddress, "the address of %qD will never be NULL",
9127                         TREE_OPERAND (op1, 0));
9128           result_type = type1;
9129         }
9130       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9131         {
9132           result_type = type0;
9133           pedwarn (location, 0, "comparison between pointer and integer");
9134         }
9135       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
9136         {
9137           result_type = type1;
9138           pedwarn (location, 0, "comparison between pointer and integer");
9139         }
9140       break;
9141
9142     case LE_EXPR:
9143     case GE_EXPR:
9144     case LT_EXPR:
9145     case GT_EXPR:
9146       build_type = integer_type_node;
9147       if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE
9148            || code0 == FIXED_POINT_TYPE)
9149           && (code1 == INTEGER_TYPE || code1 == REAL_TYPE
9150               || code1 == FIXED_POINT_TYPE))
9151         short_compare = 1;
9152       else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE)
9153         {
9154           if (comp_target_types (type0, type1))
9155             {
9156               result_type = common_pointer_type (type0, type1);
9157               if (!COMPLETE_TYPE_P (TREE_TYPE (type0))
9158                   != !COMPLETE_TYPE_P (TREE_TYPE (type1)))
9159                 pedwarn (location, 0,
9160                          "comparison of complete and incomplete pointers");
9161               else if (TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE)
9162                 pedwarn (location, OPT_pedantic, "ISO C forbids "
9163                          "ordered comparisons of pointers to functions");
9164             }
9165           else
9166             {
9167               result_type = ptr_type_node;
9168               pedwarn (location, 0,
9169                        "comparison of distinct pointer types lacks a cast");
9170             }
9171         }
9172       else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1))
9173         {
9174           result_type = type0;
9175           if (pedantic)
9176             pedwarn (location, OPT_pedantic,
9177                      "ordered comparison of pointer with integer zero");
9178           else if (extra_warnings)
9179             warning_at (location, OPT_Wextra,
9180                      "ordered comparison of pointer with integer zero");
9181         }
9182       else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0))
9183         {
9184           result_type = type1;
9185           pedwarn (location, OPT_pedantic,
9186                    "ordered comparison of pointer with integer zero");
9187         }
9188       else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
9189         {
9190           result_type = type0;
9191           pedwarn (location, 0, "comparison between pointer and integer");
9192         }
9193       else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
9194         {
9195           result_type = type1;
9196           pedwarn (location, 0, "comparison between pointer and integer");
9197         }
9198       break;
9199
9200     default:
9201       gcc_unreachable ();
9202     }
9203
9204   if (code0 == ERROR_MARK || code1 == ERROR_MARK)
9205     return error_mark_node;
9206
9207   if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE
9208       && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1))
9209           || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0),
9210                                                     TREE_TYPE (type1))))
9211     {
9212       binary_op_error (location, code, type0, type1);
9213       return error_mark_node;
9214     }
9215
9216   if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE
9217        || code0 == FIXED_POINT_TYPE || code0 == VECTOR_TYPE)
9218       &&
9219       (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE
9220        || code1 == FIXED_POINT_TYPE || code1 == VECTOR_TYPE))
9221     {
9222       int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE);
9223
9224       if (shorten || common || short_compare)
9225         {
9226           result_type = c_common_type (type0, type1);
9227           if (result_type == error_mark_node)
9228             return error_mark_node;
9229         }
9230
9231       /* For certain operations (which identify themselves by shorten != 0)
9232          if both args were extended from the same smaller type,
9233          do the arithmetic in that type and then extend.
9234
9235          shorten !=0 and !=1 indicates a bitwise operation.
9236          For them, this optimization is safe only if
9237          both args are zero-extended or both are sign-extended.
9238          Otherwise, we might change the result.
9239          Eg, (short)-1 | (unsigned short)-1 is (int)-1
9240          but calculated in (unsigned short) it would be (unsigned short)-1.  */
9241
9242       if (shorten && none_complex)
9243         {
9244           final_type = result_type;
9245           result_type = shorten_binary_op (result_type, op0, op1,
9246                                            shorten == -1);
9247         }
9248
9249       /* Shifts can be shortened if shifting right.  */
9250
9251       if (short_shift)
9252         {
9253           int unsigned_arg;
9254           tree arg0 = get_narrower (op0, &unsigned_arg);
9255
9256           final_type = result_type;
9257
9258           if (arg0 == op0 && final_type == TREE_TYPE (op0))
9259             unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0));
9260
9261           if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type)
9262               /* We can shorten only if the shift count is less than the
9263                  number of bits in the smaller type size.  */
9264               && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0
9265               /* We cannot drop an unsigned shift after sign-extension.  */
9266               && (!TYPE_UNSIGNED (final_type) || unsigned_arg))
9267             {
9268               /* Do an unsigned shift if the operand was zero-extended.  */
9269               result_type
9270                 = c_common_signed_or_unsigned_type (unsigned_arg,
9271                                                     TREE_TYPE (arg0));
9272               /* Convert value-to-be-shifted to that type.  */
9273               if (TREE_TYPE (op0) != result_type)
9274                 op0 = convert (result_type, op0);
9275               converted = 1;
9276             }
9277         }
9278
9279       /* Comparison operations are shortened too but differently.
9280          They identify themselves by setting short_compare = 1.  */
9281
9282       if (short_compare)
9283         {
9284           /* Don't write &op0, etc., because that would prevent op0
9285              from being kept in a register.
9286              Instead, make copies of the our local variables and
9287              pass the copies by reference, then copy them back afterward.  */
9288           tree xop0 = op0, xop1 = op1, xresult_type = result_type;
9289           enum tree_code xresultcode = resultcode;
9290           tree val
9291             = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode);
9292
9293           if (val != 0)
9294             {
9295               ret = val;
9296               goto return_build_binary_op;
9297             }
9298
9299           op0 = xop0, op1 = xop1;
9300           converted = 1;
9301           resultcode = xresultcode;
9302
9303           if (!skip_evaluation)
9304             {
9305               bool op0_maybe_const = true;
9306               bool op1_maybe_const = true;
9307               tree orig_op0_folded, orig_op1_folded;
9308
9309               if (in_late_binary_op)
9310                 {
9311                   orig_op0_folded = orig_op0;
9312                   orig_op1_folded = orig_op1;
9313                 }
9314               else
9315                 {
9316                   /* Fold for the sake of possible warnings, as in
9317                      build_conditional_expr.  This requires the
9318                      "original" values to be folded, not just op0 and
9319                      op1.  */
9320                   op0 = c_fully_fold (op0, require_constant_value,
9321                                       &op0_maybe_const);
9322                   op1 = c_fully_fold (op1, require_constant_value,
9323                                       &op1_maybe_const);
9324                   orig_op0_folded = c_fully_fold (orig_op0,
9325                                                   require_constant_value,
9326                                                   NULL);
9327                   orig_op1_folded = c_fully_fold (orig_op1,
9328                                                   require_constant_value,
9329                                                   NULL);
9330                 }
9331
9332               if (warn_sign_compare)
9333                 warn_for_sign_compare (location, orig_op0_folded,
9334                                        orig_op1_folded, op0, op1,
9335                                        result_type, resultcode);
9336               if (!in_late_binary_op)
9337                 {
9338                   if (!op0_maybe_const || TREE_CODE (op0) != INTEGER_CST)
9339                     {
9340                       op0 = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (op0),
9341                                     NULL, op0);
9342                       C_MAYBE_CONST_EXPR_NON_CONST (op0) = !op0_maybe_const;
9343                     }
9344                   if (!op1_maybe_const || TREE_CODE (op1) != INTEGER_CST)
9345                     {
9346                       op1 = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (op1),
9347                                     NULL, op1);
9348                       C_MAYBE_CONST_EXPR_NON_CONST (op1) = !op1_maybe_const;
9349                     }
9350                 }
9351             }
9352         }
9353     }
9354
9355   /* At this point, RESULT_TYPE must be nonzero to avoid an error message.
9356      If CONVERTED is zero, both args will be converted to type RESULT_TYPE.
9357      Then the expression will be built.
9358      It will be given type FINAL_TYPE if that is nonzero;
9359      otherwise, it will be given type RESULT_TYPE.  */
9360
9361   if (!result_type)
9362     {
9363       binary_op_error (location, code, TREE_TYPE (op0), TREE_TYPE (op1));
9364       return error_mark_node;
9365     }
9366
9367   if (!converted)
9368     {
9369       if (TREE_TYPE (op0) != result_type)
9370         op0 = convert_and_check (result_type, op0);
9371       if (TREE_TYPE (op1) != result_type)
9372         op1 = convert_and_check (result_type, op1);
9373
9374       /* This can happen if one operand has a vector type, and the other
9375          has a different type.  */
9376       if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK)
9377         return error_mark_node;
9378     }
9379
9380   if (build_type == NULL_TREE)
9381     {
9382       build_type = result_type;
9383       if (type0 != orig_type0 || type1 != orig_type1)
9384         {
9385           gcc_assert (may_need_excess_precision && common);
9386           real_result_type = c_common_type (orig_type0, orig_type1);
9387         }
9388     }
9389
9390   /* Treat expressions in initializers specially as they can't trap.  */
9391   if (int_const_or_overflow)
9392     ret = (require_constant_value
9393            ? fold_build2_initializer (resultcode, build_type, op0, op1)
9394            : fold_build2 (resultcode, build_type, op0, op1));
9395   else
9396     ret = build2 (resultcode, build_type, op0, op1);
9397   if (final_type != 0)
9398     ret = convert (final_type, ret);
9399
9400  return_build_binary_op:
9401   gcc_assert (ret != error_mark_node);
9402   if (TREE_CODE (ret) == INTEGER_CST && !TREE_OVERFLOW (ret) && !int_const)
9403     ret = (int_operands
9404            ? note_integer_operands (ret)
9405            : build1 (NOP_EXPR, TREE_TYPE (ret), ret));
9406   else if (TREE_CODE (ret) != INTEGER_CST && int_operands
9407            && !in_late_binary_op)
9408     ret = note_integer_operands (ret);
9409   if (real_result_type)
9410     ret = build1 (EXCESS_PRECISION_EXPR, real_result_type, ret);
9411   protected_set_expr_location (ret, location);
9412   return ret;
9413 }
9414
9415
9416 /* Convert EXPR to be a truth-value, validating its type for this
9417    purpose.  LOCATION is the source location for the expression.  */
9418
9419 tree
9420 c_objc_common_truthvalue_conversion (location_t location, tree expr)
9421 {
9422   bool int_const, int_operands;
9423
9424   switch (TREE_CODE (TREE_TYPE (expr)))
9425     {
9426     case ARRAY_TYPE:
9427       error_at (location, "used array that cannot be converted to pointer where scalar is required");
9428       return error_mark_node;
9429
9430     case RECORD_TYPE:
9431       error_at (location, "used struct type value where scalar is required");
9432       return error_mark_node;
9433
9434     case UNION_TYPE:
9435       error_at (location, "used union type value where scalar is required");
9436       return error_mark_node;
9437
9438     case FUNCTION_TYPE:
9439       gcc_unreachable ();
9440
9441     default:
9442       break;
9443     }
9444
9445   int_const = (TREE_CODE (expr) == INTEGER_CST && !TREE_OVERFLOW (expr));
9446   int_operands = EXPR_INT_CONST_OPERANDS (expr);
9447   if (int_operands)
9448     expr = remove_c_maybe_const_expr (expr);
9449
9450   /* ??? Should we also give an error for void and vectors rather than
9451      leaving those to give errors later?  */
9452   expr = c_common_truthvalue_conversion (location, expr);
9453
9454   if (TREE_CODE (expr) == INTEGER_CST && int_operands && !int_const)
9455     {
9456       if (TREE_OVERFLOW (expr))
9457         return expr;
9458       else
9459         return note_integer_operands (expr);
9460     }
9461   if (TREE_CODE (expr) == INTEGER_CST && !int_const)
9462     return build1 (NOP_EXPR, TREE_TYPE (expr), expr);
9463   return expr;
9464 }
9465 \f
9466
9467 /* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as
9468    required.  */
9469
9470 tree
9471 c_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, bool *se)
9472 {
9473   if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR)
9474     {
9475       tree decl = COMPOUND_LITERAL_EXPR_DECL (expr);
9476       /* Executing a compound literal inside a function reinitializes
9477          it.  */
9478       if (!TREE_STATIC (decl))
9479         *se = true;
9480       return decl;
9481     }
9482   else
9483     return expr;
9484 }
9485 \f
9486 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
9487
9488 tree
9489 c_begin_omp_parallel (void)
9490 {
9491   tree block;
9492
9493   keep_next_level ();
9494   block = c_begin_compound_stmt (true);
9495
9496   return block;
9497 }
9498
9499 /* Generate OMP_PARALLEL, with CLAUSES and BLOCK as its compound statement.  */
9500
9501 tree
9502 c_finish_omp_parallel (tree clauses, tree block)
9503 {
9504   tree stmt;
9505
9506   block = c_end_compound_stmt (block, true);
9507
9508   stmt = make_node (OMP_PARALLEL);
9509   TREE_TYPE (stmt) = void_type_node;
9510   OMP_PARALLEL_CLAUSES (stmt) = clauses;
9511   OMP_PARALLEL_BODY (stmt) = block;
9512
9513   return add_stmt (stmt);
9514 }
9515
9516 /* Like c_begin_compound_stmt, except force the retention of the BLOCK.  */
9517
9518 tree
9519 c_begin_omp_task (void)
9520 {
9521   tree block;
9522
9523   keep_next_level ();
9524   block = c_begin_compound_stmt (true);
9525
9526   return block;
9527 }
9528
9529 /* Generate OMP_TASK, with CLAUSES and BLOCK as its compound statement.  */
9530
9531 tree
9532 c_finish_omp_task (tree clauses, tree block)
9533 {
9534   tree stmt;
9535
9536   block = c_end_compound_stmt (block, true);
9537
9538   stmt = make_node (OMP_TASK);
9539   TREE_TYPE (stmt) = void_type_node;
9540   OMP_TASK_CLAUSES (stmt) = clauses;
9541   OMP_TASK_BODY (stmt) = block;
9542
9543   return add_stmt (stmt);
9544 }
9545
9546 /* For all elements of CLAUSES, validate them vs OpenMP constraints.
9547    Remove any elements from the list that are invalid.  */
9548
9549 tree
9550 c_finish_omp_clauses (tree clauses)
9551 {
9552   bitmap_head generic_head, firstprivate_head, lastprivate_head;
9553   tree c, t, *pc = &clauses;
9554   const char *name;
9555
9556   bitmap_obstack_initialize (NULL);
9557   bitmap_initialize (&generic_head, &bitmap_default_obstack);
9558   bitmap_initialize (&firstprivate_head, &bitmap_default_obstack);
9559   bitmap_initialize (&lastprivate_head, &bitmap_default_obstack);
9560
9561   for (pc = &clauses, c = clauses; c ; c = *pc)
9562     {
9563       bool remove = false;
9564       bool need_complete = false;
9565       bool need_implicitly_determined = false;
9566
9567       switch (OMP_CLAUSE_CODE (c))
9568         {
9569         case OMP_CLAUSE_SHARED:
9570           name = "shared";
9571           need_implicitly_determined = true;
9572           goto check_dup_generic;
9573
9574         case OMP_CLAUSE_PRIVATE:
9575           name = "private";
9576           need_complete = true;
9577           need_implicitly_determined = true;
9578           goto check_dup_generic;
9579
9580         case OMP_CLAUSE_REDUCTION:
9581           name = "reduction";
9582           need_implicitly_determined = true;
9583           t = OMP_CLAUSE_DECL (c);
9584           if (AGGREGATE_TYPE_P (TREE_TYPE (t))
9585               || POINTER_TYPE_P (TREE_TYPE (t)))
9586             {
9587               error ("%qE has invalid type for %<reduction%>", t);
9588               remove = true;
9589             }
9590           else if (FLOAT_TYPE_P (TREE_TYPE (t)))
9591             {
9592               enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c);
9593               const char *r_name = NULL;
9594
9595               switch (r_code)
9596                 {
9597                 case PLUS_EXPR:
9598                 case MULT_EXPR:
9599                 case MINUS_EXPR:
9600                   break;
9601                 case BIT_AND_EXPR:
9602                   r_name = "&";
9603                   break;
9604                 case BIT_XOR_EXPR:
9605                   r_name = "^";
9606                   break;
9607                 case BIT_IOR_EXPR:
9608                   r_name = "|";
9609                   break;
9610                 case TRUTH_ANDIF_EXPR:
9611                   r_name = "&&";
9612                   break;
9613                 case TRUTH_ORIF_EXPR:
9614                   r_name = "||";
9615                   break;
9616                 default:
9617                   gcc_unreachable ();
9618                 }
9619               if (r_name)
9620                 {
9621                   error ("%qE has invalid type for %<reduction(%s)%>",
9622                          t, r_name);
9623                   remove = true;
9624                 }
9625             }
9626           goto check_dup_generic;
9627
9628         case OMP_CLAUSE_COPYPRIVATE:
9629           name = "copyprivate";
9630           goto check_dup_generic;
9631
9632         case OMP_CLAUSE_COPYIN:
9633           name = "copyin";
9634           t = OMP_CLAUSE_DECL (c);
9635           if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t))
9636             {
9637               error ("%qE must be %<threadprivate%> for %<copyin%>", t);
9638               remove = true;
9639             }
9640           goto check_dup_generic;
9641
9642         check_dup_generic:
9643           t = OMP_CLAUSE_DECL (c);
9644           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9645             {
9646               error ("%qE is not a variable in clause %qs", t, name);
9647               remove = true;
9648             }
9649           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
9650                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t))
9651                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
9652             {
9653               error ("%qE appears more than once in data clauses", t);
9654               remove = true;
9655             }
9656           else
9657             bitmap_set_bit (&generic_head, DECL_UID (t));
9658           break;
9659
9660         case OMP_CLAUSE_FIRSTPRIVATE:
9661           name = "firstprivate";
9662           t = OMP_CLAUSE_DECL (c);
9663           need_complete = true;
9664           need_implicitly_determined = true;
9665           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9666             {
9667               error ("%qE is not a variable in clause %<firstprivate%>", t);
9668               remove = true;
9669             }
9670           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
9671                    || bitmap_bit_p (&firstprivate_head, DECL_UID (t)))
9672             {
9673               error ("%qE appears more than once in data clauses", t);
9674               remove = true;
9675             }
9676           else
9677             bitmap_set_bit (&firstprivate_head, DECL_UID (t));
9678           break;
9679
9680         case OMP_CLAUSE_LASTPRIVATE:
9681           name = "lastprivate";
9682           t = OMP_CLAUSE_DECL (c);
9683           need_complete = true;
9684           need_implicitly_determined = true;
9685           if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL)
9686             {
9687               error ("%qE is not a variable in clause %<lastprivate%>", t);
9688               remove = true;
9689             }
9690           else if (bitmap_bit_p (&generic_head, DECL_UID (t))
9691                    || bitmap_bit_p (&lastprivate_head, DECL_UID (t)))
9692             {
9693               error ("%qE appears more than once in data clauses", t);
9694               remove = true;
9695             }
9696           else
9697             bitmap_set_bit (&lastprivate_head, DECL_UID (t));
9698           break;
9699
9700         case OMP_CLAUSE_IF:
9701         case OMP_CLAUSE_NUM_THREADS:
9702         case OMP_CLAUSE_SCHEDULE:
9703         case OMP_CLAUSE_NOWAIT:
9704         case OMP_CLAUSE_ORDERED:
9705         case OMP_CLAUSE_DEFAULT:
9706         case OMP_CLAUSE_UNTIED:
9707         case OMP_CLAUSE_COLLAPSE:
9708           pc = &OMP_CLAUSE_CHAIN (c);
9709           continue;
9710
9711         default:
9712           gcc_unreachable ();
9713         }
9714
9715       if (!remove)
9716         {
9717           t = OMP_CLAUSE_DECL (c);
9718
9719           if (need_complete)
9720             {
9721               t = require_complete_type (t);
9722               if (t == error_mark_node)
9723                 remove = true;
9724             }
9725
9726           if (need_implicitly_determined)
9727             {
9728               const char *share_name = NULL;
9729
9730               if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t))
9731                 share_name = "threadprivate";
9732               else switch (c_omp_predetermined_sharing (t))
9733                 {
9734                 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
9735                   break;
9736                 case OMP_CLAUSE_DEFAULT_SHARED:
9737                   share_name = "shared";
9738                   break;
9739                 case OMP_CLAUSE_DEFAULT_PRIVATE:
9740                   share_name = "private";
9741                   break;
9742                 default:
9743                   gcc_unreachable ();
9744                 }
9745               if (share_name)
9746                 {
9747                   error ("%qE is predetermined %qs for %qs",
9748                          t, share_name, name);
9749                   remove = true;
9750                 }
9751             }
9752         }
9753
9754       if (remove)
9755         *pc = OMP_CLAUSE_CHAIN (c);
9756       else
9757         pc = &OMP_CLAUSE_CHAIN (c);
9758     }
9759
9760   bitmap_obstack_release (NULL);
9761   return clauses;
9762 }
9763
9764 /* Make a variant type in the proper way for C/C++, propagating qualifiers
9765    down to the element type of an array.  */
9766
9767 tree
9768 c_build_qualified_type (tree type, int type_quals)
9769 {
9770   if (type == error_mark_node)
9771     return type;
9772
9773   if (TREE_CODE (type) == ARRAY_TYPE)
9774     {
9775       tree t;
9776       tree element_type = c_build_qualified_type (TREE_TYPE (type),
9777                                                   type_quals);
9778
9779       /* See if we already have an identically qualified type.  */
9780       for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
9781         {
9782           if (TYPE_QUALS (strip_array_types (t)) == type_quals
9783               && TYPE_NAME (t) == TYPE_NAME (type)
9784               && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
9785               && attribute_list_equal (TYPE_ATTRIBUTES (t),
9786                                        TYPE_ATTRIBUTES (type)))
9787             break;
9788         }
9789       if (!t)
9790         {
9791           tree domain = TYPE_DOMAIN (type);
9792
9793           t = build_variant_type_copy (type);
9794           TREE_TYPE (t) = element_type;
9795
9796           if (TYPE_STRUCTURAL_EQUALITY_P (element_type)
9797               || (domain && TYPE_STRUCTURAL_EQUALITY_P (domain)))
9798             SET_TYPE_STRUCTURAL_EQUALITY (t);
9799           else if (TYPE_CANONICAL (element_type) != element_type
9800                    || (domain && TYPE_CANONICAL (domain) != domain))
9801             {
9802               tree unqualified_canon
9803                 = build_array_type (TYPE_CANONICAL (element_type),
9804                                     domain? TYPE_CANONICAL (domain)
9805                                           : NULL_TREE);
9806               TYPE_CANONICAL (t)
9807                 = c_build_qualified_type (unqualified_canon, type_quals);
9808             }
9809           else
9810             TYPE_CANONICAL (t) = t;
9811         }
9812       return t;
9813     }
9814
9815   /* A restrict-qualified pointer type must be a pointer to object or
9816      incomplete type.  Note that the use of POINTER_TYPE_P also allows
9817      REFERENCE_TYPEs, which is appropriate for C++.  */
9818   if ((type_quals & TYPE_QUAL_RESTRICT)
9819       && (!POINTER_TYPE_P (type)
9820           || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
9821     {
9822       error ("invalid use of %<restrict%>");
9823       type_quals &= ~TYPE_QUAL_RESTRICT;
9824     }
9825
9826   return build_qualified_type (type, type_quals);
9827 }