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