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