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